ziko 0.54.4 → 0.55.0

package/dist/ziko.mjs

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Fri Dec 12 2025 14:53:26 GMT+0100 (UTC+01:00)
+  Date : Sat Dec 13 2025 01:41:10 GMT+0100 (UTC+01:00)
   Git-Repo : https://github.com/zakarialaoui10/ziko.js
   Git-Wiki : https://github.com/zakarialaoui10/ziko.js/wiki
   Released under MIT License
@@ -46,8 +46,280 @@ const apply_fun = (x, fn) => {
     return fn(x)
 };
 
-// import {sum,prod,deg2rad} from "../utils/index.js";
-// Should avoid CD
+const base2base = (value, fromBase, toBase) => {
+
+    const dec = parseInt(value, fromBase);
+    if (Number.isNaN(dec)) throw new TypeError('Invalid value for the given base');
+
+    return dec.toString(toBase);
+};
+
+const _add = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x + y;
+        if(y.isComplex?.()) {
+            return y.clone().add(x);
+        }
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return x.clone().add(y);
+    }
+};
+
+const _sub = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x - y;
+        if(y.isComplex?.()) return new y.constructor(x - y.a, y.b);
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return x.clone().sub(y);
+    }
+};
+
+const _mul = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x * y;
+        if(y.isComplex?.()) return y.clone().mul(x);
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return x.clone().mul(y);
+    }
+};
+
+const _div = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x / y;
+        if(y.isComplex?.()) return new y.constructor(x, 0).div(y)
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return x.clone().mul(y);
+    }
+};
+
+const _modulo = (x, y) =>{
+    if(typeof x === 'number'){
+        if(typeof y === 'number') return x % y;
+        if(y.isComplex?.()) return new y.constructor(x, 0).modulo(y)
+    }
+    if(x.isComplex?.()){
+        if(typeof y === 'number' || y.isComplex?.()) return x.clone().modulo(y);
+    }
+};
+
+const add=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _add(res, b[i]);
+    return res;
+};
+const sub=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _sub(res, b[i]);
+    return res;
+};
+const mul=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _mul(res, b[i]);
+    return res;
+};
+const div=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _div(res, b[i]);
+    return res;
+};
+const modulo=(a,...b)=>{
+    let res = a;
+    for(let i=0; i<b.length; i++)
+        res = _modulo(res, b[i]);
+    return res;
+};
+
+const min$1 = (...x) => Math.min(...x);
+const max$1 = (...x) => Math.max(...x);
+
+const binomial = (n, k) =>{
+  if(n !== Math.floor(n)) return TypeError('n must be an integer');
+  if(k !== Math.floor(k)) return TypeError('k must be an integer');
+  if (n < 0) return TypeError('n must be non-negative');
+  if (k < 0 || n < 0 || k > n) return 0;
+  if (k > n - k) k = n - k;
+    let c = 1, i;
+    for (i = 0; i < k; i++)
+        c = c * (n - i) / (i + 1);
+    return c;
+};
+
+const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
+
+const variance = (...x) => {
+  const n = x.length;
+  if (n === 0) return NaN;
+  const x_mean = mean(...x);
+  return x.reduce((sum, xi) => sum + (xi - x_mean) ** 2, 0) / n;
+};
+
+const std = (...x) => Math.sqrt(variance(...x));
+
+const accum_sum = (...x) => {
+  let result = [];
+  let total = 0, i, n = x.length;
+  for(i = 0; i < n ; i++){
+    total = add(total, x[i]);
+    result.push(total);
+  }
+  return result;
+};
+
+const accum_prod = (...x) => {
+  let result = [];
+  let prod = 1, i, n = x.length;
+  for(i = 0; i < n ; i++){
+    prod = mul(prod, x[i]);
+    result.push(prod);
+  }
+  return result;
+};
+
+const percentile = (X, p) => {
+  if (X.length === 0) 
+    return NaN;
+  let a = [...X].sort((x, y) => x - y);
+  let index = (p / 100) * (a.length - 1);
+  let i = Math.floor(index);
+  let f = index - i;
+  if (i === a.length - 1) 
+    return a[i]; 
+  return a[i] * (1 - f) + a[i + 1] * f;
+};
+
+const median = X => percentile(X, 50);
+
+class Random {
+    static int(a, b){
+        return Math.floor(this.float(a, b));
+    }
+    static float(a, b){
+        return b !== undefined
+            ? Math.random() * (b - a) + a
+            : Math.random() * a;
+    }
+    static bin(){
+        return this.int(2);
+    }
+    static oct(){
+        return this.int(8);
+    }
+    static dec(){
+        return this.int(10);
+    }
+    static hex(){
+        return base2base(this.int(16), 10, 16);
+    }
+    static char(upperCase = false){
+        const i = upperCase
+            ? this.int(65, 91)
+            : this.int(97, 123);
+        return String.fromCharCode(i);
+    }
+    static bool(){
+        return Boolean(this.int(2));
+    }
+    static get color(){
+        return {
+            hex : () =>
+                `#${this.int(0xffffff).toString(16).padStart(6, '0')}`,
+
+            hexa : () => {
+                const [r,g,b,a] = Array.from(
+                    {length:4},
+                    () => this.int(0xff).toString(16).padStart(2,'0')
+                );
+                return `#${r}${g}${b}${a}`;
+            },
+            rgb : () => {
+                const [r,g,b] = Array.from({length:3}, () => this.int(0xff));
+                return `rgb(${r}, ${g}, ${b})`;
+            },
+            rgba : () => {
+                const [r,g,b] = Array.from({length:3}, () => this.int(0xff));
+                const a = Math.random().toFixed(2);
+                return `rgba(${r}, ${g}, ${b}, ${a})`;
+            },
+            hsl : () => {
+                const h = this.int(360);
+                const s = this.int(100);
+                const l = this.int(100);
+                return `hsl(${h}, ${s}%, ${l}%)`;
+            },
+            hsla : () => {
+                const h = this.int(360);
+                const s = this.int(100);
+                const l = this.int(100);
+                const a = Math.random().toFixed(2);
+                return `hsla(${h}, ${s}%, ${l}%, ${a})`;
+            },
+            gray : () => {
+                const g = this.int(0xff);
+                return `rgb(${g}, ${g}, ${g})`;
+            }
+        };
+    }
+    static get sample(){
+        const R = this;
+        return {
+            int   : (n,a,b) => Array.from({length:n}, () => R.int(a,b)),
+            float : (n,a,b) => Array.from({length:n}, () => R.float(a,b)),
+            char  : (n,upper=false) => Array.from({length:n}, () => R.char(upper)),
+            bool  : n => Array.from({length:n}, () => R.bool()),
+            bin   : n => Array.from({length:n}, () => R.bin()),
+            oct   : n => Array.from({length:n}, () => R.oct()),
+            dec   : n => Array.from({length:n}, () => R.dec()),
+            hex   : n => Array.from({length:n}, () => R.hex()),
+            get color(){
+                return {
+                    hex  : n => Array.from({length:n}, () => R.color.hex()),
+                    hexa : n => Array.from({length:n}, () => R.color.hexa()),
+                    rgb  : n => Array.from({length:n}, () => R.color.rgb()),
+                    rgba : n => Array.from({length:n}, () => R.color.rgba()),
+                    hsl  : n => Array.from({length:n}, () => R.color.hsl()),
+                    hsla : n => Array.from({length:n}, () => R.color.hsla()),
+                    gray : n => Array.from({length:n}, () => R.color.gray())
+                };
+            },
+            choice : (n, choices, p) =>
+                Array.from({length:n}, () => R.choice(choices, p))
+        };
+    }
+    static shuffle(arr){
+        return [...arr].sort(() => 0.5 - Math.random());
+    }
+    static choice(choices = [1,2,3], p = new Array(choices.length).fill(1 / choices.length)){
+        const acc = accum_sum(...p).map(v => v * 100);
+        const pool = new Array(100);
+        pool.fill(choices[0], 0, acc[0]);
+        for(let i=1;i<choices.length;i++)
+            pool.fill(choices[i], acc[i-1], acc[i]);
+        return pool[this.int(pool.length)];
+    }
+}
+
+
+globalThis.Random = Random;
+
+// // (upperCase) => upperCase ? : String.fromCharCode(rand_int(97,120))
+// class Random {
+//     static string(length,upperCase){
+//         return length instanceof Array?
+//             new Array(this.int(...length)).fill(0).map(() => this.char(upperCase)).join(""):
+//             new Array(length).fill(0).map(() => this.char(upperCase)).join("");
+//     }
+
+// }
+// export{Random}
+
 class Complex{
     constructor(a = 0, b = 0) {
         if(a instanceof Complex){
@@ -125,7 +397,13 @@ class Complex{
     static Zero() {
         return new Complex(0, 0);
     }
-    static Twidlle(N, K){
+    static get Random(){
+        return {
+            int : (a, b)=> new Complex(...Random.sample.int(2, a, b) ),
+            float : (a, b)=> new Complex(...Random.sample.float(2, a, b) ),
+        }
+    }
+    static Twiddle(N, K){
         const phi = -2 * Math.PI * K / N;
         return new Complex(
             Math.cos(phi), 
@@ -625,89 +903,6 @@ const sig = (...x) => mapfun(
     ...x
 );
 
-const _add = (x, y) =>{
-    if(typeof x === 'number'){
-        if(typeof y === 'number') return x + y;
-        if(y.isComplex?.()) {
-            return y.clone().add(x);
-        }
-    }
-    if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return x.clone().add(y);
-    }
-};
-
-const _sub = (x, y) =>{
-    if(typeof x === 'number'){
-        if(typeof y === 'number') return x - y;
-        if(y.isComplex?.()) return new y.constructor(x - y.a, y.b);
-    }
-    if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return x.clone().sub(y);
-    }
-};
-
-const _mul = (x, y) =>{
-    if(typeof x === 'number'){
-        if(typeof y === 'number') return x * y;
-        if(y.isComplex?.()) return y.clone().mul(x);
-    }
-    if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return x.clone().mul(y);
-    }
-};
-
-const _div = (x, y) =>{
-    if(typeof x === 'number'){
-        if(typeof y === 'number') return x / y;
-        if(y.isComplex?.()) return new y.constructor(x, 0).div(y)
-    }
-    if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return x.clone().mul(y);
-    }
-};
-
-const _modulo = (x, y) =>{
-    if(typeof x === 'number'){
-        if(typeof y === 'number') return x % y;
-        if(y.isComplex?.()) return new y.constructor(x, 0).modulo(y)
-    }
-    if(x.isComplex?.()){
-        if(typeof y === 'number' || y.isComplex?.()) return x.clone().modulo(y);
-    }
-};
-
-const add=(a,...b)=>{
-    let res = a;
-    for(let i=0; i<b.length; i++)
-        res = _add(res, b[i]);
-    return res;
-};
-const sub=(a,...b)=>{
-    let res = a;
-    for(let i=0; i<b.length; i++)
-        res = _sub(res, b[i]);
-    return res;
-};
-const mul=(a,...b)=>{
-    let res = a;
-    for(let i=0; i<b.length; i++)
-        res = _mul(res, b[i]);
-    return res;
-};
-const div=(a,...b)=>{
-    let res = a;
-    for(let i=0; i<b.length; i++)
-        res = _div(res, b[i]);
-    return res;
-};
-const modulo=(a,...b)=>{
-    let res = a;
-    for(let i=0; i<b.length; i++)
-        res = _modulo(res, b[i]);
-    return res;
-};
-
 const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
 const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
 
@@ -728,64 +923,6 @@ const map$1 = (x, a, b, c, d) => apply_fun(
     v => lerp(norm(v, a, b), c, d)
 );
 
-
-// export const norm = (x, min, max) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         norm(x.a, min, max),
-//         norm(x.b, min, max)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         norm(x.arr.flat(1), min, max)
-//     );
-//     if(x instanceof Array) return mapfun(n => norm(n, min, max), ...x);
-//     return min !== max ? (x - min) / (max - min) : 0;
-// }
-
-
-// export const lerp = (x, min, max) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         lerp(x.a, min, max),
-//         lerp(x.b, min, max)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         lerp(x.arr.flat(1), min, max)
-//     );
-//     if(x instanceof Array) return mapfun(n => lerp(n, min, max), ...x);
-//     return (max - min) * x + min;
-// }
-
-// export const map = (x, a, b, c, d) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         map(x.a, a, b, c, d),
-//         map(x.b, a, b, c, d)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         map(x.arr.flat(1), a, b, c, d)
-//     );
-//     if(x instanceof Array) return mapfun(n => map(n, a, b, c, d), ...x);
-//     return lerp(norm(x, a, b), c, d);
-// }
-
-// export const clamp = (x, min, max) => {
-//     if(x.isComplex?.()) return new x.constructor(
-//         clamp(x.a, min, max),
-//         clamp(x.b, min, max)
-//     )
-//     if(x.isMatrix?.()) return new x.constructor(
-//         x.rows, 
-//         x.cols, 
-//         clamp(x.arr.flat(1), min, max)
-//     );
-//     if(x instanceof Array) return mapfun(n => clamp(n, min, max), ...x);
-//     return Math.min(Math.max(x, min), max)
-// }
-
 const hypot = (...x) => {
   const c0 = x.find(a => a.isComplex?.());
   if (c0) {
@@ -810,53 +947,59 @@ const atan2 = (y, x, rad = true) => {
     return rad ? phi : phi * 180 / Math.PI;
 };
 
-const min$1 = (...x) => Math.min(...x);
-const max$1 = (...x) => Math.max(...x);
+const not = x => {
+    if(x.isComplex?.()) return new x.constructor(not(x.a), not(x.b))
+    if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, x.arr.flat(1).map(not))
+    return + !x;
+};
+const handle_complex_and_matrix = (x, operation) => {
+    if (x.every(n => n.isComplex?.())) {
+        const Re = x.map(n => n.a);
+        const Im = x.map(n => n.b);
+        return new x[0].constructor(
+            operation(...Re),
+            operation(...Im)
+        );
+    }
 
-const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
+    if (x.every(n => n.isMatrix?.())) {
+        if (!x.every(mat => mat.rows === x[0].rows && mat.cols === x[0].cols)) {
+            return TypeError('All matrices must have the same shape');
+        }
 
-const variance = (...x) => {
-  const n = x.length;
-  if (n === 0) return NaN;
-  const x_mean = mean(...x);
-  return x.reduce((sum, xi) => sum + (xi - x_mean) ** 2, 0) / n;
-};
+        const { rows, cols } = x[0];
+        const Y = Array.from({ length: rows }, (_, i) =>
+            Array.from({ length: cols }, (_, j) =>
+                operation(...x.map(mat => mat.arr[i][j]))
+            )
+        );
+        return new x[0].constructor(Y);
+    }
 
-const std = (...x) => Math.sqrt(variance(...x));
+    return null;  // Return null if no Complex or Matrix found
+};
 
-const accum_sum = (...x) => {
-  let result = [];
-  let total = 0, i; n = x.length;
-  for(i = 0; i < n ; i++){
-    total = add(total, x[i]);
-    result.push(total);
-  }
-  return result;
+const and = (...x) => {
+    const result = handle_complex_and_matrix(x, and);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n &= m), 1);
 };
 
-const accum_prod = (...x) => {
-  let result = [];
-  let prod = 1, i; n = x.length;
-  for(i = 0; i < n ; i++){
-    prod = mul(prod, x[i]);
-    result.push(prod);
-  }
-  return result;
+const or = (...x) => {
+    const result = handle_complex_and_matrix(x, or);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n |= m), 0);
 };
 
-const percentile = (X, p) => {
-  if (X.length === 0) 
-    return NaN;
-  let a = [...X].sort((x, y) => x - y);
-  let index = (p / 100) * (a.length - 1);
-  let i = Math.floor(index);
-  let f = index - i;
-  if (i === a.length - 1) 
-    return a[i]; 
-  return a[i] * (1 - f) + a[i + 1] * f;
+const xor = (...x) => {
+    const result = handle_complex_and_matrix(x, xor);
+    if (result !== null) return result;
+    return x.reduce((n, m) => (n ^= m), 0);
 };
 
-const median = X => percentile(X, 50);
+const nand = (...x) => not(and(...x));
+const nor = (...x) => not(or(...x));
+const xnor = (...x) => not(xor(...x));
 
 const preload=(url)=>{
     const xhr = new XMLHttpRequest();
@@ -3460,6 +3603,7 @@ class Matrix{
     get inv() {
         return matrix_inverse(this)
     }
+    // normalize names
     static eye(size) {
         let result = new Matrix(size, size);
         for (let i = 0; i < size; i++) 
@@ -3484,6 +3628,20 @@ class Matrix{
             for (let j = 0; j < cols; j++) result.arr[i][j] = number;
         return result;
     }
+    static get Random(){
+        return {
+            int : (r, c, a, b)=> new Matrix(
+                r,
+                c,
+                Random.sample.int(r*c, a, b)
+            ),
+            float : (r, c, a,)=> new Matrix(
+                r,
+                c,
+                Random.sample.float(r*c, a, b)
+            ),
+        }
+    }
     hstack(...matrices) {
         const M=[this, ...matrices].reduce((a,b)=>hstack(a, b));
         Object.assign(this, M);
@@ -3938,21 +4096,6 @@ const matrix2=(...element)=>new Matrix(2, 2, element);
 const matrix3=(...element)=>new Matrix(3, 3, element);
 const matrix4=(...element)=>new Matrix(4, 4, element);
 
-const powerSet=originalSet=>{
-    const subSets = [];
-    const NUMBER_OF_COMBINATIONS = 2 ** originalSet.length;
-    for (let i = 0; i < NUMBER_OF_COMBINATIONS; i += 1) {
-        const subSet = [];
-        for (let j = 0; j < originalSet.length; j += 1) {
-            if (i & (1 << j)) {
-                subSet.push(originalSet[j]);
-            }
-        }
-        subSets.push(subSet);
-    }
-    return subSets;
-};
-
 const zeros=(n)=>new Array(n).fill(0);
 const ones=(n)=>new Array(n).fill(1);
 const nums=(num,n)=>new Array(n).fill(num);
@@ -4021,97 +4164,6 @@ const geomspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
     }
 };
 
-// Mixed calcul
-const sum=(...x)=>{
-    if(x.every(n=>typeof n==="number")){
-        let s = x[0];
-        for (let i = 1; i < x.length; i++) s += x[i];
-        return s;
-    }
-    const Y=[];
-    for(let i=0;i<x.length;i++){
-        if(x[i] instanceof Array)Y.push(sum(...x[i]));
-        else if(x[i] instanceof Object){
-            Y.push(sum(...Object.values(x[i])));
-        }
-    }
-    return Y.length===1?Y[0]:Y;
-};
-const prod=(...x)=>{
-    if(x.every(n=>typeof n==="number")){
-        let p = x[0];
-        for (let i = 1; i < x.length; i++) p *= x[i];
-        return p;
-    }
-    const Y=[];
-    for(let i=0;i<x.length;i++){
-        if(x[i] instanceof Array)Y.push(prod(...x[i]));
-        else if(x[i] instanceof Object){
-            Y.push(prod(...Object.values(x[i])));
-        }
-    }
-    return Y.length===1?Y[0]:Y;
-};
-// const min=(...num)=>{
-//     if(num.every(n=>typeof n==="number"))return Math.min(...num);
-//     const Y=[];
-//     for(let i=0;i<num.length;i++){
-//         if(num[i] instanceof Array)Y.push(min(...num[i]));
-//         else if(num[i] instanceof Object){
-//             Y.push(
-//                     Object.fromEntries(
-//                         [Object.entries(num[i]).sort((a,b)=>a[1]-b[1])[0]]
-//                     )
-//                 )
-//         }
-//     }
-//     return Y.length===1?Y[0]:Y;
-// }
-// const max=(...num)=>{
-//     if(num.every(n=>typeof n==="number"))return Math.max(...num);
-//     const Y=[];
-//     for(let i=0;i<num.length;i++){
-//         if(num[i] instanceof Array)Y.push(min(...num[i]));
-//         else if(num[i] instanceof Object){
-//             Y.push(
-//                     Object.fromEntries(
-//                         [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
-//                     )
-//                 )
-//         }
-//     }
-//     return Y.length===1?Y[0]:Y;
-// }
-const accum=(...num)=>{
-    if(num.every(n=>typeof n==="number")){
-        let acc = num.reduce((x, y) => [...x, x[x.length - 1] + y], [0]);
-        acc.shift();
-        return acc;
-    }
-    const Y=[];
-    for(let i=0;i<num.length;i++){
-        if(num[i] instanceof Array)Y.push(accum(...num[i]));
-        else if(num[i] instanceof Object){
-            Y.push(null
-                    // Object.fromEntries(
-                    //     [Object.entries(num[i]).sort((a,b)=>b[1]-a[1])[0]]
-                    // )
-                );
-        }
-    }
-    return Y.length===1?Y[0]:Y;
-};
-
-//moy
-//med
-//variance
-//std
-//mode
-//acccum
-//min2max
-//max2min
-//percentile
-
 /** @module Math */
 /**
  * Checks if a value is within the specified range.
@@ -4224,369 +4276,6 @@ const Utils={
     isApproximatlyEqual
 };
 
-// const subSet = (...arr) => {
-//     let list = arange(0, 2 ** arr.length, 1);
-//     let bin = list.map((n) => n.toString(2).padStart(arr.length, '0')).map((n) => n.split("").map((n) => +n));
-//     let sub = bin.map((n) => n.map((m, i) => (m === 1 ? arr[i] : null))).map((n) => n.filter((x) => x !== null));
-//     return sub;
-// };
-const subSet = null;
-
-const Base={
-    _mode:Number,
-    _map:function(func,number,toBase){
-        if (number instanceof Matrix)
-            return new Matrix(
-                number.rows,
-                number.cols,
-                number.arr.flat(1).map(n=>func(n,toBase))
-            );
-        else if (number instanceof Complex) return new Complex(func(number.a,toBase),func(number.b,toBase));
-        else if (number instanceof Array) return number.map((n) =>func(n,toBase));
-    },
-    dec2base(dec,base){
-        base<=10?this._mode=Number:this._mode=String;
-        //this._mode=String
-        if (typeof dec === "number") return this._mode((dec >>> 0).toString(base));
-          return this._map(this.dec2base,dec,base)
-    },
-    dec2bin(dec){
-        return this.dec2base(dec,2);
-    },
-    dec2oct(dec){
-        return this.dec2base(dec,8);
-    },
-    dec2hex(dec){
-        return this.dec2base(dec,16);
-    },
-    bin2base(bin, base) {
-        return this.dec2base(this.bin2dec(bin),base)
-    },
-    bin2dec(bin){
-        return this._mode("0b"+bin);
-    },
-    bin2oct(bin){
-        return this.bin2base(bin,8);
-    },
-    bin2hex(bin){
-        return this.bin2base(bin,16);
-    },
-    oct2dec(oct){
-        return this._mode("0o"+oct);
-    },
-    oct2bin(oct){
-        return this.dec2bin(this.oct2dec(oct))
-    },
-    oct2hex(oct){
-        return this.dec2hex(this.oct2dec(oct))
-    },
-    oct2base(oct, base) {
-        return this.dec2base(this.oct2dec(oct),base)
-    },
-    hex2dec(hex){
-        return this._mode("0x"+hex);
-    },
-    hex2bin(hex){
-        return this.dec2bin(this.hex2dec(hex))
-    },
-    hex2oct(hex){
-        return this.dec2oct(this.hex2dec(hex))
-    },
-    hex2base(hex, base) {
-        return this.dec2base(this.hex2dec(hex),base)
-    },
-    IEEE32toDec(Bin){
-        let IEEE32=Bin.split(" ").join("").padEnd(32,"0");
-        let s=IEEE32[0];
-        let e=2**(+("0b"+IEEE32.slice(1,9))-127);
-        let m=IEEE32.slice(9,32).split("").map(n=>+n);
-        let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
-        let dec=(-1)**s*(1+M)*e;
-        return dec
-    },
-    IEEE64toDec(Bin){
-        let IEEE64=Bin.split(" ").join("").padEnd(64,"0");
-        let s=IEEE64[0];
-        let e=2**(+("0b"+IEEE64.slice(1,12))-1023);
-        let m=IEEE64.slice(13,64).split("").map(n=>+n);
-        let M=m.map((n,i)=>n*(2**(-i-1))).reduce((a,b)=>a+b,0);
-        let dec=(-1)**s*(1+M)*e;
-        return dec;
-    }
-};
-
-const Logic$1={
-    _mode:Number,
-    _map:function(func,a,b){
-        if (a instanceof Matrix)
-            return new Matrix(
-                a.rows,
-                a.cols,
-                a.arr.flat(1).map((n) => func(n, b))
-            );
-        else if (a instanceof Complex) return new Complex(func(a.a, b), func(a.b, b));
-        else if (a instanceof Array) return a.map((n) => func(n, b));      
-    },
-    not:function(input){
-        if(["number","boolean"].includes(typeof input)) return Logic$1._mode(!input);
-        else return this._map(this.not,input)
-    },
-    and:function(a, ...b){
-        if(["number","boolean"].includes(typeof a))return Logic$1._mode(b.reduce((n, m) => (n &= m), a));
-        else return this._map(this.and,a,b)
-    },
-    or:function(a, ...b) {
-        if(["number","boolean"].includes(typeof a)) return Logic$1._mode(b.reduce((n, m) => (n |= m), a));
-        else return this._map(this.or,a,b);
-    },
-    nand:function(a, ...b) {
-        return this.not(this.and(a, b));
-    },
-    nor:function(a, ...b) {
-        return this.not(this.or(a, b));
-    },
-    xor:function(a,...b){
-        let arr=[a,...b];
-        if(["number","boolean"].includes(typeof a))return this._mode(arr.reduce((length,cur)=>{
-            if(+cur===1)length+=1;
-            return length;
-        },0)===1);
-        else return this._map(this.xor,a,b);
-    },
-    xnor:function(a,...b){
-        return Logic$1.not(Logic$1.xor(a,b))
-    }
-    
-};
-
-class Permutation {
-    static withDiscount(arr, l = arr.length) {
-        if (l === 1) return arr.map((n) => [n]);
-        const permutations = [];
-        let smallerPermutations;
-        smallerPermutations = this.withDiscount(arr, l - 1);
-        arr.forEach((currentOption) => {
-            smallerPermutations.forEach((smallerPermutation) => {
-                permutations.push([currentOption].concat(smallerPermutation));
-            });
-        });
-        return permutations;
-    }
-    static withoutDiscount(arr) {
-        const l = arr.length;
-        if (l === 1) return arr.map((n) => [n]);
-        const permutations = [];
-        const smallerPermutations = this.withoutDiscount(arr.slice(1));
-        const firstOption = arr[0];
-        for (let i = 0; i < smallerPermutations.length; i++) {
-            const smallerPermutation = smallerPermutations[i];
-            for (let j = 0; j <= smallerPermutation.length; j++) {
-                const permutationPrefix = smallerPermutation.slice(0, j);
-                const permutationSuffix = smallerPermutation.slice(j);
-                permutations.push(permutationPrefix.concat([firstOption], permutationSuffix));
-            }
-        }
-        return permutations;
-    }
-}
-
-class Combinaison {
-    static withDiscount(comboOptions, comboLength) {
-        if (comboLength === 1) {
-            return comboOptions.map((comboOption) => [comboOption]);
-        }
-        const combos = [];
-        comboOptions.forEach((currentOption, optionIndex) => {
-            const smallerCombos = this.withDiscount(comboOptions.slice(optionIndex), comboLength - 1);
-            smallerCombos.forEach((smallerCombo) => {
-                combos.push([currentOption].concat(smallerCombo));
-            });
-        });
-        return combos;
-    }
-    static withoutDiscount(comboOptions, comboLength) {
-        if (comboLength === 1) {
-            return comboOptions.map((comboOption) => [comboOption]);
-        }
-        const combos = [];
-        comboOptions.forEach((currentOption, optionIndex) => {
-            const smallerCombos = this.withoutDiscount(comboOptions.slice(optionIndex + 1), comboLength - 1);
-            smallerCombos.forEach((smallerCombo) => {
-                combos.push([currentOption].concat(smallerCombo));
-            });
-        });
-
-        return combos;
-    }
-}
-const combinaison=(comboOptions, comboLength, discount=false)=>Combinaison[discount?"withDiscount":"withoutDiscount"](comboOptions, comboLength);
-
-class Random {
-    static float(a = 1, b) {
-        return b ? Math.random() * (b - a) + a : a * Math.random();
-    }
-    static int(a, b) {
-        return Math.floor(this.float(a, b));
-    }
-    static char(upperCase){
-        upperCase=upperCase??this.bool();
-        const Char=String.fromCharCode(this.int(97,120));
-        return upperCase?Char.toUpperCase():Char;
-    }
-    static bool(){
-        return [false,true][Math.floor(Math.random()*2)];
-    }
-    static string(length,upperCase){
-        return length instanceof Array?
-            new Array(this.int(...length)).fill(0).map(() => this.char(upperCase)).join(""):
-            new Array(length).fill(0).map(() => this.char(upperCase)).join("");
-    }
-    static bin() {
-        return this.int(2);
-    }
-    static oct() {
-        return this.int(8);
-    }
-    static dec() {
-        return this.int(8);
-    }
-    static hex() {
-        return this.int(16);
-    }
-    static choice(choices = [1, 2, 3], p = new Array(choices.length).fill(1 / choices.length)) {
-        let newchoice = new Array(100);
-        p=Utils.accum(...p).map(n=>n*100);
-        newchoice.fill(choices[0], 0, p[0]);
-        for (let i = 1; i < choices.length; i++) newchoice.fill(choices[i], p[i - 1], p[i]);
-        return newchoice[this.int(newchoice.length - 1)];
-    }
-    static shuffleArr(arr){
-        return arr.sort(()=>0.5-Math.random())    
-    }
-    static floats(n, a, b) {
-        return new Array(n).fill(0).map(() => this.float(a, b));
-    }
-    static ints(n, a, b) {
-        return new Array(n).fill(0).map(() => this.int(a, b));
-    }
-    static bools(n){
-        return  new Array(n).fill(0).map(() => this.bool());
-    }
-    static bins(n) {
-        return new Array(n).fill(0).map(() => this.int(2));
-    }
-    static octs(n) {
-        return new Array(n).fill(0).map(() => this.int(8));
-    }
-    static decs(n) {
-        return new Array(n).fill(0).map(() => this.int(10));
-    }
-    static hexs(n) {
-        return new Array(n).fill(0).map(() => this.int(16));
-    }
-    static choices(n, choices, p) {
-        return new Array(n).fill(0).map(() => this.choice(choices, p));
-    }
-    static perm(...arr) {
-        // permutation
-        return arr.permS[this.int(arr.length)];
-    }
-    static color() {
-        return "#" + Base.dec2hex(this.float(16777216)).padStart(6,0);
-    }
-    static colors(n) {
-        return new Array(n).fill(null).map(()=>this.color());
-    }
-
-    // Should be Moved to Matrix and Complex to avoid Circular dependencies
-    // static complex(a = [0,1], b = [0,1]) {
-    //     return a instanceof Array?
-    //     new Complex(
-    //         this.float(a[0], a[1]),
-    //         this.float(b[0], b[1])
-    //     ):
-    //     new Complex(
-    //         ...this.floats(2,a,b)
-    //     )
-        
-    // }
-    // static complexInt(a = [0,1], b = [0,1]) {
-    //     return new Complex(
-    //         this.int(a[0], a[1]),
-    //         this.int(b[0], b[1])
-    //         );
-    // }
-    // static complexBin() {
-    //     return new Complex(...this.bins(2));
-    // }
-    // static complexOct() {
-    //     return new Complex(...this.octs(2));
-    // }
-    // static complexDec() {
-    //     return new Complex(...this.decs(10));
-    // }
-    // static complexHex() {
-    //     return new Complex(...this.octs(2));
-    // }
-    // static complexes(n, a = 0, b = 1) {
-    //     return new Array(n).fill(0).map(() => this.complex(a, b));
-    // }
-    // static complexesInt(n, a = 0, b = 1) {
-    //     return new Array(n).fill(0).map(() => this.complexInt(a, b));
-    // }
-    // static complexesBin(n) {
-    //     return new Array(n).fill(0).map(() => this.complexBin());
-    // }
-    // static complexesOct(n) {
-    //     return new Array(n).fill(0).map(() => this.complexOct());
-    // }
-    // static complexesDec(n) {
-    //     return new Array(n).fill(0).map(() => this.complexDec());
-    // }
-    // static complexesHex(n) {
-    //     return new Array(n).fill(0).map(() => this.complexHex());
-    // }
-    // static matrix(r,c,min,max){
-    //     return matrix(r,c,this.floats(r*c,min,max))
-    // }
-    // static matrixInt(r,c,min,max){
-    //     return matrix(r,c,this.ints(r*c,min,max))
-    // }
-    // static matrixBin(r,c){
-    //     return matrix(r,c,this.bins(r*c))
-    // }
-    // static matrixOct(r,c){
-    //     return matrix(r,c,this.octs(r*c))
-    // }
-    // static matrixDec(r,c){
-    //     return matrix(r,c,this.decs(r*c))
-    // }
-    // static matrixHex(r,c){
-    //     return matrix(r,c,this.hex(r*c))
-    // }
-    // static matrixColor(r,c){
-    //     return matrix(r,c,this.colors(r*c))
-    // }
-    // static matrixComplex(r,c,a,b){
-    //     return matrix(r,c,this.complexes(r*c,a,b))
-    // }
-    // static matrixComplexInt(r,c,a,b){
-    //     return matrix(r,c,this.complexesInt(r*c,a,b))
-    // }
-    // static matrixComplexBin(r,c){
-    //     return matrix(r,c,this.complexesBin(r*c))
-    // }
-    // static matrixComplexOct(r,c){
-    //     return matrix(r,c,this.complexesBin(r*c))
-    // }
-    // static matrixComplexDec(r,c){
-    //     return matrix(r,c,this.complexesBin(r*c))
-    // }
-    // static matrixComplexHex(r,c){
-    //     return matrix(r,c,this.complexesBin(r*c))
-    // }
-}
-
 const { PI, sqrt: sqrt$1, cos: cos$2, sin: sin$2, acos, pow } = Math;
 
 const linear = t => t;
@@ -5743,4 +5432,4 @@ if(globalThis?.document){
     document?.addEventListener("DOMContentLoaded", __Ziko__.__Config__.init());
 }
 
-export { App, Base, Clock, Combinaison, Complex, E, EPSILON, FileBasedRouting, Flex, HTMLWrapper, Logic$1 as Logic, Matrix, PI$1 as PI, Permutation, Random, SPA, SVGWrapper, Scheduler, Suspense, Switch, Tick, TimeAnimation, TimeLoop, TimeScheduler, UIElement$1 as UIElement, UIHTMLWrapper, UINode, UISVGWrapper, UISwitch, UIView, UseRoot, UseThread, Utils, View, ZikoApp, ZikoEvent, ZikoSPA, ZikoUIFlex, ZikoUISuspense, ZikoUIText, abs, accum, accum_prod, accum_sum, acos$1 as acos, acosh, acot, add, animation, apply_fun, arange, arc, arr2str, asin, asinh, atan, atan2, atanh, back, bind_click_event, bind_clipboard_event, bind_drag_event, bind_focus_event, bind_key_event, bind_mouse_event, bind_pointer_event, bind_swipe_event, bind_touch_event, bind_view_event, bind_wheel_event, cartesianProduct, cbrt, ceil, clamp, clock, combinaison, complex, cos$3 as cos, cosh$2 as cosh, coth, croot, csv2arr, csv2json, csv2matrix, csv2object, csv2sql, debounce, defineParamsGetter, define_wc, deg2rad, discret, div, elastic, event_controller, exp$1 as exp, floor, fract, geomspace, getEvent, hypot, inRange, in_back, in_bounce, in_circ, in_cubic, in_elastic, in_expo, in_out_back, in_out_bounce, in_out_circ, in_out_cubic, in_out_elastic, in_out_expo, in_out_quad, in_out_quart, in_out_quint, in_out_sin, in_quad, in_quart, in_quint, in_sin, isApproximatlyEqual, isStateGetter, json2arr, json2css, json2csv, json2csvFile, json2xml, json2xmlFile, json2yml, json2ymlFile, lerp, linear, linspace, ln, logspace, loop, map$1 as map, mapfun, matrix, matrix2, matrix3, matrix4, max$1 as max, mean, median, min$1 as min, modulo, mul, norm, nthr, nums, obj2str, ones, out_back, out_bounce, out_circ, out_cubic, out_elastic, out_expo, out_quad, out_quart, out_quint, out_sin, percentile, pgcd, pow$1 as pow, powerSet, ppcm, preload, prod, rad2deg, round, sec, sig, sign, sin$3 as sin, sinh$1 as sinh, sleep, sqrt$2 as sqrt, std, step, step_fps, sub, subSet, sum, svg2ascii, svg2img, svg2imgUrl, svg2str, tags, tan, tanh, text, throttle, tick, timeTaken, time_memory_Taken, timeout, toggle_event_listener, trunc, useDerived, useEventEmitter, useIPC, useLocaleStorage, useMediaQuery, useReactive, useRoot, useSessionStorage, useState, useThread, useTitle, variance, wait, waitForUIElm, waitForUIElmSync, zeros };
+export { App, Clock, Complex, E, EPSILON, FileBasedRouting, Flex, HTMLWrapper, Matrix, PI$1 as PI, Random, SPA, SVGWrapper, Scheduler, Suspense, Switch, Tick, TimeAnimation, TimeLoop, TimeScheduler, UIElement$1 as UIElement, UIHTMLWrapper, UINode, UISVGWrapper, UISwitch, UIView, UseRoot, UseThread, Utils, View, ZikoApp, ZikoEvent, ZikoSPA, ZikoUIFlex, ZikoUISuspense, ZikoUIText, abs, accum_prod, accum_sum, acos$1 as acos, acosh, acot, add, and, animation, apply_fun, arange, arc, arr2str, asin, asinh, atan, atan2, atanh, back, bind_click_event, bind_clipboard_event, bind_drag_event, bind_focus_event, bind_key_event, bind_mouse_event, bind_pointer_event, bind_swipe_event, bind_touch_event, bind_view_event, bind_wheel_event, binomial, cartesianProduct, cbrt, ceil, clamp, clock, complex, cos$3 as cos, cosh$2 as cosh, coth, croot, csv2arr, csv2json, csv2matrix, csv2object, csv2sql, debounce, defineParamsGetter, define_wc, deg2rad, discret, div, elastic, event_controller, exp$1 as exp, floor, fract, geomspace, getEvent, hypot, inRange, in_back, in_bounce, in_circ, in_cubic, in_elastic, in_expo, in_out_back, in_out_bounce, in_out_circ, in_out_cubic, in_out_elastic, in_out_expo, in_out_quad, in_out_quart, in_out_quint, in_out_sin, in_quad, in_quart, in_quint, in_sin, isApproximatlyEqual, isStateGetter, json2arr, json2css, json2csv, json2csvFile, json2xml, json2xmlFile, json2yml, json2ymlFile, lerp, linear, linspace, ln, logspace, loop, map$1 as map, mapfun, matrix, matrix2, matrix3, matrix4, max$1 as max, mean, median, min$1 as min, modulo, mul, nand, nor, norm, nthr, nums, obj2str, ones, or, out_back, out_bounce, out_circ, out_cubic, out_elastic, out_expo, out_quad, out_quart, out_quint, out_sin, percentile, pgcd, pow$1 as pow, ppcm, preload, rad2deg, round, sec, sig, sign, sin$3 as sin, sinh$1 as sinh, sleep, sqrt$2 as sqrt, std, step, step_fps, sub, svg2ascii, svg2img, svg2imgUrl, svg2str, tags, tan, tanh, text, throttle, tick, timeTaken, time_memory_Taken, timeout, toggle_event_listener, trunc, useDerived, useEventEmitter, useIPC, useLocaleStorage, useMediaQuery, useReactive, useRoot, useSessionStorage, useState, useThread, useTitle, variance, wait, waitForUIElm, waitForUIElmSync, xnor, xor, zeros };