ziko 0.54.4 → 0.55.0

package/dist/ziko.js

@@ -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
@@ -52,8 +52,280 @@
        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){
@@ -131,7 +403,13 @@
        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), 
@@ -631,89 +909,6 @@
        ...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);
 
@@ -734,64 +929,6 @@
        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) {
@@ -816,53 +953,59 @@
        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();
@@ -3466,6 +3609,7 @@
        get inv() {
            return matrix_inverse(this)
        }
+       // normalize names
        static eye(size) {
            let result = new Matrix(size, size);
            for (let i = 0; i < size; i++) 
@@ -3490,6 +3634,20 @@
                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);
@@ -3944,21 +4102,6 @@
    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);
@@ -4027,97 +4170,6 @@
        }
    };
 
-   // 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.
@@ -4230,369 +4282,6 @@
        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;
@@ -5750,19 +5439,15 @@
    }
 
    exports.App = App;
-   exports.Base = Base;
    exports.Clock = Clock;
-   exports.Combinaison = Combinaison;
    exports.Complex = Complex;
    exports.E = E;
    exports.EPSILON = EPSILON;
    exports.FileBasedRouting = FileBasedRouting;
    exports.Flex = Flex;
    exports.HTMLWrapper = HTMLWrapper;
-   exports.Logic = Logic$1;
    exports.Matrix = Matrix;
    exports.PI = PI$1;
-   exports.Permutation = Permutation;
    exports.Random = Random;
    exports.SPA = SPA;
    exports.SVGWrapper = SVGWrapper;
@@ -5790,13 +5475,13 @@
    exports.ZikoUISuspense = ZikoUISuspense;
    exports.ZikoUIText = ZikoUIText;
    exports.abs = abs;
-   exports.accum = accum;
    exports.accum_prod = accum_prod;
    exports.accum_sum = accum_sum;
    exports.acos = acos$1;
    exports.acosh = acosh;
    exports.acot = acot;
    exports.add = add;
+   exports.and = and;
    exports.animation = animation;
    exports.apply_fun = apply_fun;
    exports.arange = arange;
@@ -5819,12 +5504,12 @@
    exports.bind_touch_event = bind_touch_event;
    exports.bind_view_event = bind_view_event;
    exports.bind_wheel_event = bind_wheel_event;
+   exports.binomial = binomial;
    exports.cartesianProduct = cartesianProduct;
    exports.cbrt = cbrt;
    exports.ceil = ceil;
    exports.clamp = clamp;
    exports.clock = clock;
-   exports.combinaison = combinaison;
    exports.complex = complex;
    exports.cos = cos$3;
    exports.cosh = cosh$2;
@@ -5898,11 +5583,14 @@
    exports.min = min$1;
    exports.modulo = modulo;
    exports.mul = mul;
+   exports.nand = nand;
+   exports.nor = nor;
    exports.norm = norm;
    exports.nthr = nthr;
    exports.nums = nums;
    exports.obj2str = obj2str;
    exports.ones = ones;
+   exports.or = or;
    exports.out_back = out_back;
    exports.out_bounce = out_bounce;
    exports.out_circ = out_circ;
@@ -5916,10 +5604,8 @@
    exports.percentile = percentile;
    exports.pgcd = pgcd;
    exports.pow = pow$1;
-   exports.powerSet = powerSet;
    exports.ppcm = ppcm;
    exports.preload = preload;
-   exports.prod = prod;
    exports.rad2deg = rad2deg;
    exports.round = round;
    exports.sec = sec;
@@ -5933,8 +5619,6 @@
    exports.step = step;
    exports.step_fps = step_fps;
    exports.sub = sub;
-   exports.subSet = subSet;
-   exports.sum = sum;
    exports.svg2ascii = svg2ascii;
    exports.svg2img = svg2img;
    exports.svg2imgUrl = svg2imgUrl;
@@ -5965,6 +5649,8 @@
    exports.wait = wait;
    exports.waitForUIElm = waitForUIElm;
    exports.waitForUIElmSync = waitForUIElmSync;
+   exports.xnor = xnor;
+   exports.xor = xor;
    exports.zeros = zeros;
 
 }));