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

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

@@ -1 +1,877 @@
-"use strict";var S=Object.defineProperty;var ae=Object.getOwnPropertyDescriptor;var se=Object.getOwnPropertyNames;var xe=Object.prototype.hasOwnProperty;var pe=(r,e)=>{for(var n in e)S(r,n,{get:e[n],enumerable:!0})},le=(r,e,n,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of se(e))!xe.call(r,o)&&o!==n&&S(r,o,{get:()=>e[o],enumerable:!(t=ae(e,o))||t.enumerable});return r};var fe=r=>le(S({},"__esModule",{value:!0}),r);var Fe={};pe(Fe,{abs:()=>O,acos:()=>Jr,acosh:()=>oe,add:()=>_,addComplex:()=>Pr,addFractions:()=>xr,addVectors2D:()=>Cr,angleBetween2D:()=>Sr,argumentComplex:()=>w,asin:()=>Wr,asinh:()=>te,atan:()=>Kr,atan2:()=>vr,atanh:()=>ue,average:()=>K,cbrt:()=>cr,ceil:()=>k,clamp:()=>M,conjugateComplex:()=>Lr,cos:()=>Hr,cosh:()=>ee,cot:()=>me,crossProduct3D:()=>Mr,csc:()=>ce,degToGrad:()=>kr,degToRad:()=>Br,distance2D:()=>Rr,distance3D:()=>Fr,divide:()=>$,divideComplex:()=>_r,dotProduct2D:()=>T,dotProduct3D:()=>zr,evaluatePolynomial:()=>sr,exp:()=>ir,factorial:()=>Y,floor:()=>Q,fromPolarComplex:()=>g,gcd:()=>h,gradToDeg:()=>Qr,invLerp:()=>F,lcm:()=>H,lerp:()=>R,lerp2D:()=>Ir,ln:()=>nr,lnComplex:()=>Gr,log:()=>ur,log10:()=>tr,log2:()=>or,magnitude2D:()=>y,magnitude3D:()=>I,magnitude4D:()=>gr,magnitudeComplex:()=>V,mapRange:()=>U,max:()=>J,median:()=>rr,min:()=>W,modulo:()=>j,multiplyComplex:()=>P,multiplyFractions:()=>pr,normalize:()=>hr,normalize2D:()=>Vr,normalize3D:()=>wr,normalizeDegrees:()=>Xr,normalizeRadians:()=>Zr,nthRoot:()=>mr,percentage:()=>lr,power:()=>G,powerComplex:()=>jr,product:()=>er,radToDeg:()=>Or,range:()=>br,rotate2D:()=>Tr,round:()=>b,scaleVector2D:()=>Nr,sec:()=>ie,sign:()=>X,simplifyFraction:()=>C,sin:()=>Yr,sinh:()=>re,solveQuadratic:()=>ar,sqrt:()=>B,sqrtComplex:()=>$r,subtract:()=>L,subtractComplex:()=>qr,subtractVectors2D:()=>Er,sum:()=>v,tan:()=>Ur,tanh:()=>ne,toBase:()=>fr,toOrdinal:()=>Dr,toPolarComplex:()=>q,trunc:()=>Z,truncateDecimals:()=>dr,wrap:()=>yr});module.exports=fe(Fe);function _(r,e){return r+e}function L(r,e){return r-e}var $=(r,e,n)=>e===0?n!==void 0?n:NaN:r/e;function j(r,e){return r%e}function G(r,e){return Math.pow(r,e)}function B(r){if(r<0)throw new Error("Cannot calculate square root of negative number");return Math.sqrt(r)}function O(r){return Math.abs(r)}var b=(r,e=0,n="round")=>{if(n==="david")return De(r,e,n);if(!Number.isFinite(r))return r;if(e===0)return Math[n](r);if(e<0){let z=10**-e;return Math[n](r/z)*z}let t=10**e,o=Math.pow(2,-52),u=r*t,s=Math.sign(u)*o*Math.abs(u),l;switch(n){case"round":l=Math.round(u+s);break;case"ceil":l=Math.ceil(u-o);break;case"floor":l=Math.floor(u+o);break;case"trunc":l=u<0?Math.ceil(u):Math.floor(u);break;default:l=Math.round(u+s)}return l/t},De=(r,e=0,n="round")=>{let t=Math.abs(r),o=r<0?-1:1;if(e===0)return Math.round(t)*o;if(!Number.isFinite(t))return t*o;let u=10**e,s=t*u,l=Math.pow(2,-53),z=Math.sign(s)*l*Math.abs(s);return s+=z,Math.round(s)/u*o},k=(r,e=0)=>b(r,e,"ceil"),Q=(r,e=0)=>b(r,e,"floor"),Z=(r,e=0)=>b(r,e,"trunc"),M=(r,e,n)=>(e>n&&([e,n]=[n,e]),r<e?e:r>n?n:r);function X(r){return r>0?1:r<0?-1:0}function Y(r){if(!Number.isInteger(r)||r<0)throw new Error("Factorial is only defined for non-negative integers");if(r===0||r===1)return 1;let e=1;for(let n=2;n<=r;n++)e*=n;return e}function h(r,e){for(r=Math.abs(r),e=Math.abs(e);e!==0;){let n=e;e=r%e,r=n}return r}function H(r,e){return Math.abs(r*e)/h(r,e)}function R(r,e,n){return r+(e-r)*M(n,0,1)}var F=(r,e,n)=>M((n-r)/(e-r),0,1),U=(r,e,n,t,o)=>{let u=F(e,n,r);return R(t,o,u)};function W(...r){return Math.min(...r)}function J(...r){return Math.max(...r)}var K=(...r)=>{if(!Array.isArray(r)||r.length===0)return 0;let e=0,n=0;for(let t of r)Number.isFinite(t)&&(e+=t,n++);return n===0?0:e/n},v=(...r)=>Array.isArray(r)?r.reduce((e,n)=>e+(Number.isFinite(n)?n:0),0):0,rr=(...r)=>{if(!Array.isArray(r)||r.length===0)return 0;let e=r.filter(Number.isFinite);if(e.length===0)return 0;e.sort((t,o)=>t-o);let n=Math.floor(e.length/2);return e.length%2===0?(e[n-1]+e[n])/2:e[n]};function er(...r){return r.reduce((e,n)=>e*n,1)}function nr(r){if(r<=0)throw new Error("Natural logarithm is only defined for positive numbers");return Math.log(r)}function tr(r){if(r<=0)throw new Error("Logarithm is only defined for positive numbers");return Math.log10(r)}function or(r){if(r<=0)throw new Error("Logarithm is only defined for positive numbers");return Math.log2(r)}function ur(r,e){if(r<=0||e<=0)throw new Error("Logarithm is only defined for positive numbers and bases");return Math.log(r)/Math.log(e)}function ir(r){return Math.exp(r)}function cr(r){return Math.cbrt(r)}function mr(r,e){if(e===0)throw new Error("Cannot calculate 0th root");if(r<0&&e%2===0)throw new Error("Cannot calculate even root of negative number");let n=1/e;return Math.sign(r)*Math.pow(Math.abs(r),n)}function ar(r,e,n){if(r===0)return e===0?[]:[-n/e];let t=e*e-4*r*n;if(t<0)return[];if(t===0)return[-e/(2*r)];{let o=Math.sqrt(t);return[(-e-o)/(2*r),(-e+o)/(2*r)]}}function sr(r,e){let n=0;for(let t=0;t<r.length;t++)n=n*e+r[t];return n}function C(r){let e=h(r.numerator,r.denominator);return{numerator:r.numerator/e,denominator:r.denominator/e}}function xr(r,e){let n=r.numerator*e.denominator+e.numerator*r.denominator,t=r.denominator*e.denominator;return C({numerator:n,denominator:t})}function pr(r,e){let n=r.numerator*e.numerator,t=r.denominator*e.denominator;return C({numerator:n,denominator:t})}var lr=(r,e,n=2)=>{if(e===0)return 0;let t=r/e*100;return b(t,n)},fr=(r,e,n=1)=>{if(e<2||e>36)throw new Error("Base must be between 2 and 36");return r.toString(e).padStart(n,"0")},Dr=r=>{let e=["th","st","nd","rd"],n=r%100;return r+(e[(n-20)%10]||e[n]||e[0])},br=(r,e,n=1)=>{let t=[];if(n===0)return t;if(n>0)for(let o=r;o<e;o+=n)t.push(o);else for(let o=r;o>e;o+=n)t.push(o);return t},dr=(r,e)=>{if(!Number.isFinite(r))return r;let n=10**e;return Math.trunc(r*n)/n},hr=(r,e,n)=>e===n?0:(r-e)/(n-e),yr=(r,e,n)=>{let t=n-e;return((r-e)%t+t)%t+e};function m(r,e){if(typeof r!="number"||!Number.isFinite(r))throw new Error(`${e} must be a finite number, got ${r}`)}function p(r){return Math.abs(r)<1e-9}function i(r,e="Vector2D"){if(!r||typeof r!="object")throw new Error(`${e} must be an object`);m(r.x,`${e}.x`),m(r.y,`${e}.y`)}function f(r,e="Vector3D"){if(!r||typeof r!="object")throw new Error(`${e} must be an object`);m(r.x,`${e}.x`),m(r.y,`${e}.y`),m(r.z,`${e}.z`)}function be(r,e="Vector4D"){if(!r||typeof r!="object")throw new Error(`${e} must be an object`);m(r.x,`${e}.x`),m(r.y,`${e}.y`),m(r.z,`${e}.z`),m(r.w,`${e}.w`)}function y(r){i(r);let e=Math.sqrt(r.x*r.x+r.y*r.y);return p(e)?0:e}function I(r){f(r);let e=Math.sqrt(r.x*r.x+r.y*r.y+r.z*r.z);return p(e)?0:e}function gr(r){be(r);let e=Math.sqrt(r.x*r.x+r.y*r.y+r.z*r.z+r.w*r.w);return p(e)?0:e}function Vr(r){i(r);let e=y(r);if(p(e))throw new Error("Cannot normalize zero or near-zero vector");return{x:r.x/e,y:r.y/e}}function wr(r){f(r);let e=I(r);if(p(e))throw new Error("Cannot normalize zero or near-zero vector");return{x:r.x/e,y:r.y/e,z:r.z/e}}function T(r,e){return i(r,"First vector"),i(e,"Second vector"),r.x*e.x+r.y*e.y}function zr(r,e){return f(r,"First vector"),f(e,"Second vector"),r.x*e.x+r.y*e.y+r.z*e.z}function Mr(r,e){return f(r,"First vector"),f(e,"Second vector"),{x:r.y*e.z-r.z*e.y,y:r.z*e.x-r.x*e.z,z:r.x*e.y-r.y*e.x}}function Cr(r,e){return i(r,"First vector"),i(e,"Second vector"),{x:r.x+e.x,y:r.y+e.y}}function Er(r,e){return i(r,"First vector"),i(e,"Second vector"),{x:r.x-e.x,y:r.y-e.y}}function Nr(r,e){return i(r),m(e,"scalar"),{x:r.x*e,y:r.y*e}}function Sr(r,e){i(r,"First vector"),i(e,"Second vector");let n=T(r,e),t=y(r),o=y(e);if(p(t)||p(o))throw new Error("Cannot calculate angle with zero or near-zero vector");let u=Math.max(-1,Math.min(1,n/(t*o)));return Math.acos(u)}function Rr(r,e){i(r,"First point"),i(e,"Second point");let n=e.x-r.x,t=e.y-r.y,o=Math.sqrt(n*n+t*t);return p(o)?0:o}function Fr(r,e){f(r,"First point"),f(e,"Second point");let n=e.x-r.x,t=e.y-r.y,o=e.z-r.z,u=Math.sqrt(n*n+t*t+o*o);return p(u)?0:u}function Ir(r,e,n){return i(r,"Start vector"),i(e,"End vector"),m(n,"t"),{x:r.x+(e.x-r.x)*n,y:r.y+(e.y-r.y)*n}}function Tr(r,e){i(r),m(e,"angle");let n=Math.cos(e),t=Math.sin(e);return{x:r.x*n-r.y*t,y:r.x*t+r.y*n}}var A=2*Math.PI;function a(r){return Math.abs(r)<1e-10}function Ar(r,e){return Math.abs(r-e)<1e-10}function D(r){return{real:a(r.real)?0:r.real,imag:a(r.imag)?0:r.imag}}function d(r,e){if(typeof r!="number"||!Number.isFinite(r))throw new Error(`${e} must be a finite number, got ${r}`)}function c(r,e="Complex number"){if(!r||typeof r!="object")throw new Error(`${e} must be an object`);d(r.real,`${e}.real`),d(r.imag,`${e}.imag`)}function E(r,e=0){return d(r,"real"),d(e,"imag"),D({real:r,imag:e})}function Pr(r,e){return c(r,"First complex number"),c(e,"Second complex number"),D({real:r.real+e.real,imag:r.imag+e.imag})}function qr(r,e){return c(r,"First complex number"),c(e,"Second complex number"),D({real:r.real-e.real,imag:r.imag-e.imag})}function P(r,e){return c(r,"First complex number"),c(e,"Second complex number"),D({real:r.real*e.real-r.imag*e.imag,imag:r.real*e.imag+r.imag*e.real})}function _r(r,e){c(r,"Numerator complex number"),c(e,"Denominator complex number");let n=e.real*e.real+e.imag*e.imag;if(a(n))throw new Error("Cannot divide by zero or near-zero complex number");return D({real:(r.real*e.real+r.imag*e.imag)/n,imag:(r.imag*e.real-r.real*e.imag)/n})}function V(r){c(r);let e=Math.sqrt(r.real*r.real+r.imag*r.imag);return a(e)?0:e}function Lr(r){return c(r),D({real:r.real,imag:-r.imag})}function w(r){return c(r),a(r.real)&&a(r.imag)?0:Math.atan2(r.imag,r.real)}function q(r){return c(r),{magnitude:V(r),angle:w(r)}}function g(r,e){if(d(r,"magnitude"),d(e,"angle"),r<-1e-10)throw new Error("Magnitude must be non-negative");let n=e%A;n>Math.PI&&(n-=A),n<=-Math.PI&&(n+=A);let t=Math.max(0,r);return D({real:t*Math.cos(n),imag:t*Math.sin(n)})}function $r(r){if(c(r),a(r.real)&&a(r.imag)){let s=E(0,0);return[s,s]}let e=V(r),n=w(r),t=Math.sqrt(e),o=n/2,u=o+Math.PI;return[g(t,o),g(t,u)]}function jr(r,e){if(c(r),d(e,"exponent"),a(e))return E(1,0);if(Ar(e,1))return E(r.real,r.imag);if(Ar(e,2))return P(r,r);if(a(r.real)&&a(r.imag)){if(e>0)return E(0,0);if(e<0)throw new Error("Cannot raise zero to a negative power")}let n=q(r),t=Math.pow(n.magnitude,e),o=t<-1e-10?Math.abs(t):Math.max(0,t),u=n.angle*e;return g(o,u)}function Gr(r){c(r);let e=V(r);if(a(e))throw new Error("Cannot take logarithm of zero or near-zero complex number");let n=w(r);return D({real:Math.log(e),imag:n})}var N=3.141592653589793,de=2.718281828459045,he=1.618033988749894,ye=1.4142135623730951,ge=.7071067811865476,Ve=.6931471805599453,we=2.302585092994046,ze=1.4426950408889634,Me=.4342944819032518,Ce=360,Ee=2*N,Ne=400,Se=180/N,Re=N/180,x={PI:N,E:de,PHI:he,SQRT2:ye,SQRT1_2:ge,LN2:Ve,LN10:we,LOG2E:ze,LOG10E:Me,DEGREES_IN_CIRCLE:Ce,RADIANS_IN_CIRCLE:Ee,GRADIANS_IN_CIRCLE:Ne,DEGREES_PER_RADIAN:Se,RADIANS_PER_DEGREE:Re};function Br(r){return r*x.RADIANS_PER_DEGREE}function Or(r){return r*x.DEGREES_PER_RADIAN}function kr(r){return r*(x.GRADIANS_IN_CIRCLE/x.DEGREES_IN_CIRCLE)}function Qr(r){return r*(x.DEGREES_IN_CIRCLE/x.GRADIANS_IN_CIRCLE)}function Zr(r){let e=x.RADIANS_IN_CIRCLE,n=r%e;return n<0&&(n+=e),n}function Xr(r){let e=r%x.DEGREES_IN_CIRCLE;return e<0&&(e+=x.DEGREES_IN_CIRCLE),e}function Yr(r){return Math.sin(r)}function Hr(r){return Math.cos(r)}function Ur(r){let e=Math.cos(r);if(Math.abs(e)<1e-10)throw new Error("Tangent undefined for this angle (cosine is zero)");return Math.tan(r)}function Wr(r){if(r<-1||r>1)throw new Error("Arcsine is only defined for values between -1 and 1");return Math.asin(r)}function Jr(r){if(r<-1||r>1)throw new Error("Arccosine is only defined for values between -1 and 1");return Math.acos(r)}function Kr(r){return Math.atan(r)}function vr(r,e){return Math.atan2(r,e)}function re(r){return Math.sinh(r)}function ee(r){return Math.cosh(r)}function ne(r){return Math.tanh(r)}function te(r){return Math.asinh(r)}function oe(r){if(r<1)throw new Error("Inverse hyperbolic cosine is only defined for x >= 1");return Math.acosh(r)}function ue(r){if(Math.abs(r)>=1)throw new Error("Inverse hyperbolic tangent is only defined for |x| < 1");return Math.atanh(r)}function ie(r){let e=Math.cos(r);if(Math.abs(e)<1e-10)throw new Error("Secant undefined for this angle (cosine is zero)");return 1/e}function ce(r){let e=Math.sin(r);if(Math.abs(e)<1e-10)throw new Error("Cosecant undefined for this angle (sine is zero)");return 1/e}function me(r){let e=Math.tan(r);if(Math.abs(e)<1e-10)throw new Error("Cotangent undefined for this angle (tangent is zero)");return 1/e}
+/*! @fluixi/utils v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  abs: () => abs,
+  acos: () => acos,
+  acosh: () => acosh,
+  add: () => add,
+  addComplex: () => addComplex,
+  addFractions: () => addFractions,
+  addVectors2D: () => addVectors2D,
+  angleBetween2D: () => angleBetween2D,
+  argumentComplex: () => argumentComplex,
+  asin: () => asin,
+  asinh: () => asinh,
+  atan: () => atan,
+  atan2: () => atan2,
+  atanh: () => atanh,
+  average: () => average,
+  cbrt: () => cbrt,
+  ceil: () => ceil,
+  clamp: () => clamp,
+  conjugateComplex: () => conjugateComplex,
+  cos: () => cos,
+  cosh: () => cosh,
+  cot: () => cot,
+  crossProduct3D: () => crossProduct3D,
+  csc: () => csc,
+  degToGrad: () => degToGrad,
+  degToRad: () => degToRad,
+  distance2D: () => distance2D,
+  distance3D: () => distance3D,
+  divide: () => divide,
+  divideComplex: () => divideComplex,
+  dotProduct2D: () => dotProduct2D,
+  dotProduct3D: () => dotProduct3D,
+  evaluatePolynomial: () => evaluatePolynomial,
+  exp: () => exp,
+  factorial: () => factorial,
+  floor: () => floor,
+  fromPolarComplex: () => fromPolarComplex,
+  gcd: () => gcd,
+  gradToDeg: () => gradToDeg,
+  invLerp: () => invLerp,
+  lcm: () => lcm,
+  lerp: () => lerp,
+  lerp2D: () => lerp2D,
+  ln: () => ln,
+  lnComplex: () => lnComplex,
+  log: () => log,
+  log10: () => log10,
+  log2: () => log2,
+  magnitude2D: () => magnitude2D,
+  magnitude3D: () => magnitude3D,
+  magnitude4D: () => magnitude4D,
+  magnitudeComplex: () => magnitudeComplex,
+  mapRange: () => mapRange,
+  max: () => max,
+  median: () => median,
+  min: () => min,
+  modulo: () => modulo,
+  multiplyComplex: () => multiplyComplex,
+  multiplyFractions: () => multiplyFractions,
+  normalize: () => normalize,
+  normalize2D: () => normalize2D,
+  normalize3D: () => normalize3D,
+  normalizeDegrees: () => normalizeDegrees,
+  normalizeRadians: () => normalizeRadians,
+  nthRoot: () => nthRoot,
+  percentage: () => percentage,
+  power: () => power,
+  powerComplex: () => powerComplex,
+  product: () => product,
+  radToDeg: () => radToDeg,
+  range: () => range,
+  rotate2D: () => rotate2D,
+  round: () => round,
+  scaleVector2D: () => scaleVector2D,
+  sec: () => sec,
+  sign: () => sign,
+  simplifyFraction: () => simplifyFraction,
+  sin: () => sin,
+  sinh: () => sinh,
+  solveQuadratic: () => solveQuadratic,
+  sqrt: () => sqrt,
+  sqrtComplex: () => sqrtComplex,
+  subtract: () => subtract,
+  subtractComplex: () => subtractComplex,
+  subtractVectors2D: () => subtractVectors2D,
+  sum: () => sum,
+  tan: () => tan,
+  tanh: () => tanh,
+  toBase: () => toBase,
+  toOrdinal: () => toOrdinal,
+  toPolarComplex: () => toPolarComplex,
+  trunc: () => trunc,
+  truncateDecimals: () => truncateDecimals,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/maths/fn/basic.ts
+function add(a, b) {
+  return a + b;
+}
+function subtract(a, b) {
+  return a - b;
+}
+var divide = (dividend, divisor, fallback) => {
+  if (divisor === 0) {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  return dividend / divisor;
+};
+function modulo(a, b) {
+  return a % b;
+}
+function power(base, exponent) {
+  return Math.pow(base, exponent);
+}
+function sqrt(value) {
+  if (value < 0) {
+    throw new Error("Cannot calculate square root of negative number");
+  }
+  return Math.sqrt(value);
+}
+function abs(value) {
+  return Math.abs(value);
+}
+var round = (value, precision = 0, mode = "round") => {
+  if (mode === "david") return roundUsingDavidGay(value, precision, mode);
+  if (!Number.isFinite(value)) return value;
+  if (precision === 0) return Math[mode](value);
+  if (precision < 0) {
+    const factor2 = 10 ** -precision;
+    return Math[mode](value / factor2) * factor2;
+  }
+  const factor = 10 ** precision;
+  const epsilon = Math.pow(2, -52);
+  const adjusted = value * factor;
+  const correction = Math.sign(adjusted) * epsilon * Math.abs(adjusted);
+  let rounded;
+  switch (mode) {
+    case "round":
+      rounded = Math.round(adjusted + correction);
+      break;
+    case "ceil":
+      rounded = Math.ceil(adjusted - epsilon);
+      break;
+    case "floor":
+      rounded = Math.floor(adjusted + epsilon);
+      break;
+    case "trunc":
+      rounded = adjusted < 0 ? Math.ceil(adjusted) : Math.floor(adjusted);
+      break;
+    default:
+      rounded = Math.round(adjusted + correction);
+  }
+  return rounded / factor;
+};
+var roundUsingDavidGay = (_value, precision = 0, mode = "round") => {
+  let value = Math.abs(_value);
+  const multiplicator = _value < 0 ? -1 : 1;
+  if (precision === 0) {
+    return Math.round(value) * multiplicator;
+  }
+  if (!Number.isFinite(value)) {
+    return value * multiplicator;
+  }
+  const factor = 10 ** precision;
+  let shifted = value * factor;
+  const epsilon = Math.pow(2, -53);
+  const correction = Math.sign(shifted) * epsilon * Math.abs(shifted);
+  shifted += correction;
+  const rounded = Math.round(shifted);
+  return rounded / factor * multiplicator;
+};
+var ceil = (value, precision = 0) => {
+  return round(value, precision, "ceil");
+};
+var floor = (value, precision = 0) => {
+  return round(value, precision, "floor");
+};
+var trunc = (value, precision = 0) => {
+  return round(value, precision, "trunc");
+};
+var clamp = (value, min2, max2) => {
+  if (min2 > max2) [min2, max2] = [max2, min2];
+  return value < min2 ? min2 : value > max2 ? max2 : value;
+};
+function sign(value) {
+  if (value > 0) return 1;
+  if (value < 0) return -1;
+  return 0;
+}
+function factorial(n) {
+  if (!Number.isInteger(n) || n < 0) {
+    throw new Error("Factorial is only defined for non-negative integers");
+  }
+  if (n === 0 || n === 1) return 1;
+  let result = 1;
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+  return result;
+}
+function gcd(a, b) {
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b !== 0) {
+    const temp = b;
+    b = a % b;
+    a = temp;
+  }
+  return a;
+}
+function lcm(a, b) {
+  return Math.abs(a * b) / gcd(a, b);
+}
+function lerp(start, end, t) {
+  return start + (end - start) * clamp(t, 0, 1);
+}
+var invLerp = (start, end, value) => {
+  return clamp((value - start) / (end - start), 0, 1);
+};
+var mapRange = (value, inMin, inMax, outMin, outMax) => {
+  const t = invLerp(inMin, inMax, value);
+  return lerp(outMin, outMax, t);
+};
+function min(...values) {
+  return Math.min(...values);
+}
+function max(...values) {
+  return Math.max(...values);
+}
+var average = (...numbers) => {
+  if (!Array.isArray(numbers) || numbers.length === 0) return 0;
+  let total = 0;
+  let count = 0;
+  for (const num of numbers) {
+    if (Number.isFinite(num)) {
+      total += num;
+      count++;
+    }
+  }
+  return count === 0 ? 0 : total / count;
+};
+var sum = (...numbers) => {
+  if (!Array.isArray(numbers)) return 0;
+  return numbers.reduce(
+    (acc, val) => acc + (Number.isFinite(val) ? val : 0),
+    0
+  );
+};
+var median = (...numbers) => {
+  if (!Array.isArray(numbers) || numbers.length === 0) return 0;
+  const validNumbers = numbers.filter(Number.isFinite);
+  if (validNumbers.length === 0) return 0;
+  validNumbers.sort((a, b) => a - b);
+  const mid = Math.floor(validNumbers.length / 2);
+  return validNumbers.length % 2 === 0 ? (validNumbers[mid - 1] + validNumbers[mid]) / 2 : validNumbers[mid];
+};
+function product(...values) {
+  return values.reduce((prod, val) => prod * val, 1);
+}
+
+// src/lib/maths/fn/advanced.ts
+function ln(value) {
+  if (value <= 0) {
+    throw new Error("Natural logarithm is only defined for positive numbers");
+  }
+  return Math.log(value);
+}
+function log10(value) {
+  if (value <= 0) {
+    throw new Error("Logarithm is only defined for positive numbers");
+  }
+  return Math.log10(value);
+}
+function log2(value) {
+  if (value <= 0) {
+    throw new Error("Logarithm is only defined for positive numbers");
+  }
+  return Math.log2(value);
+}
+function log(value, base) {
+  if (value <= 0 || base <= 0) {
+    throw new Error("Logarithm is only defined for positive numbers and bases");
+  }
+  return Math.log(value) / Math.log(base);
+}
+function exp(x) {
+  return Math.exp(x);
+}
+function cbrt(value) {
+  return Math.cbrt(value);
+}
+function nthRoot(value, n) {
+  if (n === 0) {
+    throw new Error("Cannot calculate 0th root");
+  }
+  if (value < 0 && n % 2 === 0) {
+    throw new Error("Cannot calculate even root of negative number");
+  }
+  const exponent = 1 / n;
+  return Math.sign(value) * Math.pow(Math.abs(value), exponent);
+}
+function solveQuadratic(a, b, c) {
+  if (a === 0) {
+    if (b === 0) return [];
+    return [-c / b];
+  }
+  const discriminant = b * b - 4 * a * c;
+  if (discriminant < 0) {
+    return [];
+  } else if (discriminant === 0) {
+    return [-b / (2 * a)];
+  } else {
+    const sqrtDiscriminant = Math.sqrt(discriminant);
+    return [
+      (-b - sqrtDiscriminant) / (2 * a),
+      (-b + sqrtDiscriminant) / (2 * a)
+    ];
+  }
+}
+function evaluatePolynomial(coefficients, x) {
+  let result = 0;
+  for (let i = 0; i < coefficients.length; i++) {
+    result = result * x + coefficients[i];
+  }
+  return result;
+}
+function simplifyFraction(fraction) {
+  const divisor = gcd(fraction.numerator, fraction.denominator);
+  return {
+    numerator: fraction.numerator / divisor,
+    denominator: fraction.denominator / divisor
+  };
+}
+function addFractions(a, b) {
+  const numerator = a.numerator * b.denominator + b.numerator * a.denominator;
+  const denominator = a.denominator * b.denominator;
+  return simplifyFraction({ numerator, denominator });
+}
+function multiplyFractions(a, b) {
+  const numerator = a.numerator * b.numerator;
+  const denominator = a.denominator * b.denominator;
+  return simplifyFraction({ numerator, denominator });
+}
+var percentage = (value, total, precision = 2) => {
+  if (total === 0) return 0;
+  const percent = value / total * 100;
+  return round(percent, precision);
+};
+var toBase = (number, base, minLength = 1) => {
+  if (base < 2 || base > 36) {
+    throw new Error("Base must be between 2 and 36");
+  }
+  const result = number.toString(base);
+  return result.padStart(minLength, "0");
+};
+var toOrdinal = (n) => {
+  const suffix = ["th", "st", "nd", "rd"];
+  const v = n % 100;
+  return n + (suffix[(v - 20) % 10] || suffix[v] || suffix[0]);
+};
+var range = (start, end, step = 1) => {
+  const result = [];
+  if (step === 0) return result;
+  if (step > 0) {
+    for (let i = start; i < end; i += step) {
+      result.push(i);
+    }
+  } else {
+    for (let i = start; i > end; i += step) {
+      result.push(i);
+    }
+  }
+  return result;
+};
+var truncateDecimals = (value, decimalPlaces) => {
+  if (!Number.isFinite(value)) return value;
+  const factor = 10 ** decimalPlaces;
+  return Math.trunc(value * factor) / factor;
+};
+var normalize = (value, min2, max2) => {
+  if (min2 === max2) return 0;
+  return (value - min2) / (max2 - min2);
+};
+var wrap = (value, min2, max2) => {
+  const range2 = max2 - min2;
+  return ((value - min2) % range2 + range2) % range2 + min2;
+};
+
+// 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 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 magnitude2D(vector) {
+  validateVector2D(vector);
+  const magnitude = Math.sqrt(vector.x * vector.x + vector.y * vector.y);
+  return isApproximatelyZero(magnitude) ? 0 : magnitude;
+}
+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 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 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 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 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 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 subtractVectors2D(a, b) {
+  validateVector2D(a, "First vector");
+  validateVector2D(b, "Second vector");
+  return {
+    x: a.x - b.x,
+    y: a.y - b.y
+  };
+}
+function scaleVector2D(vector, scalar) {
+  validateVector2D(vector);
+  validateNumber(scalar, "scalar");
+  return {
+    x: vector.x * scalar,
+    y: vector.y * 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 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 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 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 rotate2D(vector, angle) {
+  validateVector2D(vector);
+  validateNumber(angle, "angle");
+  const cos2 = Math.cos(angle);
+  const sin2 = Math.sin(angle);
+  return {
+    x: vector.x * cos2 - vector.y * sin2,
+    y: vector.x * sin2 + vector.y * cos2
+  };
+}
+
+// src/lib/maths/fn/complex.ts
+var EPSILON = 1e-10;
+var TWO_PI = 2 * Math.PI;
+function isApproximatelyZero2(value) {
+  return Math.abs(value) < EPSILON;
+}
+function approximatelyEqual(a, b) {
+  return Math.abs(a - b) < EPSILON;
+}
+function normalizeComplex(c) {
+  return {
+    real: isApproximatelyZero2(c.real) ? 0 : c.real,
+    imag: isApproximatelyZero2(c.imag) ? 0 : c.imag
+  };
+}
+function validateNumber2(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(`${name} must be a finite number, got ${value}`);
+  }
+}
+function validateComplexNumber(c, name = "Complex number") {
+  if (!c || typeof c !== "object") {
+    throw new Error(`${name} must be an object`);
+  }
+  validateNumber2(c.real, `${name}.real`);
+  validateNumber2(c.imag, `${name}.imag`);
+}
+function createComplex(real, imag = 0) {
+  validateNumber2(real, "real");
+  validateNumber2(imag, "imag");
+  return normalizeComplex({ real, imag });
+}
+function addComplex(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return normalizeComplex({
+    real: a.real + b.real,
+    imag: a.imag + b.imag
+  });
+}
+function subtractComplex(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return normalizeComplex({
+    real: a.real - b.real,
+    imag: a.imag - b.imag
+  });
+}
+function multiplyComplex(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return normalizeComplex({
+    real: a.real * b.real - a.imag * b.imag,
+    imag: a.real * b.imag + a.imag * b.real
+  });
+}
+function divideComplex(a, b) {
+  validateComplexNumber(a, "Numerator complex number");
+  validateComplexNumber(b, "Denominator complex number");
+  const denominator = b.real * b.real + b.imag * b.imag;
+  if (isApproximatelyZero2(denominator)) {
+    throw new Error("Cannot divide by zero or near-zero complex number");
+  }
+  return normalizeComplex({
+    real: (a.real * b.real + a.imag * b.imag) / denominator,
+    imag: (a.imag * b.real - a.real * b.imag) / denominator
+  });
+}
+function magnitudeComplex(c) {
+  validateComplexNumber(c);
+  const magnitude = Math.sqrt(c.real * c.real + c.imag * c.imag);
+  return isApproximatelyZero2(magnitude) ? 0 : magnitude;
+}
+function conjugateComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: c.real,
+    imag: -c.imag
+  });
+}
+function argumentComplex(c) {
+  validateComplexNumber(c);
+  if (isApproximatelyZero2(c.real) && isApproximatelyZero2(c.imag)) {
+    return 0;
+  }
+  return Math.atan2(c.imag, c.real);
+}
+function toPolarComplex(c) {
+  validateComplexNumber(c);
+  return {
+    magnitude: magnitudeComplex(c),
+    angle: argumentComplex(c)
+  };
+}
+function fromPolarComplex(magnitude, angle) {
+  validateNumber2(magnitude, "magnitude");
+  validateNumber2(angle, "angle");
+  if (magnitude < -EPSILON) {
+    throw new Error("Magnitude must be non-negative");
+  }
+  let normalizedAngle = angle % TWO_PI;
+  if (normalizedAngle > Math.PI) normalizedAngle -= TWO_PI;
+  if (normalizedAngle <= -Math.PI) normalizedAngle += TWO_PI;
+  const mag = Math.max(0, magnitude);
+  return normalizeComplex({
+    real: mag * Math.cos(normalizedAngle),
+    imag: mag * Math.sin(normalizedAngle)
+  });
+}
+function sqrtComplex(c) {
+  validateComplexNumber(c);
+  if (isApproximatelyZero2(c.real) && isApproximatelyZero2(c.imag)) {
+    const zero = createComplex(0, 0);
+    return [zero, zero];
+  }
+  const magnitude = magnitudeComplex(c);
+  const angle = argumentComplex(c);
+  const rootMagnitude = Math.sqrt(magnitude);
+  const rootAngle1 = angle / 2;
+  const rootAngle2 = rootAngle1 + Math.PI;
+  return [
+    fromPolarComplex(rootMagnitude, rootAngle1),
+    fromPolarComplex(rootMagnitude, rootAngle2)
+  ];
+}
+function powerComplex(c, exponent) {
+  validateComplexNumber(c);
+  validateNumber2(exponent, "exponent");
+  if (isApproximatelyZero2(exponent)) {
+    return createComplex(1, 0);
+  }
+  if (approximatelyEqual(exponent, 1)) {
+    return createComplex(c.real, c.imag);
+  }
+  if (approximatelyEqual(exponent, 2)) {
+    return multiplyComplex(c, c);
+  }
+  if (isApproximatelyZero2(c.real) && isApproximatelyZero2(c.imag)) {
+    if (exponent > 0) {
+      return createComplex(0, 0);
+    } else if (exponent < 0) {
+      throw new Error("Cannot raise zero to a negative power");
+    }
+  }
+  const polar = toPolarComplex(c);
+  const magnitude = Math.pow(polar.magnitude, exponent);
+  const safeMagnitude = magnitude < -EPSILON ? Math.abs(magnitude) : Math.max(0, magnitude);
+  const angle = polar.angle * exponent;
+  return fromPolarComplex(safeMagnitude, angle);
+}
+function lnComplex(c) {
+  validateComplexNumber(c);
+  const magnitude = magnitudeComplex(c);
+  if (isApproximatelyZero2(magnitude)) {
+    throw new Error(
+      "Cannot take logarithm of zero or near-zero complex number"
+    );
+  }
+  const angle = argumentComplex(c);
+  return normalizeComplex({
+    real: Math.log(magnitude),
+    imag: angle
+  });
+}
+
+// src/lib/maths/constants.ts
+var PI = 3.141592653589793;
+var E = 2.718281828459045;
+var PHI = 1.618033988749894;
+var SQRT2 = 1.4142135623730951;
+var SQRT1_2 = 0.7071067811865476;
+var LN2 = 0.6931471805599453;
+var LN10 = 2.302585092994046;
+var LOG2E = 1.4426950408889634;
+var LOG10E = 0.4342944819032518;
+var DEGREES_IN_CIRCLE = 360;
+var RADIANS_IN_CIRCLE = 2 * PI;
+var GRADIANS_IN_CIRCLE = 400;
+var DEGREES_PER_RADIAN = 180 / PI;
+var RADIANS_PER_DEGREE = PI / 180;
+var Constants = {
+  PI,
+  E,
+  PHI,
+  SQRT2,
+  SQRT1_2,
+  LN2,
+  LN10,
+  LOG2E,
+  LOG10E,
+  DEGREES_IN_CIRCLE,
+  RADIANS_IN_CIRCLE,
+  GRADIANS_IN_CIRCLE,
+  DEGREES_PER_RADIAN,
+  RADIANS_PER_DEGREE
+};
+
+// src/lib/maths/fn/trigo.ts
+function degToRad(degrees) {
+  return degrees * Constants.RADIANS_PER_DEGREE;
+}
+function radToDeg(radians) {
+  return radians * Constants.DEGREES_PER_RADIAN;
+}
+function degToGrad(degrees) {
+  return degrees * (Constants.GRADIANS_IN_CIRCLE / Constants.DEGREES_IN_CIRCLE);
+}
+function gradToDeg(gradians) {
+  return gradians * (Constants.DEGREES_IN_CIRCLE / Constants.GRADIANS_IN_CIRCLE);
+}
+function normalizeRadians(radians) {
+  const twoPi = Constants.RADIANS_IN_CIRCLE;
+  let normalized = radians % twoPi;
+  if (normalized < 0) normalized += twoPi;
+  return normalized;
+}
+function normalizeDegrees(degrees) {
+  let normalized = degrees % Constants.DEGREES_IN_CIRCLE;
+  if (normalized < 0) normalized += Constants.DEGREES_IN_CIRCLE;
+  return normalized;
+}
+function sin(radians) {
+  return Math.sin(radians);
+}
+function cos(radians) {
+  return Math.cos(radians);
+}
+function tan(radians) {
+  const cosine = Math.cos(radians);
+  if (Math.abs(cosine) < 1e-10) {
+    throw new Error("Tangent undefined for this angle (cosine is zero)");
+  }
+  return Math.tan(radians);
+}
+function asin(value) {
+  if (value < -1 || value > 1) {
+    throw new Error("Arcsine is only defined for values between -1 and 1");
+  }
+  return Math.asin(value);
+}
+function acos(value) {
+  if (value < -1 || value > 1) {
+    throw new Error("Arccosine is only defined for values between -1 and 1");
+  }
+  return Math.acos(value);
+}
+function atan(value) {
+  return Math.atan(value);
+}
+function atan2(y, x) {
+  return Math.atan2(y, x);
+}
+function sinh(x) {
+  return Math.sinh(x);
+}
+function cosh(x) {
+  return Math.cosh(x);
+}
+function tanh(x) {
+  return Math.tanh(x);
+}
+function asinh(x) {
+  return Math.asinh(x);
+}
+function acosh(x) {
+  if (x < 1) {
+    throw new Error("Inverse hyperbolic cosine is only defined for x >= 1");
+  }
+  return Math.acosh(x);
+}
+function atanh(x) {
+  if (Math.abs(x) >= 1) {
+    throw new Error("Inverse hyperbolic tangent is only defined for |x| < 1");
+  }
+  return Math.atanh(x);
+}
+function sec(radians) {
+  const cosine = Math.cos(radians);
+  if (Math.abs(cosine) < 1e-10) {
+    throw new Error("Secant undefined for this angle (cosine is zero)");
+  }
+  return 1 / cosine;
+}
+function csc(radians) {
+  const sine = Math.sin(radians);
+  if (Math.abs(sine) < 1e-10) {
+    throw new Error("Cosecant undefined for this angle (sine is zero)");
+  }
+  return 1 / sine;
+}
+function cot(radians) {
+  const tangent = Math.tan(radians);
+  if (Math.abs(tangent) < 1e-10) {
+    throw new Error("Cotangent undefined for this angle (tangent is zero)");
+  }
+  return 1 / tangent;
+}