@fluixi/utils 1.0.0-alpha.53

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

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

package/dist/lib/maths/formatter.cjs

@@ -0,0 +1 @@
+"use strict";var o=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var c=(r,t)=>{for(var n in t)o(r,n,{get:t[n],enumerable:!0})},g=(r,t,n,m)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of s(t))!u.call(r,e)&&e!==n&&o(r,e,{get:()=>t[e],enumerable:!(m=a(t,e))||m.enumerable});return r};var l=r=>g(o({},"__esModule",{value:!0}),r);var x={};c(x,{formatBytes:()=>b,formatCurrency:()=>F,formatNumber:()=>B,formatPercent:()=>f});module.exports=l(x);var B=(r,t={})=>{let{locale:n="en-US",minimumFractionDigits:m=0,maximumFractionDigits:e=20}=t;return new Intl.NumberFormat(n,{minimumFractionDigits:m,maximumFractionDigits:e}).format(r)},F=(r,t="USD",n="en-US")=>new Intl.NumberFormat(n,{style:"currency",currency:t}).format(r),b=(r,t=2)=>{if(r===0)return"0 Bytes";let n=1024,m=t<0?0:t,e=["Bytes","KB","MB","GB","TB","PB","EB","ZB","YB"],i=Math.floor(Math.log(r)/Math.log(n));return`${parseFloat((r/Math.pow(n,i)).toFixed(m))} ${e[i]}`},f=(r,t=2,n="en-US")=>{let m=r*100;return new Intl.NumberFormat(n,{style:"percent",minimumFractionDigits:0,maximumFractionDigits:Math.max(0,t)}).format(m/100)};

package/dist/lib/maths/formatter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Formats a number with thousand separators and decimal places
+ * @param value - Number to format
+ * @param options - Options object with locale, minimumFractionDigits, and maximumFractionDigits
+ * Optimized: Uses Intl.NumberFormat for locale-aware formatting
+ */
+export declare const formatNumber: (value: number, options?: {
+    locale?: Intl.LocalesArgument;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}) => string;
+/**
+ * Formats a number as currency
+ * @param value - Number to format
+ * @param currency - Currency code (default: 'USD')
+ * @param locale - Locale string (default: 'en-US')
+ * Optimized: Uses Intl.NumberFormat
+ */
+export declare const formatCurrency: (value: number, currency?: string, locale?: string) => string;
+/**
+ * Formats bytes to human-readable string (KB, MB, GB, etc.)
+ * @param bytes - Number of bytes to format
+ * @param decimals - Number of decimal places to include (default: 2)
+ * Optimized: Logarithmic calculation for units
+ */
+export declare const formatBytes: (bytes: number, decimals?: number) => string;
+/**
+ * Formats a number as a percentage
+ * @param value - Number to format
+ * @param decimals - Number of decimal places to include (default: 2)
+ * @param locale - Locale string (default: 'en-US')
+ * Optimized: Single multiplication and formatting
+ */
+export declare const formatPercent: (value: number, decimals?: number, locale?: string) => string;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/lib/maths/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../../src/lib/maths/formatter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,MAAM,EACb,UAAS;IACP,MAAM,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC;IAC9B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAC3B,KACL,MAWF,CAAC;AAGF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,GACzB,OAAO,MAAM,EACb,WAAU,MAAc,EACxB,SAAQ,MAAgB,KACvB,MAKF,CAAC;AAGF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GACtB,OAAO,MAAM,EACb,WAAU,MAAU,KACnB,MASF,CAAC;AAGF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,MAAM,EACb,WAAU,MAAU,EACpB,SAAQ,MAAgB,KACvB,MAOF,CAAC"}

package/dist/lib/maths/formatter.js

@@ -0,0 +1,56 @@
+/**
+ * Formats a number with thousand separators and decimal places
+ * @param value - Number to format
+ * @param options - Options object with locale, minimumFractionDigits, and maximumFractionDigits
+ * Optimized: Uses Intl.NumberFormat for locale-aware formatting
+ */
+export const formatNumber = (value, options = {}) => {
+    const { locale = 'en-US', minimumFractionDigits = 0, maximumFractionDigits = 20 } = options;
+    return new Intl.NumberFormat(locale, {
+        minimumFractionDigits,
+        maximumFractionDigits
+    }).format(value);
+};
+/**
+ * Formats a number as currency
+ * @param value - Number to format
+ * @param currency - Currency code (default: 'USD')
+ * @param locale - Locale string (default: 'en-US')
+ * Optimized: Uses Intl.NumberFormat
+ */
+export const formatCurrency = (value, currency = 'USD', locale = 'en-US') => {
+    return new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency
+    }).format(value);
+};
+/**
+ * Formats bytes to human-readable string (KB, MB, GB, etc.)
+ * @param bytes - Number of bytes to format
+ * @param decimals - Number of decimal places to include (default: 2)
+ * Optimized: Logarithmic calculation for units
+ */
+export const 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]}`;
+};
+/**
+ * Formats a number as a percentage
+ * @param value - Number to format
+ * @param decimals - Number of decimal places to include (default: 2)
+ * @param locale - Locale string (default: 'en-US')
+ * Optimized: Single multiplication and formatting
+ */
+export const 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);
+};

package/dist/lib/maths/formatter.mjs

@@ -0,0 +1 @@
+var i=(t,r={})=>{let{locale:n="en-US",minimumFractionDigits:e=0,maximumFractionDigits:m=20}=r;return new Intl.NumberFormat(n,{minimumFractionDigits:e,maximumFractionDigits:m}).format(t)},a=(t,r="USD",n="en-US")=>new Intl.NumberFormat(n,{style:"currency",currency:r}).format(t),s=(t,r=2)=>{if(t===0)return"0 Bytes";let n=1024,e=r<0?0:r,m=["Bytes","KB","MB","GB","TB","PB","EB","ZB","YB"],o=Math.floor(Math.log(t)/Math.log(n));return`${parseFloat((t/Math.pow(n,o)).toFixed(e))} ${m[o]}`},u=(t,r=2,n="en-US")=>{let e=t*100;return new Intl.NumberFormat(n,{style:"percent",minimumFractionDigits:0,maximumFractionDigits:Math.max(0,r)}).format(e/100)};export{s as formatBytes,a as formatCurrency,i as formatNumber,u as formatPercent};

package/dist/lib/maths/guards.cjs

@@ -0,0 +1 @@
+"use strict";var s=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var b=Object.getOwnPropertyNames;var f=Object.prototype.hasOwnProperty;var a=(r,n)=>{for(var e in n)s(r,e,{get:n[e],enumerable:!0})},p=(r,n,e,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of b(n))!f.call(r,o)&&o!==e&&s(r,o,{get:()=>n[o],enumerable:!(t=m(n,o))||t.enumerable});return r};var y=r=>p(s({},"__esModule",{value:!0}),r);var T={};a(T,{approxEqual:()=>O,isComplexNumber:()=>A,isEven:()=>S,isFiniteNumber:()=>w,isFloat:()=>F,isFraction:()=>E,isInRange:()=>P,isInt:()=>N,isInteger:()=>d,isMatrix:()=>M,isNegative:()=>l,isNonNegative:()=>h,isNonPositive:()=>D,isNumber:()=>x,isNumeric:()=>c,isNumericString:()=>u,isOdd:()=>C,isPositive:()=>j,isPowerOfTwo:()=>R,isPrime:()=>z,isSafeInteger:()=>g,isVector2D:()=>I,isVector3D:()=>k,isZero:()=>V});module.exports=y(T);var u=r=>{let n=r.trim();if(n===""||!/^[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$/.test(n))return!1;let e=Number(n);return Number.isFinite(e)},c=r=>typeof r=="number"?Number.isFinite(r):typeof r=="string"?u(r):!1,N=r=>{if(typeof r=="number")return Number.isInteger(r);if(typeof r=="string"){let e=r.trim();if(!e||!/^[-+]?\d+$/.test(e))return!1;let t=Number(e);return Number.isInteger(t)&&Number.isFinite(t)}if(typeof r=="boolean"||r==null||Array.isArray(r))return!1;let n=Number(r);return!Number.isNaN(n)&&Number.isInteger(n)&&Number.isFinite(n)},x=r=>typeof r=="number"&&Number.isFinite(r),g=r=>typeof r=="number"&&Number.isSafeInteger(r),F=r=>typeof r!="number"||!Number.isFinite(r)?!1:!Number.isInteger(r);function d(r){return Number.isInteger(r)}function w(r){return Number.isFinite(r)}function I(r){return typeof r=="object"&&r!==null&&"x"in r&&"y"in r&&typeof r.x=="number"&&typeof r.y=="number"}function k(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 A(r){return typeof r=="object"&&r!==null&&"real"in r&&"imag"in r&&typeof r.real=="number"&&typeof r.imag=="number"}function E(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 M(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(n=>Array.isArray(n))}var j=r=>Number.isFinite(r)&&r>0,l=r=>Number.isFinite(r)&&r<0;function h(r){return Number.isFinite(r)&&r>=0}function D(r){return Number.isFinite(r)&&r<=0}var V=(r,n=1e-10)=>Number.isFinite(r)&&Math.abs(r)<n;function P(r,n,e,t=!0){return t?r>=n&&r<=e:r>n&&r<e}function S(r){return(r&1)===0}function C(r){return(r&1)===1}var z=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 n=5;n*n<=r;n+=6)if(r%n===0||r%(n+2)===0)return!1;return!0},O=(r,n,e=Math.E)=>{if(r===n)return!0;if(!Number.isFinite(r)||!Number.isFinite(n))return r===n;let t=Math.abs(r),o=Math.abs(n),i=Math.abs(r-n);return r===0||n===0||i<e?i<e:i>e?!1:i/Math.min(t+o,Number.MAX_SAFE_INTEGER)<e},R=r=>r>0&&(r&r-1)===0;

package/dist/lib/maths/guards.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Type guard functions for mathematical types.
+ * @module TypeGuards
+ */
+import type { Integer, Vector2D, Vector3D, ComplexNumber, Fraction } from './types/index.js';
+/**
+ * Checks if a string is a valid numeric string.
+ * @param value - The string to check
+ * @returns True if the string is a valid numeric string
+ */
+export declare const isNumericString: (value: string) => boolean;
+/**
+ * Type guard to check if a value is numeric.
+ * @param value - The value to check
+ * @returns True if the value is numeric
+ */
+export declare const isNumeric: (value: unknown) => value is number | string;
+/**
+ * Checks if a value is an integer with high performance
+ * @param value - The value to check
+ * @returns True if the value is a valid integer
+ * @example
+* isInt(42) // true
+* isInt("42") // true
+* isInt("42.5") // false
+* isInt(null) // false
+*/
+export declare const isInt: (value: unknown) => value is number;
+/**
+ * Checks if a value is a finite number (not NaN, Infinity, or string)
+ * @param value - The value to check
+ * @returns True if the value is a finite number
+ * @example
+* isNumber(42) // true
+* isNumber(NaN) // false
+* isNumber(Infinity) // false
+* isNumber("42") // false
+*/
+export declare const isNumber: (value: unknown) => value is number;
+/**
+ * Checks if a value is a safe integer within Number.MAX_SAFE_INTEGER range
+ * @param value - The value to check
+ * @returns True if value is a safe integer
+ * @example
+* isSafeInteger(42) // true
+* isSafeInteger(9007199254740992) // false (beyond safe range)
+*/
+export declare const isSafeInteger: (value: unknown) => boolean;
+/**
+ * Checks if a value is a float (not an integer)
+ * @param value - The value to check
+ * @returns True if the value is a float
+*/
+export declare const isFloat: (value: unknown) => boolean;
+/**
+ * Type guard to check if a number is an integer.
+ * @param value - The number to check
+ * @returns True if the number is an integer
+ */
+export declare function isInteger(value: unknown): value is Integer;
+/**
+ * Type guard to check if a number is a finite number.
+ * @param value - The number to check
+ * @returns True if the number is finite
+ */
+export declare function isFiniteNumber(value: number): boolean;
+/**
+ * Type guard to check if a value is a valid Vector2D.
+ * @param value - The value to check
+ * @returns True if the value is a valid Vector2D
+ */
+export declare function isVector2D(value: unknown): value is Vector2D;
+/**
+ * Type guard to check if a value is a valid Vector3D.
+ * @param value - The value to check
+ * @returns True if the value is a valid Vector3D
+ */
+export declare function isVector3D(value: unknown): value is Vector3D;
+/**
+ * Type guard to check if a value is a valid ComplexNumber.
+ * @param value - The value to check
+ * @returns True if the value is a valid ComplexNumber
+ */
+export declare function isComplexNumber(value: unknown): value is ComplexNumber;
+/**
+ * Type guard to check if a value is a valid Fraction.
+ * @param value - The value to check
+ * @returns True if the value is a valid Fraction
+ */
+export declare function isFraction(value: unknown): value is Fraction;
+/**
+ * Type guard to check if a value is a valid Matrix.
+ * @param value - The value to check
+ * @returns True if the value is a valid Matrix
+ */
+export declare function isMatrix(value: unknown): value is import('./types/index.js').Matrix<any, any>;
+/**
+ * Type guard to check if a number is positive (> 0).
+ * @param value - The number to check
+ * @returns True if the number is positive
+ */
+export declare const isPositive: (value: number) => boolean;
+/**
+ * Type guard to check if a number is negative (< 0).
+ * @param value - The number to check
+ * @returns True if the number is negative
+ */
+export declare const isNegative: (value: number) => boolean;
+/**
+ * Type guard to check if a number is non-negative (>= 0).
+ * @param value - The number to check
+ * @returns True if the number is non-negative
+ */
+export declare function isNonNegative(value: number): boolean;
+/**
+ * Type guard to check if a number is non-positive (<= 0).
+ * @param value - The number to check
+ * @returns True if the number is non-positive
+ */
+export declare function isNonPositive(value: number): boolean;
+/**
+ * Checks if a number is zero (or very close to zero)
+ */
+export declare const isZero: (value: number, epsilon?: number) => boolean;
+/**
+ * Type guard to check if a number is within a range (inclusive).
+ * @param value - The number to check
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @param inclusive - Whether the range is inclusive
+ * @returns True if the number is within the range
+ */
+export declare function isInRange(value: number, min: number, max: number, inclusive?: boolean): boolean;
+/**
+ * Type guard to check if a number is even.
+ * @param value - The number to check
+ * @returns True if the number is even
+ */
+export declare function isEven(value: number): boolean;
+/**
+ * Type guard to check if a number is odd.
+ * @param value - The number to check
+ * @returns True if the number is odd
+ */
+export declare function isOdd(value: number): boolean;
+/**
+ * Checks if a number is prime.
+ * @param n - The number to check
+ * @returns True if the number is prime, false otherwise
+ */
+export declare const isPrime: (n: number) => boolean;
+/**
+ * Checks if two numbers are approximately equal.
+ * @param a - First number
+ * @param b - Second number
+ * @param epsilon - The maximum allowed difference between the numbers
+ * @returns True if the numbers are approximately equal, false otherwise
+*/
+export declare const approxEqual: (a: number, b: number, epsilon?: number) => boolean;
+/**
+ * Checks if a number is a power of two
+ * @param n - The number to check
+ * Optimized: Bitwise trick
+ */
+export declare const isPowerOfTwo: (n: number) => boolean;
+//# sourceMappingURL=guards.d.ts.map

package/dist/lib/maths/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../../src/lib/maths/guards.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE7F;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,OAAO,MAAM,KAAG,OAS/C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,GAAG,MAI5D,CAAC;AAEF;;;;;;;;;EASE;AACF,eAAO,MAAM,KAAK,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MA4B/C,CAAC;AAIF;;;;;;;;;EASE;AACF,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAElD,CAAC;AAGF;;;;;;;EAOE;AACF,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,OAE9C,CAAC;AAGF;;;;EAIE;AACF,eAAO,MAAM,OAAO,GAAI,OAAO,OAAO,KAAG,OAGxC,CAAC;AACF;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAS5D;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAW5D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAStE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAU5D;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,kBAAkB,EAAE,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAY7F;AAED;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,KAAG,OAE1C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,MAAM,KAAG,OAE1C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,MAAM,EAAE,UAAS,MAAc,KAAG,OAE/D,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,GAAE,OAAc,GAAG,OAAO,CAErG;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAG7C;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAG5C;AAED;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAAI,GAAG,MAAM,KAAG,OAenC,CAAC;AAEF;;;;;;EAME;AACF,eAAO,MAAM,WAAW,GACtB,GAAG,MAAM,EACT,GAAG,MAAM,EACT,UAAS,MAAe,KACvB,OAqBF,CAAC;AAGF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,GAAG,MAAM,KAAG,OAExC,CAAC"}

package/dist/lib/maths/guards.js

@@ -0,0 +1,315 @@
+/**
+ * Type guard functions for mathematical types.
+ * @module TypeGuards
+ */
+/**
+ * Checks if a string is a valid numeric string.
+ * @param value - The string to check
+ * @returns True if the string is a valid numeric string
+ */
+export const isNumericString = (value) => {
+    const trimmed = value.trim();
+    if (trimmed === '')
+        return false;
+    // Allow: optional sign, digits, optional decimal with digits, optional exponent
+    if (!/^[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$/.test(trimmed))
+        return false;
+    const num = Number(trimmed);
+    return Number.isFinite(num);
+};
+/**
+ * Type guard to check if a value is numeric.
+ * @param value - The value to check
+ * @returns True if the value is numeric
+ */
+export const isNumeric = (value) => {
+    if (typeof value === 'number')
+        return Number.isFinite(value);
+    if (typeof value === 'string')
+        return isNumericString(value);
+    return false;
+};
+/**
+ * Checks if a value is an integer with high performance
+ * @param value - The value to check
+ * @returns True if the value is a valid integer
+ * @example
+* isInt(42) // true
+* isInt("42") // true
+* isInt("42.5") // false
+* isInt(null) // false
+*/
+export const isInt = (value) => {
+    // Fast path: number type
+    if (typeof value === 'number') {
+        return Number.isInteger(value);
+    }
+    // Fast path: string type
+    if (typeof value === 'string') {
+        const trimmed = value.trim();
+        if (!trimmed)
+            return false;
+        // Fast regex check: optional sign, digits only
+        if (!/^[-+]?\d+$/.test(trimmed))
+            return false;
+        // Parse and validate
+        const num = Number(trimmed);
+        return Number.isInteger(num) && Number.isFinite(num);
+    }
+    // Fast reject for non-numeric types
+    if (typeof value === 'boolean' || value == null) {
+        return false;
+    }
+    if (Array.isArray(value))
+        return false;
+    // For other types, attempt conversion
+    const num = Number(value);
+    return !Number.isNaN(num) && Number.isInteger(num) && Number.isFinite(num);
+};
+/**
+ * Checks if a value is a finite number (not NaN, Infinity, or string)
+ * @param value - The value to check
+ * @returns True if the value is a finite number
+ * @example
+* isNumber(42) // true
+* isNumber(NaN) // false
+* isNumber(Infinity) // false
+* isNumber("42") // false
+*/
+export const isNumber = (value) => {
+    return typeof value === 'number' && Number.isFinite(value);
+};
+/**
+ * Checks if a value is a safe integer within Number.MAX_SAFE_INTEGER range
+ * @param value - The value to check
+ * @returns True if value is a safe integer
+ * @example
+* isSafeInteger(42) // true
+* isSafeInteger(9007199254740992) // false (beyond safe range)
+*/
+export const isSafeInteger = (value) => {
+    return typeof value === 'number' && Number.isSafeInteger(value);
+};
+/**
+ * Checks if a value is a float (not an integer)
+ * @param value - The value to check
+ * @returns True if the value is a float
+*/
+export const isFloat = (value) => {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return false;
+    return !Number.isInteger(value);
+};
+/**
+ * Type guard to check if a number is an integer.
+ * @param value - The number to check
+ * @returns True if the number is an integer
+ */
+export function isInteger(value) {
+    return Number.isInteger(value);
+}
+/**
+ * Type guard to check if a number is a finite number.
+ * @param value - The number to check
+ * @returns True if the number is finite
+ */
+export function isFiniteNumber(value) {
+    return Number.isFinite(value);
+}
+/**
+ * Type guard to check if a value is a valid Vector2D.
+ * @param value - The value to check
+ * @returns True if the value is a valid Vector2D
+ */
+export function isVector2D(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'x' in value &&
+        'y' in value &&
+        typeof value.x === 'number' &&
+        typeof value.y === 'number');
+}
+/**
+ * Type guard to check if a value is a valid Vector3D.
+ * @param value - The value to check
+ * @returns True if the value is a valid Vector3D
+ */
+export 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');
+}
+/**
+ * Type guard to check if a value is a valid ComplexNumber.
+ * @param value - The value to check
+ * @returns True if the value is a valid ComplexNumber
+ */
+export function isComplexNumber(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'real' in value &&
+        'imag' in value &&
+        typeof value.real === 'number' &&
+        typeof value.imag === 'number');
+}
+/**
+ * Type guard to check if a value is a valid Fraction.
+ * @param value - The value to check
+ * @returns True if the value is a valid Fraction
+ */
+export 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);
+}
+/**
+ * Type guard to check if a value is a valid Matrix.
+ * @param value - The value to check
+ * @returns True if the value is a valid Matrix
+ */
+export 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)));
+}
+/**
+ * Type guard to check if a number is positive (> 0).
+ * @param value - The number to check
+ * @returns True if the number is positive
+ */
+export const isPositive = (value) => {
+    return Number.isFinite(value) && value > 0;
+};
+/**
+ * Type guard to check if a number is negative (< 0).
+ * @param value - The number to check
+ * @returns True if the number is negative
+ */
+export const isNegative = (value) => {
+    return Number.isFinite(value) && value < 0;
+};
+/**
+ * Type guard to check if a number is non-negative (>= 0).
+ * @param value - The number to check
+ * @returns True if the number is non-negative
+ */
+export function isNonNegative(value) {
+    return Number.isFinite(value) && value >= 0;
+}
+/**
+ * Type guard to check if a number is non-positive (<= 0).
+ * @param value - The number to check
+ * @returns True if the number is non-positive
+ */
+export function isNonPositive(value) {
+    return Number.isFinite(value) && value <= 0;
+}
+/**
+ * Checks if a number is zero (or very close to zero)
+ */
+export const isZero = (value, epsilon = 1e-10) => {
+    return Number.isFinite(value) && Math.abs(value) < epsilon;
+};
+/**
+ * Type guard to check if a number is within a range (inclusive).
+ * @param value - The number to check
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @param inclusive - Whether the range is inclusive
+ * @returns True if the number is within the range
+ */
+export function isInRange(value, min, max, inclusive = true) {
+    return inclusive ? value >= min && value <= max : value > min && value < max;
+}
+/**
+ * Type guard to check if a number is even.
+ * @param value - The number to check
+ * @returns True if the number is even
+ */
+export function isEven(value) {
+    // return value % 2 === 0;
+    return (value & 1) === 0;
+}
+/**
+ * Type guard to check if a number is odd.
+ * @param value - The number to check
+ * @returns True if the number is odd
+ */
+export function isOdd(value) {
+    // return value % 2 !== 0;
+    return (value & 1) === 1;
+}
+/**
+ * Checks if a number is prime.
+ * @param n - The number to check
+ * @returns True if the number is prime, false otherwise
+ */
+export const isPrime = (n) => {
+    // First check if it's an integer
+    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;
+};
+/**
+ * Checks if two numbers are approximately equal.
+ * @param a - First number
+ * @param b - Second number
+ * @param epsilon - The maximum allowed difference between the numbers
+ * @returns True if the numbers are approximately equal, false otherwise
+*/
+export const approxEqual = (a, b, epsilon = Math.E) => {
+    // Handle edge cases
+    if (a === b)
+        return true;
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        // Both are NaN or both are same infinity
+        return a === b;
+    }
+    // Use relative epsilon for better precision across different magnitudes
+    const absA = Math.abs(a);
+    const absB = Math.abs(b);
+    const diff = Math.abs(a - b);
+    // For very small numbers, use absolute epsilon
+    if (a === 0 || b === 0 || diff < epsilon) {
+        return diff < epsilon;
+    }
+    if (diff > epsilon)
+        return false;
+    // For larger numbers, use relative epsilon
+    const relativeError = diff / Math.min(absA + absB, Number.MAX_SAFE_INTEGER);
+    return relativeError < epsilon;
+};
+/**
+ * Checks if a number is a power of two
+ * @param n - The number to check
+ * Optimized: Bitwise trick
+ */
+export const isPowerOfTwo = (n) => {
+    return n > 0 && (n & (n - 1)) === 0;
+};

package/dist/lib/maths/guards.mjs

@@ -0,0 +1 @@
+var s=r=>{let n=r.trim();if(n===""||!/^[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?$/.test(n))return!1;let e=Number(n);return Number.isFinite(e)},m=r=>typeof r=="number"?Number.isFinite(r):typeof r=="string"?s(r):!1,b=r=>{if(typeof r=="number")return Number.isInteger(r);if(typeof r=="string"){let e=r.trim();if(!e||!/^[-+]?\d+$/.test(e))return!1;let t=Number(e);return Number.isInteger(t)&&Number.isFinite(t)}if(typeof r=="boolean"||r==null||Array.isArray(r))return!1;let n=Number(r);return!Number.isNaN(n)&&Number.isInteger(n)&&Number.isFinite(n)},f=r=>typeof r=="number"&&Number.isFinite(r),a=r=>typeof r=="number"&&Number.isSafeInteger(r),p=r=>typeof r!="number"||!Number.isFinite(r)?!1:!Number.isInteger(r);function y(r){return Number.isInteger(r)}function c(r){return Number.isFinite(r)}function N(r){return typeof r=="object"&&r!==null&&"x"in r&&"y"in r&&typeof r.x=="number"&&typeof r.y=="number"}function x(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 g(r){return typeof r=="object"&&r!==null&&"real"in r&&"imag"in r&&typeof r.real=="number"&&typeof r.imag=="number"}function F(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 d(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(n=>Array.isArray(n))}var w=r=>Number.isFinite(r)&&r>0,I=r=>Number.isFinite(r)&&r<0;function k(r){return Number.isFinite(r)&&r>=0}function A(r){return Number.isFinite(r)&&r<=0}var E=(r,n=1e-10)=>Number.isFinite(r)&&Math.abs(r)<n;function M(r,n,e,t=!0){return t?r>=n&&r<=e:r>n&&r<e}function j(r){return(r&1)===0}function l(r){return(r&1)===1}var h=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 n=5;n*n<=r;n+=6)if(r%n===0||r%(n+2)===0)return!1;return!0},D=(r,n,e=Math.E)=>{if(r===n)return!0;if(!Number.isFinite(r)||!Number.isFinite(n))return r===n;let t=Math.abs(r),i=Math.abs(n),o=Math.abs(r-n);return r===0||n===0||o<e?o<e:o>e?!1:o/Math.min(t+i,Number.MAX_SAFE_INTEGER)<e},V=r=>r>0&&(r&r-1)===0;export{D as approxEqual,g as isComplexNumber,j as isEven,c as isFiniteNumber,p as isFloat,F as isFraction,M as isInRange,b as isInt,y as isInteger,d as isMatrix,I as isNegative,k as isNonNegative,A as isNonPositive,f as isNumber,m as isNumeric,s as isNumericString,l as isOdd,w as isPositive,V as isPowerOfTwo,h as isPrime,a as isSafeInteger,N as isVector2D,x as isVector3D,E as isZero};