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

package/dist/lib/maths/index.cjs

@@ -1 +1,1152 @@
-"use strict";var S=Object.defineProperty;var Me=Object.getOwnPropertyDescriptor;var ze=Object.getOwnPropertyNames;var Ce=Object.prototype.hasOwnProperty;var Ee=(r,e)=>{for(var n in e)S(r,n,{get:e[n],enumerable:!0})},Fe=(r,e,n,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of ze(e))!Ce.call(r,o)&&o!==n&&S(r,o,{get:()=>e[o],enumerable:!(t=Me(e,o))||t.enumerable});return r};var Se=r=>Fe(S({},"__esModule",{value:!0}),r);var xn={};Ee(xn,{Constants:()=>p,DEGREES_IN_CIRCLE:()=>Q,DEGREES_PER_RADIAN:()=>k,E:()=>$,GRADIANS_IN_CIRCLE:()=>Y,LN10:()=>O,LN2:()=>G,LOG10E:()=>Z,LOG2E:()=>U,PHI:()=>j,PI:()=>g,RADIANS_IN_CIRCLE:()=>X,RADIANS_PER_DEGREE:()=>H,SQRT1_2:()=>B,SQRT2:()=>L,abs:()=>tr,acos:()=>pe,acosh:()=>ge,add:()=>W,addComplex:()=>Hr,addFractions:()=>Cr,addVectors2D:()=>Br,angleBetween2D:()=>Ur,approxEqual:()=>We,argumentComplex:()=>M,asin:()=>xe,asinh:()=>ye,atan:()=>fe,atan2:()=>be,atanh:()=>he,average:()=>fr,cbrt:()=>Nr,ceil:()=>or,clamp:()=>z,conjugateComplex:()=>Jr,cos:()=>se,cosh:()=>de,cot:()=>we,crossProduct3D:()=>Lr,csc:()=>Ne,degToGrad:()=>oe,degToRad:()=>ne,distance2D:()=>Zr,distance3D:()=>Qr,divide:()=>v,divideComplex:()=>Wr,dotProduct2D:()=>T,dotProduct3D:()=>jr,evaluatePolynomial:()=>zr,exp:()=>Vr,factorial:()=>cr,floor:()=>ur,formatBytes:()=>tn,formatCurrency:()=>nn,formatNumber:()=>en,formatPercent:()=>on,fromPolarComplex:()=>N,gcd:()=>h,gradToDeg:()=>ue,invLerp:()=>I,isComplexNumber:()=>Le,isEven:()=>ke,isFiniteNumber:()=>_e,isFloat:()=>Pe,isFraction:()=>Be,isInRange:()=>Ye,isInt:()=>Ie,isInteger:()=>qe,isMatrix:()=>Ge,isNegative:()=>Ue,isNonNegative:()=>Ze,isNonPositive:()=>Qe,isNumber:()=>Ae,isNumeric:()=>Re,isNumericString:()=>K,isOdd:()=>He,isPositive:()=>Oe,isPowerOfTwo:()=>Je,isPrime:()=>Ke,isSafeInteger:()=>Te,isVector2D:()=>$e,isVector3D:()=>je,isZero:()=>Xe,lcm:()=>sr,lerp:()=>R,lerp2D:()=>Xr,ln:()=>Dr,lnComplex:()=>ee,log:()=>hr,log10:()=>yr,log2:()=>gr,magnitude2D:()=>V,magnitude3D:()=>A,magnitude4D:()=>qr,magnitudeComplex:()=>w,mapRange:()=>ar,max:()=>pr,median:()=>lr,min:()=>xr,modulo:()=>rr,multiplyComplex:()=>q,multiplyFractions:()=>Er,normalize:()=>Tr,normalize2D:()=>_r,normalize3D:()=>$r,normalizeDegrees:()=>me,normalizeRadians:()=>ie,nthRoot:()=>wr,parseIntSafe:()=>an,percentage:()=>Fr,power:()=>er,powerComplex:()=>re,product:()=>dr,radToDeg:()=>te,randomBool:()=>cn,randomFloat:()=>mn,randomInt:()=>un,range:()=>Ir,rotate2D:()=>Yr,round:()=>d,scaleVector2D:()=>Or,sec:()=>Ve,sign:()=>mr,simplifyFraction:()=>C,sin:()=>ce,sinh:()=>le,solveQuadratic:()=>Mr,sqrt:()=>nr,sqrtComplex:()=>vr,subtract:()=>J,subtractComplex:()=>Kr,subtractVectors2D:()=>Gr,sum:()=>br,tan:()=>ae,tanh:()=>De,toBase:()=>Sr,toNumber:()=>sn,toOrdinal:()=>Rr,toPolarComplex:()=>_,trunc:()=>ir,truncateDecimals:()=>Ar,wrap:()=>Pr});module.exports=Se(xn);var g=3.141592653589793,$=2.718281828459045,j=1.618033988749894,L=1.4142135623730951,B=.7071067811865476,G=.6931471805599453,O=2.302585092994046,U=1.4426950408889634,Z=.4342944819032518,Q=360,X=2*g,Y=400,k=180/g,H=g/180,p={PI:g,E:$,PHI:j,SQRT2:L,SQRT1_2:B,LN2:G,LN10:O,LOG2E:U,LOG10E:Z,DEGREES_IN_CIRCLE:Q,RADIANS_IN_CIRCLE:X,GRADIANS_IN_CIRCLE:Y,DEGREES_PER_RADIAN:k,RADIANS_PER_DEGREE:H};var K=r=>{let e=r.trim();if(e===""||!/^[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$/.test(e))return!1;let n=Number(e);return Number.isFinite(n)},Re=r=>typeof r=="number"?Number.isFinite(r):typeof r=="string"?K(r):!1,Ie=r=>{if(typeof r=="number")return Number.isInteger(r);if(typeof r=="string"){let n=r.trim();if(!n||!/^[-+]?\d+$/.test(n))return!1;let t=Number(n);return Number.isInteger(t)&&Number.isFinite(t)}if(typeof r=="boolean"||r==null||Array.isArray(r))return!1;let e=Number(r);return!Number.isNaN(e)&&Number.isInteger(e)&&Number.isFinite(e)},Ae=r=>typeof r=="number"&&Number.isFinite(r),Te=r=>typeof r=="number"&&Number.isSafeInteger(r),Pe=r=>typeof r!="number"||!Number.isFinite(r)?!1:!Number.isInteger(r);function qe(r){return Number.isInteger(r)}function _e(r){return Number.isFinite(r)}function $e(r){return typeof r=="object"&&r!==null&&"x"in r&&"y"in r&&typeof r.x=="number"&&typeof r.y=="number"}function je(r){return typeof r=="object"&&r!==null&&"x"in r&&"y"in r&&"z"in r&&typeof r.x=="number"&&typeof r.y=="number"&&typeof r.z=="number"}function Le(r){return typeof r=="object"&&r!==null&&"real"in r&&"imag"in r&&typeof r.real=="number"&&typeof r.imag=="number"}function Be(r){return typeof r=="object"&&r!==null&&"numerator"in r&&"denominator"in r&&typeof r.numerator=="number"&&typeof r.denominator=="number"&&r.denominator!==0}function Ge(r){return typeof r=="object"&&r!==null&&"rows"in r&&"columns"in r&&"data"in r&&typeof r.rows=="number"&&typeof r.columns=="number"&&Array.isArray(r.data)&&r.data.every(e=>Array.isArray(e))}var Oe=r=>Number.isFinite(r)&&r>0,Ue=r=>Number.isFinite(r)&&r<0;function Ze(r){return Number.isFinite(r)&&r>=0}function Qe(r){return Number.isFinite(r)&&r<=0}var Xe=(r,e=1e-10)=>Number.isFinite(r)&&Math.abs(r)<e;function Ye(r,e,n,t=!0){return t?r>=e&&r<=n:r>e&&r<n}function ke(r){return(r&1)===0}function He(r){return(r&1)===1}var Ke=r=>{if(!Number.isInteger(r)||r<=1)return!1;if(r<=3)return!0;if(r%2===0||r%3===0)return!1;for(let e=5;e*e<=r;e+=6)if(r%e===0||r%(e+2)===0)return!1;return!0},We=(r,e,n=Math.E)=>{if(r===e)return!0;if(!Number.isFinite(r)||!Number.isFinite(e))return r===e;let t=Math.abs(r),o=Math.abs(e),u=Math.abs(r-e);return r===0||e===0||u<n?u<n:u>n?!1:u/Math.min(t+o,Number.MAX_SAFE_INTEGER)<n},Je=r=>r>0&&(r&r-1)===0;function W(r,e){return r+e}function J(r,e){return r-e}var v=(r,e,n)=>e===0?n!==void 0?n:NaN:r/e;function rr(r,e){return r%e}function er(r,e){return Math.pow(r,e)}function nr(r){if(r<0)throw new Error("Cannot calculate square root of negative number");return Math.sqrt(r)}function tr(r){return Math.abs(r)}var d=(r,e=0,n="round")=>{if(n==="david")return ve(r,e,n);if(!Number.isFinite(r))return r;if(e===0)return Math[n](r);if(e<0){let y=10**-e;return Math[n](r/y)*y}let t=10**e,o=Math.pow(2,-52),u=r*t,i=Math.sign(u)*o*Math.abs(u),s;switch(n){case"round":s=Math.round(u+i);break;case"ceil":s=Math.ceil(u-o);break;case"floor":s=Math.floor(u+o);break;case"trunc":s=u<0?Math.ceil(u):Math.floor(u);break;default:s=Math.round(u+i)}return s/t},ve=(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,i=t*u,s=Math.pow(2,-53),y=Math.sign(i)*s*Math.abs(i);return i+=y,Math.round(i)/u*o},or=(r,e=0)=>d(r,e,"ceil"),ur=(r,e=0)=>d(r,e,"floor"),ir=(r,e=0)=>d(r,e,"trunc"),z=(r,e,n)=>(e>n&&([e,n]=[n,e]),r<e?e:r>n?n:r);function mr(r){return r>0?1:r<0?-1:0}function cr(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 sr(r,e){return Math.abs(r*e)/h(r,e)}function R(r,e,n){return r+(e-r)*z(n,0,1)}var I=(r,e,n)=>z((n-r)/(e-r),0,1),ar=(r,e,n,t,o)=>{let u=I(e,n,r);return R(t,o,u)};function xr(...r){return Math.min(...r)}function pr(...r){return Math.max(...r)}var fr=(...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},br=(...r)=>Array.isArray(r)?r.reduce((e,n)=>e+(Number.isFinite(n)?n:0),0):0,lr=(...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 dr(...r){return r.reduce((e,n)=>e*n,1)}function Dr(r){if(r<=0)throw new Error("Natural logarithm is only defined for positive numbers");return Math.log(r)}function yr(r){if(r<=0)throw new Error("Logarithm is only defined for positive numbers");return Math.log10(r)}function gr(r){if(r<=0)throw new Error("Logarithm is only defined for positive numbers");return Math.log2(r)}function hr(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 Vr(r){return Math.exp(r)}function Nr(r){return Math.cbrt(r)}function wr(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 Mr(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 zr(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 Cr(r,e){let n=r.numerator*e.denominator+e.numerator*r.denominator,t=r.denominator*e.denominator;return C({numerator:n,denominator:t})}function Er(r,e){let n=r.numerator*e.numerator,t=r.denominator*e.denominator;return C({numerator:n,denominator:t})}var Fr=(r,e,n=2)=>{if(e===0)return 0;let t=r/e*100;return d(t,n)},Sr=(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")},Rr=r=>{let e=["th","st","nd","rd"],n=r%100;return r+(e[(n-20)%10]||e[n]||e[0])},Ir=(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},Ar=(r,e)=>{if(!Number.isFinite(r))return r;let n=10**e;return Math.trunc(r*n)/n},Tr=(r,e,n)=>e===n?0:(r-e)/(n-e),Pr=(r,e,n)=>{let t=n-e;return((r-e)%t+t)%t+e};function a(r,e){if(typeof r!="number"||!Number.isFinite(r))throw new Error(`${e} must be a finite number, got ${r}`)}function f(r){return Math.abs(r)<1e-9}function m(r,e="Vector2D"){if(!r||typeof r!="object")throw new Error(`${e} must be an object`);a(r.x,`${e}.x`),a(r.y,`${e}.y`)}function b(r,e="Vector3D"){if(!r||typeof r!="object")throw new Error(`${e} must be an object`);a(r.x,`${e}.x`),a(r.y,`${e}.y`),a(r.z,`${e}.z`)}function rn(r,e="Vector4D"){if(!r||typeof r!="object")throw new Error(`${e} must be an object`);a(r.x,`${e}.x`),a(r.y,`${e}.y`),a(r.z,`${e}.z`),a(r.w,`${e}.w`)}function V(r){m(r);let e=Math.sqrt(r.x*r.x+r.y*r.y);return f(e)?0:e}function A(r){b(r);let e=Math.sqrt(r.x*r.x+r.y*r.y+r.z*r.z);return f(e)?0:e}function qr(r){rn(r);let e=Math.sqrt(r.x*r.x+r.y*r.y+r.z*r.z+r.w*r.w);return f(e)?0:e}function _r(r){m(r);let e=V(r);if(f(e))throw new Error("Cannot normalize zero or near-zero vector");return{x:r.x/e,y:r.y/e}}function $r(r){b(r);let e=A(r);if(f(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 m(r,"First vector"),m(e,"Second vector"),r.x*e.x+r.y*e.y}function jr(r,e){return b(r,"First vector"),b(e,"Second vector"),r.x*e.x+r.y*e.y+r.z*e.z}function Lr(r,e){return b(r,"First vector"),b(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 Br(r,e){return m(r,"First vector"),m(e,"Second vector"),{x:r.x+e.x,y:r.y+e.y}}function Gr(r,e){return m(r,"First vector"),m(e,"Second vector"),{x:r.x-e.x,y:r.y-e.y}}function Or(r,e){return m(r),a(e,"scalar"),{x:r.x*e,y:r.y*e}}function Ur(r,e){m(r,"First vector"),m(e,"Second vector");let n=T(r,e),t=V(r),o=V(e);if(f(t)||f(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 Zr(r,e){m(r,"First point"),m(e,"Second point");let n=e.x-r.x,t=e.y-r.y,o=Math.sqrt(n*n+t*t);return f(o)?0:o}function Qr(r,e){b(r,"First point"),b(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 f(u)?0:u}function Xr(r,e,n){return m(r,"Start vector"),m(e,"End vector"),a(n,"t"),{x:r.x+(e.x-r.x)*n,y:r.y+(e.y-r.y)*n}}function Yr(r,e){m(r),a(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 P=2*Math.PI;function x(r){return Math.abs(r)<1e-10}function kr(r,e){return Math.abs(r-e)<1e-10}function l(r){return{real:x(r.real)?0:r.real,imag:x(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"),l({real:r,imag:e})}function Hr(r,e){return c(r,"First complex number"),c(e,"Second complex number"),l({real:r.real+e.real,imag:r.imag+e.imag})}function Kr(r,e){return c(r,"First complex number"),c(e,"Second complex number"),l({real:r.real-e.real,imag:r.imag-e.imag})}function q(r,e){return c(r,"First complex number"),c(e,"Second complex number"),l({real:r.real*e.real-r.imag*e.imag,imag:r.real*e.imag+r.imag*e.real})}function Wr(r,e){c(r,"Numerator complex number"),c(e,"Denominator complex number");let n=e.real*e.real+e.imag*e.imag;if(x(n))throw new Error("Cannot divide by zero or near-zero complex number");return l({real:(r.real*e.real+r.imag*e.imag)/n,imag:(r.imag*e.real-r.real*e.imag)/n})}function w(r){c(r);let e=Math.sqrt(r.real*r.real+r.imag*r.imag);return x(e)?0:e}function Jr(r){return c(r),l({real:r.real,imag:-r.imag})}function M(r){return c(r),x(r.real)&&x(r.imag)?0:Math.atan2(r.imag,r.real)}function _(r){return c(r),{magnitude:w(r),angle:M(r)}}function N(r,e){if(D(r,"magnitude"),D(e,"angle"),r<-1e-10)throw new Error("Magnitude must be non-negative");let n=e%P;n>Math.PI&&(n-=P),n<=-Math.PI&&(n+=P);let t=Math.max(0,r);return l({real:t*Math.cos(n),imag:t*Math.sin(n)})}function vr(r){if(c(r),x(r.real)&&x(r.imag)){let i=E(0,0);return[i,i]}let e=w(r),n=M(r),t=Math.sqrt(e),o=n/2,u=o+Math.PI;return[N(t,o),N(t,u)]}function re(r,e){if(c(r),D(e,"exponent"),x(e))return E(1,0);if(kr(e,1))return E(r.real,r.imag);if(kr(e,2))return q(r,r);if(x(r.real)&&x(r.imag)){if(e>0)return E(0,0);if(e<0)throw new Error("Cannot raise zero to a negative power")}let n=_(r),t=Math.pow(n.magnitude,e),o=t<-1e-10?Math.abs(t):Math.max(0,t),u=n.angle*e;return N(o,u)}function ee(r){c(r);let e=w(r);if(x(e))throw new Error("Cannot take logarithm of zero or near-zero complex number");let n=M(r);return l({real:Math.log(e),imag:n})}function ne(r){return r*p.RADIANS_PER_DEGREE}function te(r){return r*p.DEGREES_PER_RADIAN}function oe(r){return r*(p.GRADIANS_IN_CIRCLE/p.DEGREES_IN_CIRCLE)}function ue(r){return r*(p.DEGREES_IN_CIRCLE/p.GRADIANS_IN_CIRCLE)}function ie(r){let e=p.RADIANS_IN_CIRCLE,n=r%e;return n<0&&(n+=e),n}function me(r){let e=r%p.DEGREES_IN_CIRCLE;return e<0&&(e+=p.DEGREES_IN_CIRCLE),e}function ce(r){return Math.sin(r)}function se(r){return Math.cos(r)}function ae(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 xe(r){if(r<-1||r>1)throw new Error("Arcsine is only defined for values between -1 and 1");return Math.asin(r)}function pe(r){if(r<-1||r>1)throw new Error("Arccosine is only defined for values between -1 and 1");return Math.acos(r)}function fe(r){return Math.atan(r)}function be(r,e){return Math.atan2(r,e)}function le(r){return Math.sinh(r)}function de(r){return Math.cosh(r)}function De(r){return Math.tanh(r)}function ye(r){return Math.asinh(r)}function ge(r){if(r<1)throw new Error("Inverse hyperbolic cosine is only defined for x >= 1");return Math.acosh(r)}function he(r){if(Math.abs(r)>=1)throw new Error("Inverse hyperbolic tangent is only defined for |x| < 1");return Math.atanh(r)}function Ve(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 Ne(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 we(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}var en=(r,e={})=>{let{locale:n="en-US",minimumFractionDigits:t=0,maximumFractionDigits:o=20}=e;return new Intl.NumberFormat(n,{minimumFractionDigits:t,maximumFractionDigits:o}).format(r)},nn=(r,e="USD",n="en-US")=>new Intl.NumberFormat(n,{style:"currency",currency:e}).format(r),tn=(r,e=2)=>{if(r===0)return"0 Bytes";let n=1024,t=e<0?0:e,o=["Bytes","KB","MB","GB","TB","PB","EB","ZB","YB"],u=Math.floor(Math.log(r)/Math.log(n));return`${parseFloat((r/Math.pow(n,u)).toFixed(t))} ${o[u]}`},on=(r,e=2,n="en-US")=>{let t=r*100;return new Intl.NumberFormat(n,{style:"percent",minimumFractionDigits:0,maximumFractionDigits:Math.max(0,e)}).format(t/100)};var un=(r,e)=>{let[n,t]=r<=e?[r,e]:[e,r];if(typeof crypto<"u"&&crypto.getRandomValues){let o=t-n+1,u=4294967295,i=new Uint32Array(1),s;do crypto.getRandomValues(i),s=i[0]/(u+1);while(s>=1-1%o/1);return Math.floor(s*o)+n}return Math.floor(Math.random()*(t-n+1))+n},mn=(r,e)=>{let[n,t]=r<=e?[r,e]:[e,r];return Math.random()*(t-n)+n},cn=(r=.5)=>Math.random()<r;var sn=(r,e)=>{if(typeof r=="number")return Number.isFinite(r)?r:e!==void 0?e:NaN;if(r==null)return e!==void 0?e:NaN;if(typeof r=="boolean")return r?1:0;if(typeof r=="string"){let t=r.trim();if(t==="")return e!==void 0?e:NaN;let o=Number(t);return Number.isFinite(o)?o:e!==void 0?e:NaN}let n=Number(r);return Number.isFinite(n)?n:e!==void 0?e:NaN},an=(r,e=10,n)=>{let t=r.trim();if(t==="")return n!==void 0?n:NaN;if(e===16){let u=/^(-?)0?x?([0-9a-fA-F]+)$/,i=t.match(u);if(i){let s=i[1]?-1:1,y=i[2],F=parseInt(y,16);return isNaN(F)?n!==void 0?n:NaN:s*F}}let o=parseInt(t,e);if(isNaN(o))return n!==void 0?n:NaN;if(e!==16&&e!==10){let u="0123456789abcdefghijklmnopqrstuvwxyz".slice(0,e);if(!new RegExp(`^[-+]?[${u}]+$`,"i").test(t))return n!==void 0?n:NaN}return o};
+/*! @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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Constants: () => Constants,
+  DEGREES_IN_CIRCLE: () => DEGREES_IN_CIRCLE,
+  DEGREES_PER_RADIAN: () => DEGREES_PER_RADIAN,
+  E: () => E,
+  GRADIANS_IN_CIRCLE: () => GRADIANS_IN_CIRCLE,
+  LN10: () => LN10,
+  LN2: () => LN2,
+  LOG10E: () => LOG10E,
+  LOG2E: () => LOG2E,
+  PHI: () => PHI,
+  PI: () => PI,
+  RADIANS_IN_CIRCLE: () => RADIANS_IN_CIRCLE,
+  RADIANS_PER_DEGREE: () => RADIANS_PER_DEGREE,
+  SQRT1_2: () => SQRT1_2,
+  SQRT2: () => SQRT2,
+  abs: () => abs,
+  acos: () => acos,
+  acosh: () => acosh,
+  add: () => add,
+  addComplex: () => addComplex,
+  addFractions: () => addFractions,
+  addVectors2D: () => addVectors2D,
+  angleBetween2D: () => angleBetween2D,
+  approxEqual: () => approxEqual,
+  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,
+  formatBytes: () => formatBytes,
+  formatCurrency: () => formatCurrency,
+  formatNumber: () => formatNumber,
+  formatPercent: () => formatPercent,
+  fromPolarComplex: () => fromPolarComplex,
+  gcd: () => gcd,
+  gradToDeg: () => gradToDeg,
+  invLerp: () => invLerp,
+  isComplexNumber: () => isComplexNumber,
+  isEven: () => isEven,
+  isFiniteNumber: () => isFiniteNumber,
+  isFloat: () => isFloat,
+  isFraction: () => isFraction,
+  isInRange: () => isInRange,
+  isInt: () => isInt,
+  isInteger: () => isInteger,
+  isMatrix: () => isMatrix,
+  isNegative: () => isNegative,
+  isNonNegative: () => isNonNegative,
+  isNonPositive: () => isNonPositive,
+  isNumber: () => isNumber,
+  isNumeric: () => isNumeric,
+  isNumericString: () => isNumericString,
+  isOdd: () => isOdd,
+  isPositive: () => isPositive,
+  isPowerOfTwo: () => isPowerOfTwo,
+  isPrime: () => isPrime,
+  isSafeInteger: () => isSafeInteger,
+  isVector2D: () => isVector2D,
+  isVector3D: () => isVector3D,
+  isZero: () => isZero,
+  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,
+  parseIntSafe: () => parseIntSafe,
+  percentage: () => percentage,
+  power: () => power,
+  powerComplex: () => powerComplex,
+  product: () => product,
+  radToDeg: () => radToDeg,
+  randomBool: () => randomBool,
+  randomFloat: () => randomFloat,
+  randomInt: () => randomInt,
+  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,
+  toNumber: () => toNumber,
+  toOrdinal: () => toOrdinal,
+  toPolarComplex: () => toPolarComplex,
+  trunc: () => trunc,
+  truncateDecimals: () => truncateDecimals,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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/guards.ts
+var isNumericString = (value) => {
+  const trimmed = value.trim();
+  if (trimmed === "") return false;
+  if (!/^[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$/.test(trimmed)) return false;
+  const num = Number(trimmed);
+  return Number.isFinite(num);
+};
+var isNumeric = (value) => {
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value === "string") return isNumericString(value);
+  return false;
+};
+var isInt = (value) => {
+  if (typeof value === "number") {
+    return Number.isInteger(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return false;
+    if (!/^[-+]?\d+$/.test(trimmed)) return false;
+    const num2 = Number(trimmed);
+    return Number.isInteger(num2) && Number.isFinite(num2);
+  }
+  if (typeof value === "boolean" || value == null) {
+    return false;
+  }
+  if (Array.isArray(value)) return false;
+  const num = Number(value);
+  return !Number.isNaN(num) && Number.isInteger(num) && Number.isFinite(num);
+};
+var isNumber = (value) => {
+  return typeof value === "number" && Number.isFinite(value);
+};
+var isSafeInteger = (value) => {
+  return typeof value === "number" && Number.isSafeInteger(value);
+};
+var isFloat = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) return false;
+  return !Number.isInteger(value);
+};
+function isInteger(value) {
+  return Number.isInteger(value);
+}
+function isFiniteNumber(value) {
+  return Number.isFinite(value);
+}
+function isVector2D(value) {
+  return typeof value === "object" && value !== null && "x" in value && "y" in value && typeof value.x === "number" && typeof value.y === "number";
+}
+function isVector3D(value) {
+  return typeof value === "object" && value !== null && "x" in value && "y" in value && "z" in value && typeof value.x === "number" && typeof value.y === "number" && typeof value.z === "number";
+}
+function isComplexNumber(value) {
+  return typeof value === "object" && value !== null && "real" in value && "imag" in value && typeof value.real === "number" && typeof value.imag === "number";
+}
+function isFraction(value) {
+  return typeof value === "object" && value !== null && "numerator" in value && "denominator" in value && typeof value.numerator === "number" && typeof value.denominator === "number" && value.denominator !== 0;
+}
+function isMatrix(value) {
+  return typeof value === "object" && value !== null && "rows" in value && "columns" in value && "data" in value && typeof value.rows === "number" && typeof value.columns === "number" && Array.isArray(value.data) && value.data.every((row) => Array.isArray(row));
+}
+var isPositive = (value) => {
+  return Number.isFinite(value) && value > 0;
+};
+var isNegative = (value) => {
+  return Number.isFinite(value) && value < 0;
+};
+function isNonNegative(value) {
+  return Number.isFinite(value) && value >= 0;
+}
+function isNonPositive(value) {
+  return Number.isFinite(value) && value <= 0;
+}
+var isZero = (value, epsilon = 1e-10) => {
+  return Number.isFinite(value) && Math.abs(value) < epsilon;
+};
+function isInRange(value, min2, max2, inclusive = true) {
+  return inclusive ? value >= min2 && value <= max2 : value > min2 && value < max2;
+}
+function isEven(value) {
+  return (value & 1) === 0;
+}
+function isOdd(value) {
+  return (value & 1) === 1;
+}
+var isPrime = (n) => {
+  if (!Number.isInteger(n)) {
+    return false;
+  }
+  if (n <= 1) return false;
+  if (n <= 3) return true;
+  if (n % 2 === 0 || n % 3 === 0) return false;
+  for (let i = 5; i * i <= n; i += 6) {
+    if (n % i === 0 || n % (i + 2) === 0) return false;
+  }
+  return true;
+};
+var approxEqual = (a, b, epsilon = Math.E) => {
+  if (a === b) return true;
+  if (!Number.isFinite(a) || !Number.isFinite(b)) {
+    return a === b;
+  }
+  const absA = Math.abs(a);
+  const absB = Math.abs(b);
+  const diff = Math.abs(a - b);
+  if (a === 0 || b === 0 || diff < epsilon) {
+    return diff < epsilon;
+  }
+  if (diff > epsilon) return false;
+  const relativeError = diff / Math.min(absA + absB, Number.MAX_SAFE_INTEGER);
+  return relativeError < epsilon;
+};
+var isPowerOfTwo = (n) => {
+  return n > 0 && (n & n - 1) === 0;
+};
+
+// 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/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;
+}
+
+// src/lib/maths/formatter.ts
+var formatNumber = (value, options = {}) => {
+  const {
+    locale = "en-US",
+    minimumFractionDigits = 0,
+    maximumFractionDigits = 20
+  } = options;
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits,
+    maximumFractionDigits
+  }).format(value);
+};
+var formatCurrency = (value, currency = "USD", locale = "en-US") => {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency
+  }).format(value);
+};
+var formatBytes = (bytes, decimals = 2) => {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+};
+var formatPercent = (value, decimals = 2, locale = "en-US") => {
+  const percent = value * 100;
+  return new Intl.NumberFormat(locale, {
+    style: "percent",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: Math.max(0, decimals)
+  }).format(percent / 100);
+};
+
+// src/lib/maths/random.ts
+var randomInt = (min2, max2) => {
+  const [realMin, realMax] = min2 <= max2 ? [min2, max2] : [max2, min2];
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const range2 = realMax - realMin + 1;
+    const maxSafe = 4294967295;
+    const byteArray = new Uint32Array(1);
+    let randomValue;
+    do {
+      crypto.getRandomValues(byteArray);
+      randomValue = byteArray[0] / (maxSafe + 1);
+    } while (randomValue >= 1 - 1 % range2 / 1);
+    return Math.floor(randomValue * range2) + realMin;
+  }
+  return Math.floor(Math.random() * (realMax - realMin + 1)) + realMin;
+};
+var randomFloat = (min2, max2) => {
+  const [realMin, realMax] = min2 <= max2 ? [min2, max2] : [max2, min2];
+  return Math.random() * (realMax - realMin) + realMin;
+};
+var randomBool = (probability = 0.5) => {
+  return Math.random() < probability;
+};
+
+// src/lib/maths/parser.ts
+var toNumber = (value, fallback) => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : fallback !== void 0 ? fallback : NaN;
+  }
+  if (value == null) {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") {
+      return fallback !== void 0 ? fallback : NaN;
+    }
+    const num2 = Number(trimmed);
+    return Number.isFinite(num2) ? num2 : fallback !== void 0 ? fallback : NaN;
+  }
+  const num = Number(value);
+  return Number.isFinite(num) ? num : fallback !== void 0 ? fallback : NaN;
+};
+var parseIntSafe = (value, radix = 10, fallback) => {
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  if (radix === 16) {
+    const hexRegex = /^(-?)0?x?([0-9a-fA-F]+)$/;
+    const match = trimmed.match(hexRegex);
+    if (match) {
+      const sign2 = match[1] ? -1 : 1;
+      const hexStr = match[2];
+      const parsed2 = parseInt(hexStr, 16);
+      return !isNaN(parsed2) ? sign2 * parsed2 : fallback !== void 0 ? fallback : NaN;
+    }
+  }
+  const parsed = parseInt(trimmed, radix);
+  if (isNaN(parsed)) {
+    return fallback !== void 0 ? fallback : NaN;
+  }
+  if (radix !== 16 && radix !== 10) {
+    const validDigits = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, radix);
+    const pattern = new RegExp(`^[-+]?[${validDigits}]+$`, "i");
+    if (!pattern.test(trimmed)) {
+      return fallback !== void 0 ? fallback : NaN;
+    }
+  }
+  return parsed;
+};