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

package/dist/lib/maths/constants.cjs

@@ -1 +1,70 @@
-"use strict";var e=Object.defineProperty;var G=Object.getOwnPropertyDescriptor;var P=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var m=(s,t)=>{for(var c in t)e(s,c,{get:t[c],enumerable:!0})},u=(s,t,c,a)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of P(t))!b.call(s,o)&&o!==c&&e(s,o,{get:()=>t[o],enumerable:!(a=G(t,o))||a.enumerable});return s};var y=s=>u(e({},"__esModule",{value:!0}),s);var Q={};m(Q,{Constants:()=>O,DEGREES_IN_CIRCLE:()=>N,DEGREES_PER_RADIAN:()=>L,E:()=>r,GRADIANS_IN_CIRCLE:()=>D,LN10:()=>I,LN2:()=>R,LOG10E:()=>C,LOG2E:()=>_,PHI:()=>p,PI:()=>n,RADIANS_IN_CIRCLE:()=>A,RADIANS_PER_DEGREE:()=>S,SQRT1_2:()=>x,SQRT2:()=>E});module.exports=y(Q);var n=3.141592653589793,r=2.718281828459045,p=1.618033988749894,E=1.4142135623730951,x=.7071067811865476,R=.6931471805599453,I=2.302585092994046,_=1.4426950408889634,C=.4342944819032518,N=360,A=2*n,D=400,L=180/n,S=n/180,O={PI:n,E:r,PHI:p,SQRT2:E,SQRT1_2:x,LN2:R,LN10:I,LOG2E:_,LOG10E:C,DEGREES_IN_CIRCLE:N,RADIANS_IN_CIRCLE:A,GRADIANS_IN_CIRCLE:D,DEGREES_PER_RADIAN:L,RADIANS_PER_DEGREE:S};
+/*! @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/constants.ts
+var constants_exports = {};
+__export(constants_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
+});
+module.exports = __toCommonJS(constants_exports);
+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
+};

package/dist/lib/maths/constants.mjs

@@ -1 +1,50 @@
-var t=3.141592653589793,s=2.718281828459045,o=1.618033988749894,n=1.4142135623730951,c=.7071067811865476,e=.6931471805599453,a=2.302585092994046,r=1.4426950408889634,p=.4342944819032518,E=360,x=2*t,R=400,I=180/t,_=t/180,C={PI:t,E:s,PHI:o,SQRT2:n,SQRT1_2:c,LN2:e,LN10:a,LOG2E:r,LOG10E:p,DEGREES_IN_CIRCLE:E,RADIANS_IN_CIRCLE:x,GRADIANS_IN_CIRCLE:R,DEGREES_PER_RADIAN:I,RADIANS_PER_DEGREE:_};export{C as Constants,E as DEGREES_IN_CIRCLE,I as DEGREES_PER_RADIAN,s as E,R as GRADIANS_IN_CIRCLE,a as LN10,e as LN2,p as LOG10E,r as LOG2E,o as PHI,t as PI,x as RADIANS_IN_CIRCLE,_ as RADIANS_PER_DEGREE,c as SQRT1_2,n as SQRT2};
+/*! @fluixi/utils v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// 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
+};
+export {
+  Constants,
+  DEGREES_IN_CIRCLE,
+  DEGREES_PER_RADIAN,
+  E,
+  GRADIANS_IN_CIRCLE,
+  LN10,
+  LN2,
+  LOG10E,
+  LOG2E,
+  PHI,
+  PI,
+  RADIANS_IN_CIRCLE,
+  RADIANS_PER_DEGREE,
+  SQRT1_2,
+  SQRT2
+};

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

@@ -1 +1,231 @@
-"use strict";var c=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var h=Object.prototype.hasOwnProperty;var l=(r,n)=>{for(var e in n)c(r,e,{get:n[e],enumerable:!0})},g=(r,n,e,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of p(n))!h.call(r,o)&&o!==e&&c(r,o,{get:()=>n[o],enumerable:!(t=d(n,o))||t.enumerable});return r};var x=r=>g(c({},"__esModule",{value:!0}),r);var I={};l(I,{addFractions:()=>R,cbrt:()=>T,evaluatePolynomial:()=>q,exp:()=>E,ln:()=>w,log:()=>N,log10:()=>y,log2:()=>F,multiplyFractions:()=>L,normalize:()=>z,nthRoot:()=>S,percentage:()=>j,range:()=>D,simplifyFraction:()=>a,solveQuadratic:()=>A,toBase:()=>k,toOrdinal:()=>C,truncateDecimals:()=>B,wrap:()=>G});module.exports=x(I);var s=(r,n=0,e="round")=>{if(e==="david")return M(r,n,e);if(!Number.isFinite(r))return r;if(n===0)return Math[e](r);if(n<0){let b=10**-n;return Math[e](r/b)*b}let t=10**n,o=Math.pow(2,-52),u=r*t,m=Math.sign(u)*o*Math.abs(u),i;switch(e){case"round":i=Math.round(u+m);break;case"ceil":i=Math.ceil(u-o);break;case"floor":i=Math.floor(u+o);break;case"trunc":i=u<0?Math.ceil(u):Math.floor(u);break;default:i=Math.round(u+m)}return i/t},M=(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,m=t*u,i=Math.pow(2,-53),b=Math.sign(m)*i*Math.abs(m);return m+=b,Math.round(m)/u*o};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 w(r){if(r<=0)throw new Error("Natural logarithm is only defined for positive numbers");return Math.log(r)}function y(r){if(r<=0)throw new Error("Logarithm is only defined for positive numbers");return Math.log10(r)}function F(r){if(r<=0)throw new Error("Logarithm is only defined for positive numbers");return Math.log2(r)}function N(r,n){if(r<=0||n<=0)throw new Error("Logarithm is only defined for positive numbers and bases");return Math.log(r)/Math.log(n)}function E(r){return Math.exp(r)}function T(r){return Math.cbrt(r)}function S(r,n){if(n===0)throw new Error("Cannot calculate 0th root");if(r<0&&n%2===0)throw new Error("Cannot calculate even root of negative number");let e=1/n;return Math.sign(r)*Math.pow(Math.abs(r),e)}function A(r,n,e){if(r===0)return n===0?[]:[-e/n];let t=n*n-4*r*e;if(t<0)return[];if(t===0)return[-n/(2*r)];{let o=Math.sqrt(t);return[(-n-o)/(2*r),(-n+o)/(2*r)]}}function q(r,n){let e=0;for(let t=0;t<r.length;t++)e=e*n+r[t];return e}function a(r){let n=f(r.numerator,r.denominator);return{numerator:r.numerator/n,denominator:r.denominator/n}}function R(r,n){let e=r.numerator*n.denominator+n.numerator*r.denominator,t=r.denominator*n.denominator;return a({numerator:e,denominator:t})}function L(r,n){let e=r.numerator*n.numerator,t=r.denominator*n.denominator;return a({numerator:e,denominator:t})}var j=(r,n,e=2)=>{if(n===0)return 0;let t=r/n*100;return s(t,e)},k=(r,n,e=1)=>{if(n<2||n>36)throw new Error("Base must be between 2 and 36");return r.toString(n).padStart(e,"0")},C=r=>{let n=["th","st","nd","rd"],e=r%100;return r+(n[(e-20)%10]||n[e]||n[0])},D=(r,n,e=1)=>{let t=[];if(e===0)return t;if(e>0)for(let o=r;o<n;o+=e)t.push(o);else for(let o=r;o>n;o+=e)t.push(o);return t},B=(r,n)=>{if(!Number.isFinite(r))return r;let e=10**n;return Math.trunc(r*e)/e},z=(r,n,e)=>n===e?0:(r-n)/(e-n),G=(r,n,e)=>{let t=e-n;return((r-n)%t+t)%t+n};
+"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/advanced.ts
+var advanced_exports = {};
+__export(advanced_exports, {
+  addFractions: () => addFractions,
+  cbrt: () => cbrt,
+  evaluatePolynomial: () => evaluatePolynomial,
+  exp: () => exp,
+  ln: () => ln,
+  log: () => log,
+  log10: () => log10,
+  log2: () => log2,
+  multiplyFractions: () => multiplyFractions,
+  normalize: () => normalize,
+  nthRoot: () => nthRoot,
+  percentage: () => percentage,
+  range: () => range,
+  simplifyFraction: () => simplifyFraction,
+  solveQuadratic: () => solveQuadratic,
+  toBase: () => toBase,
+  toOrdinal: () => toOrdinal,
+  truncateDecimals: () => truncateDecimals,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(advanced_exports);
+
+// src/lib/maths/fn/basic.ts
+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;
+};
+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;
+}
+
+// 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, min, max) => {
+  if (min === max) return 0;
+  return (value - min) / (max - min);
+};
+var wrap = (value, min, max) => {
+  const range2 = max - min;
+  return ((value - min) % range2 + range2) % range2 + min;
+};

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

@@ -1 +1,208 @@
-var c=(r,n=0,e="round")=>{if(e==="david")return f(r,n,e);if(!Number.isFinite(r))return r;if(n===0)return Math[e](r);if(n<0){let b=10**-n;return Math[e](r/b)*b}let t=10**n,o=Math.pow(2,-52),u=r*t,m=Math.sign(u)*o*Math.abs(u),i;switch(e){case"round":i=Math.round(u+m);break;case"ceil":i=Math.ceil(u-o);break;case"floor":i=Math.floor(u+o);break;case"trunc":i=u<0?Math.ceil(u):Math.floor(u);break;default:i=Math.round(u+m)}return i/t},f=(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,m=t*u,i=Math.pow(2,-53),b=Math.sign(m)*i*Math.abs(m);return m+=b,Math.round(m)/u*o};function a(r,n){for(r=Math.abs(r),n=Math.abs(n);n!==0;){let e=n;n=r%n,r=e}return r}function l(r){if(r<=0)throw new Error("Natural logarithm is only defined for positive numbers");return Math.log(r)}function g(r){if(r<=0)throw new Error("Logarithm is only defined for positive numbers");return Math.log10(r)}function x(r){if(r<=0)throw new Error("Logarithm is only defined for positive numbers");return Math.log2(r)}function M(r,n){if(r<=0||n<=0)throw new Error("Logarithm is only defined for positive numbers and bases");return Math.log(r)/Math.log(n)}function w(r){return Math.exp(r)}function y(r){return Math.cbrt(r)}function F(r,n){if(n===0)throw new Error("Cannot calculate 0th root");if(r<0&&n%2===0)throw new Error("Cannot calculate even root of negative number");let e=1/n;return Math.sign(r)*Math.pow(Math.abs(r),e)}function N(r,n,e){if(r===0)return n===0?[]:[-e/n];let t=n*n-4*r*e;if(t<0)return[];if(t===0)return[-n/(2*r)];{let o=Math.sqrt(t);return[(-n-o)/(2*r),(-n+o)/(2*r)]}}function E(r,n){let e=0;for(let t=0;t<r.length;t++)e=e*n+r[t];return e}function s(r){let n=a(r.numerator,r.denominator);return{numerator:r.numerator/n,denominator:r.denominator/n}}function T(r,n){let e=r.numerator*n.denominator+n.numerator*r.denominator,t=r.denominator*n.denominator;return s({numerator:e,denominator:t})}function S(r,n){let e=r.numerator*n.numerator,t=r.denominator*n.denominator;return s({numerator:e,denominator:t})}var A=(r,n,e=2)=>{if(n===0)return 0;let t=r/n*100;return c(t,e)},q=(r,n,e=1)=>{if(n<2||n>36)throw new Error("Base must be between 2 and 36");return r.toString(n).padStart(e,"0")},R=r=>{let n=["th","st","nd","rd"],e=r%100;return r+(n[(e-20)%10]||n[e]||n[0])},L=(r,n,e=1)=>{let t=[];if(e===0)return t;if(e>0)for(let o=r;o<n;o+=e)t.push(o);else for(let o=r;o>n;o+=e)t.push(o);return t},j=(r,n)=>{if(!Number.isFinite(r))return r;let e=10**n;return Math.trunc(r*e)/e},k=(r,n,e)=>n===e?0:(r-n)/(e-n),C=(r,n,e)=>{let t=e-n;return((r-n)%t+t)%t+n};export{T as addFractions,y as cbrt,E as evaluatePolynomial,w as exp,l as ln,M as log,g as log10,x as log2,S as multiplyFractions,k as normalize,F as nthRoot,A as percentage,L as range,s as simplifyFraction,N as solveQuadratic,q as toBase,R as toOrdinal,j as truncateDecimals,C as wrap};
+// src/lib/maths/fn/basic.ts
+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;
+};
+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;
+}
+
+// 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, min, max) => {
+  if (min === max) return 0;
+  return (value - min) / (max - min);
+};
+var wrap = (value, min, max) => {
+  const range2 = max - min;
+  return ((value - min) % range2 + range2) % range2 + min;
+};
+export {
+  addFractions,
+  cbrt,
+  evaluatePolynomial,
+  exp,
+  ln,
+  log,
+  log10,
+  log2,
+  multiplyFractions,
+  normalize,
+  nthRoot,
+  percentage,
+  range,
+  simplifyFraction,
+  solveQuadratic,
+  toBase,
+  toOrdinal,
+  truncateDecimals,
+  wrap
+};