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

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

@@ -1 +1,212 @@
-"use strict";var a=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var M=Object.prototype.hasOwnProperty;var g=(r,n)=>{for(var e in n)a(r,e,{get:n[e],enumerable:!0})},x=(r,n,e,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let u of l(n))!M.call(r,u)&&u!==e&&a(r,u,{get:()=>n[u],enumerable:!(t=p(n,u))||t.enumerable});return r};var w=r=>x(a({},"__esModule",{value:!0}),r);var K={};g(K,{abs:()=>R,add:()=>y,average:()=>z,ceil:()=>q,clamp:()=>s,divide:()=>T,factorial:()=>D,floor:()=>j,gcd:()=>f,invLerp:()=>h,lcm:()=>G,lerp:()=>d,mapRange:()=>I,max:()=>U,median:()=>H,min:()=>L,modulo:()=>A,power:()=>F,product:()=>J,round:()=>c,sign:()=>C,sqrt:()=>S,subtract:()=>N,sum:()=>B,trunc:()=>E});module.exports=w(K);function y(r,n){return r+n}function N(r,n){return r-n}var T=(r,n,e)=>n===0?e!==void 0?e:NaN:r/n;function A(r,n){return r%n}function F(r,n){return Math.pow(r,n)}function S(r){if(r<0)throw new Error("Cannot calculate square root of negative number");return Math.sqrt(r)}function R(r){return Math.abs(r)}var c=(r,n=0,e="round")=>{if(e==="david")return k(r,n,e);if(!Number.isFinite(r))return r;if(n===0)return Math[e](r);if(n<0){let m=10**-n;return Math[e](r/m)*m}let t=10**n,u=Math.pow(2,-52),o=r*t,i=Math.sign(o)*u*Math.abs(o),b;switch(e){case"round":b=Math.round(o+i);break;case"ceil":b=Math.ceil(o-u);break;case"floor":b=Math.floor(o+u);break;case"trunc":b=o<0?Math.ceil(o):Math.floor(o);break;default:b=Math.round(o+i)}return b/t},k=(r,n=0,e="round")=>{let t=Math.abs(r),u=r<0?-1:1;if(n===0)return Math.round(t)*u;if(!Number.isFinite(t))return t*u;let o=10**n,i=t*o,b=Math.pow(2,-53),m=Math.sign(i)*b*Math.abs(i);return i+=m,Math.round(i)/o*u},q=(r,n=0)=>c(r,n,"ceil"),j=(r,n=0)=>c(r,n,"floor"),E=(r,n=0)=>c(r,n,"trunc"),s=(r,n,e)=>(n>e&&([n,e]=[e,n]),r<n?n:r>e?e:r);function C(r){return r>0?1:r<0?-1:0}function D(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 n=1;for(let e=2;e<=r;e++)n*=e;return n}function f(r,n){for(r=Math.abs(r),n=Math.abs(n);n!==0;){let e=n;n=r%n,r=e}return r}function G(r,n){return Math.abs(r*n)/f(r,n)}function d(r,n,e){return r+(n-r)*s(e,0,1)}var h=(r,n,e)=>s((e-r)/(n-r),0,1),I=(r,n,e,t,u)=>{let o=h(n,e,r);return d(t,u,o)};function L(...r){return Math.min(...r)}function U(...r){return Math.max(...r)}var z=(...r)=>{if(!Array.isArray(r)||r.length===0)return 0;let n=0,e=0;for(let t of r)Number.isFinite(t)&&(n+=t,e++);return e===0?0:n/e},B=(...r)=>Array.isArray(r)?r.reduce((n,e)=>n+(Number.isFinite(e)?e:0),0):0,H=(...r)=>{if(!Array.isArray(r)||r.length===0)return 0;let n=r.filter(Number.isFinite);if(n.length===0)return 0;n.sort((t,u)=>t-u);let e=Math.floor(n.length/2);return n.length%2===0?(n[e-1]+n[e])/2:n[e]};function J(...r){return r.reduce((n,e)=>n*e,1)}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/maths/fn/basic.ts
+var basic_exports = {};
+__export(basic_exports, {
+  abs: () => abs,
+  add: () => add,
+  average: () => average,
+  ceil: () => ceil,
+  clamp: () => clamp,
+  divide: () => divide,
+  factorial: () => factorial,
+  floor: () => floor,
+  gcd: () => gcd,
+  invLerp: () => invLerp,
+  lcm: () => lcm,
+  lerp: () => lerp,
+  mapRange: () => mapRange,
+  max: () => max,
+  median: () => median,
+  min: () => min,
+  modulo: () => modulo,
+  power: () => power,
+  product: () => product,
+  round: () => round,
+  sign: () => sign,
+  sqrt: () => sqrt,
+  subtract: () => subtract,
+  sum: () => sum,
+  trunc: () => trunc
+});
+module.exports = __toCommonJS(basic_exports);
+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);
+}

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

@@ -1 +1,191 @@
-function l(r,n){return r+n}function M(r,n){return r-n}var g=(r,n,e)=>n===0?e!==void 0?e:NaN:r/n;function x(r,n){return r%n}function w(r,n){return Math.pow(r,n)}function y(r){if(r<0)throw new Error("Cannot calculate square root of negative number");return Math.sqrt(r)}function N(r){return Math.abs(r)}var c=(r,n=0,e="round")=>{if(e==="david")return s(r,n,e);if(!Number.isFinite(r))return r;if(n===0)return Math[e](r);if(n<0){let m=10**-n;return Math[e](r/m)*m}let t=10**n,o=Math.pow(2,-52),u=r*t,i=Math.sign(u)*o*Math.abs(u),b;switch(e){case"round":b=Math.round(u+i);break;case"ceil":b=Math.ceil(u-o);break;case"floor":b=Math.floor(u+o);break;case"trunc":b=u<0?Math.ceil(u):Math.floor(u);break;default:b=Math.round(u+i)}return b/t},s=(r,n=0,e="round")=>{let t=Math.abs(r),o=r<0?-1:1;if(n===0)return Math.round(t)*o;if(!Number.isFinite(t))return t*o;let u=10**n,i=t*u,b=Math.pow(2,-53),m=Math.sign(i)*b*Math.abs(i);return i+=m,Math.round(i)/u*o},T=(r,n=0)=>c(r,n,"ceil"),A=(r,n=0)=>c(r,n,"floor"),F=(r,n=0)=>c(r,n,"trunc"),a=(r,n,e)=>(n>e&&([n,e]=[e,n]),r<n?n:r>e?e:r);function S(r){return r>0?1:r<0?-1:0}function R(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 n=1;for(let e=2;e<=r;e++)n*=e;return n}function f(r,n){for(r=Math.abs(r),n=Math.abs(n);n!==0;){let e=n;n=r%n,r=e}return r}function k(r,n){return Math.abs(r*n)/f(r,n)}function d(r,n,e){return r+(n-r)*a(e,0,1)}var h=(r,n,e)=>a((e-r)/(n-r),0,1),q=(r,n,e,t,o)=>{let u=h(n,e,r);return d(t,o,u)};function j(...r){return Math.min(...r)}function E(...r){return Math.max(...r)}var C=(...r)=>{if(!Array.isArray(r)||r.length===0)return 0;let n=0,e=0;for(let t of r)Number.isFinite(t)&&(n+=t,e++);return e===0?0:n/e},D=(...r)=>Array.isArray(r)?r.reduce((n,e)=>n+(Number.isFinite(e)?e:0),0):0,G=(...r)=>{if(!Array.isArray(r)||r.length===0)return 0;let n=r.filter(Number.isFinite);if(n.length===0)return 0;n.sort((t,o)=>t-o);let e=Math.floor(n.length/2);return n.length%2===0?(n[e-1]+n[e])/2:n[e]};function I(...r){return r.reduce((n,e)=>n*e,1)}export{N as abs,l as add,C as average,T as ceil,a as clamp,g as divide,R as factorial,A as floor,f as gcd,h as invLerp,k as lcm,d as lerp,q as mapRange,E as max,G as median,j as min,x as modulo,w as power,I as product,c as round,S as sign,y as sqrt,M as subtract,D as sum,F as trunc};
+// 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);
+}
+export {
+  abs,
+  add,
+  average,
+  ceil,
+  clamp,
+  divide,
+  factorial,
+  floor,
+  gcd,
+  invLerp,
+  lcm,
+  lerp,
+  mapRange,
+  max,
+  median,
+  min,
+  modulo,
+  power,
+  product,
+  round,
+  sign,
+  sqrt,
+  subtract,
+  sum,
+  trunc
+};

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

@@ -1 +1,268 @@
-"use strict";var s=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var w=Object.prototype.hasOwnProperty;var E=(e,r)=>{for(var o in r)s(e,o,{get:r[o],enumerable:!0})},P=(e,r,o,a)=>{if(r&&typeof r=="object"||typeof r=="function")for(let l of d(r))!w.call(e,l)&&l!==o&&s(e,l,{get:()=>r[l],enumerable:!(a=c(r,l))||a.enumerable});return e};var I=e=>P(s({},"__esModule",{value:!0}),e);var W={};E(W,{addComplex:()=>S,argumentComplex:()=>b,complexEquals:()=>z,conjugateComplex:()=>O,cosComplex:()=>A,createComplex:()=>i,divideComplex:()=>v,expComplex:()=>$,fromPolarComplex:()=>x,getImag:()=>k,getReal:()=>Z,isZeroComplex:()=>R,lnComplex:()=>L,magnitudeComplex:()=>g,multiplyComplex:()=>h,negateComplex:()=>D,powerComplex:()=>F,reciprocalComplex:()=>T,sinComplex:()=>j,sqrtComplex:()=>q,subtractComplex:()=>y,toPolarComplex:()=>M});module.exports=I(W);var N=2*Math.PI;function n(e){return Math.abs(e)<1e-10}function p(e,r){return Math.abs(e-r)<1e-10}function t(e){return{real:n(e.real)?0:e.real,imag:n(e.imag)?0:e.imag}}function u(e,r){if(typeof e!="number"||!Number.isFinite(e))throw new Error(`${r} must be a finite number, got ${e}`)}function m(e,r="Complex number"){if(!e||typeof e!="object")throw new Error(`${r} must be an object`);u(e.real,`${r}.real`),u(e.imag,`${r}.imag`)}function i(e,r=0){return u(e,"real"),u(r,"imag"),t({real:e,imag:r})}function z(e,r){return m(e,"First complex number"),m(r,"Second complex number"),p(e.real,r.real)&&p(e.imag,r.imag)}function S(e,r){return m(e,"First complex number"),m(r,"Second complex number"),t({real:e.real+r.real,imag:e.imag+r.imag})}function y(e,r){return m(e,"First complex number"),m(r,"Second complex number"),t({real:e.real-r.real,imag:e.imag-r.imag})}function h(e,r){return m(e,"First complex number"),m(r,"Second complex number"),t({real:e.real*r.real-e.imag*r.imag,imag:e.real*r.imag+e.imag*r.real})}function v(e,r){m(e,"Numerator complex number"),m(r,"Denominator complex number");let o=r.real*r.real+r.imag*r.imag;if(n(o))throw new Error("Cannot divide by zero or near-zero complex number");return t({real:(e.real*r.real+e.imag*r.imag)/o,imag:(e.imag*r.real-e.real*r.imag)/o})}function g(e){m(e);let r=Math.sqrt(e.real*e.real+e.imag*e.imag);return n(r)?0:r}function O(e){return m(e),t({real:e.real,imag:-e.imag})}function b(e){return m(e),n(e.real)&&n(e.imag)?0:Math.atan2(e.imag,e.real)}function M(e){return m(e),{magnitude:g(e),angle:b(e)}}function x(e,r){if(u(e,"magnitude"),u(r,"angle"),e<-1e-10)throw new Error("Magnitude must be non-negative");let o=r%N;o>Math.PI&&(o-=N),o<=-Math.PI&&(o+=N);let a=Math.max(0,e);return t({real:a*Math.cos(o),imag:a*Math.sin(o)})}function q(e){if(m(e),n(e.real)&&n(e.imag)){let f=i(0,0);return[f,f]}let r=g(e),o=b(e),a=Math.sqrt(r),l=o/2,C=l+Math.PI;return[x(a,l),x(a,C)]}function F(e,r){if(m(e),u(r,"exponent"),n(r))return i(1,0);if(p(r,1))return i(e.real,e.imag);if(p(r,2))return h(e,e);if(n(e.real)&&n(e.imag)){if(r>0)return i(0,0);if(r<0)throw new Error("Cannot raise zero to a negative power")}let o=M(e),a=Math.pow(o.magnitude,r),l=a<-1e-10?Math.abs(a):Math.max(0,a),C=o.angle*r;return x(l,C)}function L(e){m(e);let r=g(e);if(n(r))throw new Error("Cannot take logarithm of zero or near-zero complex number");let o=b(e);return t({real:Math.log(r),imag:o})}function $(e){m(e);let r=Math.exp(e.real);return t({real:r*Math.cos(e.imag),imag:r*Math.sin(e.imag)})}function j(e){return m(e),t({real:Math.sin(e.real)*Math.cosh(e.imag),imag:Math.cos(e.real)*Math.sinh(e.imag)})}function A(e){return m(e),t({real:Math.cos(e.real)*Math.cosh(e.imag),imag:-Math.sin(e.real)*Math.sinh(e.imag)})}function R(e){return m(e),n(e.real)&&n(e.imag)}function Z(e){return m(e),e.real}function k(e){return m(e),e.imag}function D(e){return m(e),t({real:-e.real,imag:-e.imag})}function T(e){m(e);let r=e.real*e.real+e.imag*e.imag;if(n(r))throw new Error("Cannot calculate reciprocal of zero or near-zero complex number");return t({real:e.real/r,imag:-e.imag/r})}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/maths/fn/complex.ts
+var complex_exports = {};
+__export(complex_exports, {
+  addComplex: () => addComplex,
+  argumentComplex: () => argumentComplex,
+  complexEquals: () => complexEquals,
+  conjugateComplex: () => conjugateComplex,
+  cosComplex: () => cosComplex,
+  createComplex: () => createComplex,
+  divideComplex: () => divideComplex,
+  expComplex: () => expComplex,
+  fromPolarComplex: () => fromPolarComplex,
+  getImag: () => getImag,
+  getReal: () => getReal,
+  isZeroComplex: () => isZeroComplex,
+  lnComplex: () => lnComplex,
+  magnitudeComplex: () => magnitudeComplex,
+  multiplyComplex: () => multiplyComplex,
+  negateComplex: () => negateComplex,
+  powerComplex: () => powerComplex,
+  reciprocalComplex: () => reciprocalComplex,
+  sinComplex: () => sinComplex,
+  sqrtComplex: () => sqrtComplex,
+  subtractComplex: () => subtractComplex,
+  toPolarComplex: () => toPolarComplex
+});
+module.exports = __toCommonJS(complex_exports);
+var EPSILON = 1e-10;
+var TWO_PI = 2 * Math.PI;
+function isApproximatelyZero(value) {
+  return Math.abs(value) < EPSILON;
+}
+function approximatelyEqual(a, b) {
+  return Math.abs(a - b) < EPSILON;
+}
+function normalizeComplex(c) {
+  return {
+    real: isApproximatelyZero(c.real) ? 0 : c.real,
+    imag: isApproximatelyZero(c.imag) ? 0 : c.imag
+  };
+}
+function validateNumber(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`);
+  }
+  validateNumber(c.real, `${name}.real`);
+  validateNumber(c.imag, `${name}.imag`);
+}
+function createComplex(real, imag = 0) {
+  validateNumber(real, "real");
+  validateNumber(imag, "imag");
+  return normalizeComplex({ real, imag });
+}
+function complexEquals(a, b) {
+  validateComplexNumber(a, "First complex number");
+  validateComplexNumber(b, "Second complex number");
+  return approximatelyEqual(a.real, b.real) && approximatelyEqual(a.imag, b.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 (isApproximatelyZero(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 isApproximatelyZero(magnitude) ? 0 : magnitude;
+}
+function conjugateComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: c.real,
+    imag: -c.imag
+  });
+}
+function argumentComplex(c) {
+  validateComplexNumber(c);
+  if (isApproximatelyZero(c.real) && isApproximatelyZero(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) {
+  validateNumber(magnitude, "magnitude");
+  validateNumber(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 (isApproximatelyZero(c.real) && isApproximatelyZero(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);
+  validateNumber(exponent, "exponent");
+  if (isApproximatelyZero(exponent)) {
+    return createComplex(1, 0);
+  }
+  if (approximatelyEqual(exponent, 1)) {
+    return createComplex(c.real, c.imag);
+  }
+  if (approximatelyEqual(exponent, 2)) {
+    return multiplyComplex(c, c);
+  }
+  if (isApproximatelyZero(c.real) && isApproximatelyZero(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 (isApproximatelyZero(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
+  });
+}
+function expComplex(c) {
+  validateComplexNumber(c);
+  const expReal = Math.exp(c.real);
+  return normalizeComplex({
+    real: expReal * Math.cos(c.imag),
+    imag: expReal * Math.sin(c.imag)
+  });
+}
+function sinComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: Math.sin(c.real) * Math.cosh(c.imag),
+    imag: Math.cos(c.real) * Math.sinh(c.imag)
+  });
+}
+function cosComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: Math.cos(c.real) * Math.cosh(c.imag),
+    imag: -Math.sin(c.real) * Math.sinh(c.imag)
+  });
+}
+function isZeroComplex(c) {
+  validateComplexNumber(c);
+  return isApproximatelyZero(c.real) && isApproximatelyZero(c.imag);
+}
+function getReal(c) {
+  validateComplexNumber(c);
+  return c.real;
+}
+function getImag(c) {
+  validateComplexNumber(c);
+  return c.imag;
+}
+function negateComplex(c) {
+  validateComplexNumber(c);
+  return normalizeComplex({
+    real: -c.real,
+    imag: -c.imag
+  });
+}
+function reciprocalComplex(c) {
+  validateComplexNumber(c);
+  const denominator = c.real * c.real + c.imag * c.imag;
+  if (isApproximatelyZero(denominator)) {
+    throw new Error(
+      "Cannot calculate reciprocal of zero or near-zero complex number"
+    );
+  }
+  return normalizeComplex({
+    real: c.real / denominator,
+    imag: -c.imag / denominator
+  });
+}