ziko 0.51.1 → 0.53.0

package/dist/ziko.js

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Thu Dec 04 2025 12:08:41 GMT+0100 (UTC+01:00)
+  Date : Fri Dec 05 2025 17:08:57 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
@@ -17,75 +17,107 @@
     const { PI: PI$2, E } = Math;
     const EPSILON=Number.EPSILON;
 
-    const {PI: PI$1, cos: cos$3, sin: sin$3, tan: tan$1, acos: acos$2, asin: asin$1, atan: atan$1, cosh: cosh$2, sinh: sinh$2, tanh: tanh$1, acosh: acosh$1, asinh: asinh$1, atanh: atanh$1, log: log$1} = Math;
+    const {PI: PI$1, cos: cos$3, sin: sin$3, tan: tan$1, atan: atan$1, cosh: cosh$2, sinh: sinh$2, tanh: tanh$1, acosh: acosh$1, asinh: asinh$1, atanh: atanh$1, log: log$1} = Math;
     let Fixed={
-        cos: cos$3,
-        sin: sin$3,
-        tan: tan$1,
+        cos : x=> {
+            if(x.isComplex?.()) return new x.constructor(
+                cos$3(x.a)*cosh$2(x.b),
+                -(sin$3(x.a)*sinh$2(x.b))
+            );
+            return cos$3(x)
+        },
+        sin : x=>{
+            if(x?.isComplex) return new x.constructor(
+                sin$3(x.a)*cosh$2(x.b),
+                cos$3(x.a)*sinh$2(x.b)
+            );
+            return sin$3(x)
+        },
+        tan : x=>{
+            if(x?.isComplex){
+                const DEN = cos$3(2*x.a)+cosh$2(2*x.b);
+                return new x.constructor(
+                    sin$3(2*x.a)/DEN,
+                    sinh$2(2*x.b)/DEN
+                );
+            } 
+            return tan$1(x) 
+        },
         sinc: x => sin$3(PI$1*x)/(PI$1*x),
         sec: x => 1/cos$3(x),
         csc: x => 1/sin$3(x),
         cot: x => 1/tan$1(x),
-        acos: acos$2,
-        asin: asin$1,
-        atan: atan$1,
+        acos: x=>{
+            if(x?.isComplex) return 
+            return sin$3(x)
+        },
+        asin: x=>{
+            if(x?.isComplex) return 
+            return sin$3(x)
+        },
+        atan: x=>{
+            if(x?.isComplex) return 
+            return sin$3(x)
+        },
         acot: x => PI$1/2-atan$1(x),
-        cosh: cosh$2,
-        sinh: sinh$2,
-        tanh: tanh$1,
+        cosh: x=>{
+            if(x?.isComplex) return new x.constructor(
+                cosh$2(x.a)*cos$3(x.b),
+                sinh$2(x.a)*sin$3(x.b)
+            ); 
+            return cosh$2(x)
+        },
+        sinh: x=>{
+            if(x?.isComplex) return new x.constructor(
+                sinh$2(x.a)*cos$3(x.b),
+                cosh$2(x.a)*sin$3(x.b)
+            ); 
+            return sinh$2(x)
+        },
+        tanh: x=>{
+            if(x?.isComplex){
+                const DEN=cosh$2(2*a)+cos$3(2*b);
+                return new x.constructor(
+                    sinh$2(2*a)/DEN,
+                    sin$3(2*b)/DEN
+                )
+            } 
+            return tanh$1(x)
+        },
         coth: n => (1/2*log$1((1+n)/(1-n))),
         acosh: acosh$1,
         asinh: asinh$1,
         atanh: atanh$1,
     };
 
-    Fixed = new Proxy(Fixed, {
-        get(target, prop) {
-            if(prop in target){
-                return x => + target[prop](x).toFixed(15);
-            }
-            return undefined;
-        }
-    });
+    // Fixed = new Proxy(Fixed, {
+    //     get(target, prop) {
+    //         if(prop in target){
+    //             return x => + target[prop](x).toFixed(15);
+    //         }
+    //         return undefined;
+    //     }
+    // })
+
+    const is_primitive = value => typeof value !== 'object' && typeof value !== 'function' || value === null;
 
-    // To generalise
     const mapfun$1=(fun,...X)=>{
         const Y=X.map(x=>{
-            if(x===null) return fun(null);
-            if(["number","string","boolean","bigint","undefined"].includes(typeof x)) return fun(x);
+            if(is_primitive(x) || x?.__mapfun__) return fun(x)
             if(x instanceof Array) return x.map(n=>mapfun$1(fun,n));
             if(ArrayBuffer.isView(x)) return x.map(n=>fun(n));
             if(x instanceof Set) return new Set(mapfun$1(fun,...[...x]));
             if(x instanceof Map) return new Map([...x].map(n=>[n[0],mapfun$1(fun,n[1])]));
             if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun$1(x.arr.flat(1)))
-            if(x.isComplex?.()){
-                const complex = (...args) => new x.constructor(...args); 
-                const [a,b,z,phi]=[x.a,x.b,x.z,x.phi];
-                switch(fun){
-                    case Math.log: return complex(ln(z),phi); // Done
-                    case Math.exp: return complex(e(a)*cos$2(b),e(a)*sin$2(b)); // Done
-                    case Math.abs: return z; // Done
-                    case Math.sqrt: return complex(sqrt$2(z)*cos$2(phi/2),sqrt$2(z)*sin$2(phi/2)); // Done
-                    case Fixed.cos: return complex(cos$2(a)*cosh$1(b),-(sin$2(a)*sinh$1(b)));
-                    case Fixed.sin: return complex(sin$2(a)*cosh$1(b),cos$2(a)*sinh$1(b));
-                    case Fixed.tan:{
-                        const DEN = cos$2(2*a)+cosh$1(2*b);
-                        return complex(sin$2(2*a)/DEN,sinh$1(2*b)/DEN);
-                    }
-                    case Fixed.cosh:return complex(cosh$1(a)*cos$2(b),sinh$1(a)*sin$2(b));
-                    case Fixed.sinh:return complex(sinh$1(a)*cos$2(b),cosh$1(a)*sin$2(b));
-                    case Fixed.tanh:{
-                        const DEN=cosh$1(2*a)+cos$2(2*b);
-                        return complex(sinh$1(2*a)/DEN,sin$2(2*b)/DEN)
-                    }
-                    default : return fun(x)
-                }
-            }
             else if(x instanceof Object){
-                return Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun$1(fun,n[1])]))
+                return Object.fromEntries(
+                    Object.entries(x).map(
+                        n=>n=[n[0],mapfun$1(fun,n[1])]
+                    )
+                )
             }
         });
-       return Y.length==1?Y[0]:Y; 
+       return Y.length==1? Y[0]: Y; 
     };
 
     // Mixed calcul
@@ -694,8 +726,8 @@
                     this.a=a.b/tan(a.phi);
                 }
                 else if(("z" in a && "phi" in a)){
-                    this.a=a.z*cos$2(a.phi);
-                    this.a=a.z*sin$2(a.phi);
+                    this.a = +a.z*cos$2(a.phi).toFixed(15);
+                    this.b = +a.z*sin$2(a.phi).toFixed(15);
                 }
             }
             else if(typeof(a)==="number"&&typeof(b)==="number"){
@@ -703,6 +735,9 @@
                 this.b = +b.toFixed(32);
             }
         }
+        get __mapfun__(){
+            return true
+        }
         isComplex(){
             return true
         }
@@ -995,6 +1030,35 @@
 
     // globalThis.node = (node) => new UINode(node);
 
+    function parseQueryParams$1(queryString) {
+        const params = {};
+        queryString.replace(/[A-Z0-9]+?=([\w|:|\/\.]*)/gi, (match) => {
+            const [key, value] = match.split('=');
+            params[key] = value;
+        });
+        return params;
+    }
+
+    function defineParamsGetter$1(target ){
+        Object.defineProperties(target, {
+            'QueryParams': {
+                get: function() {
+                    return parseQueryParams$1(globalThis.location.search.substring(1));
+                },
+                configurable: false,
+                enumerable: true 
+            },
+            'HashParams': {
+                get: function() {
+                    const hash = globalThis.location.hash.substring(1);
+                    return hash.split("#");
+                },
+                configurable: false,
+                enumerable: true 
+            }
+        });
+    }
+
     class UIStore extends Array {
         constructor(...args) {
             super(...args); 
@@ -1028,202 +1092,6 @@
     // create the singleton
     const __UI__ = new UIStore();
 
-    // __init__global__()
-    class UIElementCore extends UINode{
-      constructor(){
-        super();
-      }
-      init(element, name, type, render){
-        this.target = globalThis.__Ziko__.__Config__.default.target||globalThis?.document?.body;
-        if(typeof element === "string") {
-          switch(type){
-            case "html" : {
-              element = globalThis?.document?.createElement(element);
-              // console.log('1')
-            } break;
-            case "svg" : {
-              element = globalThis?.document?.createElementNS("http://www.w3.org/2000/svg", element); 
-              // console.log('2')
-            } break;
-            default : throw Error("Not supported")
-          }
-        }
-        else this.target = element?.parentElement;
-        Object.assign(this.cache, {
-          name,
-          isInteractive : false,
-          parent:null,
-          isBody:false,
-          isRoot:false,
-          isHidden: false,
-          isFrozzen:false,
-          legacyParent : null,
-          attributes: {},
-          filters: {},
-          temp:{}
-        });
-        this.events = {
-          ptr:null,
-          mouse:null,
-          wheel:null,
-          key:null,
-          drag:null,
-          drop:null,
-          click:null,
-          clipboard:null,
-          focus:null,
-          swipe:null,
-          custom:null,
-        };
-        this.observer={
-          resize:null,
-          intersection:null
-        };
-        if(element) Object.assign(this.cache,{element});
-        // useDefaultStyle && this.style({ 
-        //   position: "relative",
-        //   boxSizing:"border-box",
-        //   margin:0,
-        //   padding:0,
-        //   width : "auto",
-        //   height : "auto"
-        //  });
-        this.items = new UIStore();
-        globalThis.__Ziko__.__UI__[this.cache.name]?globalThis.__Ziko__.__UI__[this.cache.name]?.push(this):globalThis.__Ziko__.__UI__[this.cache.name]=[this];
-        element && render && this?.render?.();
-        globalThis.__Ziko__.__UI__.push(this);
-      }
-      get element(){
-        return this.cache.element;
-      }
-        [Symbol.iterator]() {
-        return this.items[Symbol.iterator]();
-      }
-      maintain() {
-        for (let i = 0; i < this.items.length; i++) {
-          Object.defineProperty(this, i, {
-            value: this.items[i],
-            writable: true,
-            configurable: true,
-            enumerable: false 
-            });
-        }
-      }
-      isInteractive(){
-        return this.cache.isInteractive;
-      }
-      isUIElement(){
-        return true;
-      }
-    }
-
-    function register_to_class(target, ...mixins){
-        mixins.forEach(n => _register_to_class_(target, n));
-    }
-    function _register_to_class_(target, mixin) {
-      const descriptors = Object.getOwnPropertyDescriptors(mixin);
-      for (const key of Reflect.ownKeys(descriptors)) {
-        const desc = descriptors[key];
-        if ('get' in desc || 'set' in desc || typeof desc.value !== 'function') {
-          Object.defineProperty(Object.getPrototypeOf(target), key, desc);
-        } else if (typeof desc.value === 'function') {
-          if (!Object.getPrototypeOf(target).hasOwnProperty(key)) {
-            Object.defineProperty(Object.getPrototypeOf(target), key, desc);
-          }
-        }
-      }
-    }
-
-    // export function mount(target = this.target) {
-    //   if(this.isBody) return ;
-    //   if(target?.isUIElement)target=target.element;
-    //   this.target=target;
-    //   this.target?.appendChild(this.element);
-    //   return this;
-    // }
-    // export function unmount(){
-    //   if(this.cache.parent)this.cache.parent.remove(this);
-    //   else if(this.target?.children?.length && [...this.target?.children].includes(this.element)) this.target.removeChild(this.element);
-    //   return this;
-    // }
-
-    // export function mountAfter(target = this.target, t = 1) {
-    //   setTimeout(() => this.mount(), t);
-    //   return this;
-    // }
-    // export function unmountAfter(t = 1) {
-    //   setTimeout(() => this.unmount(), t);
-    //   return this;
-    // }
-
-    function mount(target = this.target, delay = 0) {
-        if (delay > 0) {
-            setTimeout(() => this.mount(target, 0), delay);
-            return this;
-        }
-
-        if (this.isBody) return this;
-
-        if (target?.isUIElement) target = target.element;
-        this.target = target;
-
-        this.target?.appendChild(this.element);
-        return this;
-    }
-
-    function unmount(delay = 0) {
-        if (delay > 0) {
-            setTimeout(() => this.unmount(0), delay);
-            return this;
-        }
-
-        if (this.cache.parent) {
-            this.cache.parent.remove(this);
-        } else if (
-            this.target?.children?.length &&
-            [...this.target.children].includes(this.element)
-        ) {
-            this.target.removeChild(this.element);
-        }
-
-        return this;
-    }
-
-    var LifecycleMethods = /*#__PURE__*/Object.freeze({
-        __proto__: null,
-        mount: mount,
-        unmount: unmount
-    });
-
-    function parseQueryParams$1(queryString) {
-        const params = {};
-        queryString.replace(/[A-Z0-9]+?=([\w|:|\/\.]*)/gi, (match) => {
-            const [key, value] = match.split('=');
-            params[key] = value;
-        });
-        return params;
-    }
-
-    function defineParamsGetter$1(target ){
-        Object.defineProperties(target, {
-            'QueryParams': {
-                get: function() {
-                    return parseQueryParams$1(globalThis.location.search.substring(1));
-                },
-                configurable: false,
-                enumerable: true 
-            },
-            'HashParams': {
-                get: function() {
-                    const hash = globalThis.location.hash.substring(1);
-                    return hash.split("#");
-                },
-                configurable: false,
-                enumerable: true 
-            }
-        });
-    }
-
     const __Config__ = {
         default:{
             target:null,
@@ -1267,384 +1135,6 @@
         }
     };
 
-    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 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))
-        // }
-    }
-
     class UseIPC {
         #channel;
         #eventData;
@@ -1656,7 +1146,7 @@
             this.#channel = new BroadcastChannel(name);
             this.#eventData = new Map();
             this.#handlers = new Map(); // Map<event, Array<{fn, rooms}>>
-            this.#uuid = "ziko-channel:" + Random.string(10);
+            this.#uuid = "ziko-channel:" + (Math.random()*10e16);  // To Be Replaced by UUID
             this.#subscribers = new Set([this.#uuid]);
             this.#currentRooms = new Set(); 
             this.#channel.addEventListener("message", (e) => {
@@ -1840,21 +1330,188 @@
             } 
         },
 
-    };
-
-    function __init__global__(){
-        if ( !globalThis?.__Ziko__ ){
-            globalThis.__Ziko__ = {
-                        __UI__,
-                        __HYDRATION__,
-                        __State__,
-                        __Config__,
-                        __CACHE__,
-                    };
-            defineParamsGetter$1(__Ziko__);
+    };
+
+    function __init__global__(){
+        if ( !globalThis?.__Ziko__ ){
+            globalThis.__Ziko__ = {
+                        __UI__,
+                        __HYDRATION__,
+                        __State__,
+                        __Config__,
+                        __CACHE__,
+                    };
+            defineParamsGetter$1(__Ziko__);
+        }
+    }
+
+    __init__global__();
+    class UIElementCore extends UINode{
+      constructor(){
+        super();
+      }
+      init(element, name, type, render){
+        this.target = globalThis.__Ziko__.__Config__.default.target||globalThis?.document?.body;
+        if(typeof element === "string") {
+          switch(type){
+            case "html" : {
+              element = globalThis?.document?.createElement(element);
+              // console.log('1')
+            } break;
+            case "svg" : {
+              element = globalThis?.document?.createElementNS("http://www.w3.org/2000/svg", element); 
+              // console.log('2')
+            } break;
+            default : throw Error("Not supported")
+          }
+        }
+        else this.target = element?.parentElement;
+        Object.assign(this.cache, {
+          name,
+          isInteractive : false,
+          parent:null,
+          isBody:false,
+          isRoot:false,
+          isHidden: false,
+          isFrozzen:false,
+          legacyParent : null,
+          attributes: {},
+          filters: {},
+          temp:{}
+        });
+        this.events = {
+          ptr:null,
+          mouse:null,
+          wheel:null,
+          key:null,
+          drag:null,
+          drop:null,
+          click:null,
+          clipboard:null,
+          focus:null,
+          swipe:null,
+          custom:null,
+        };
+        this.observer={
+          resize:null,
+          intersection:null
+        };
+        if(element) Object.assign(this.cache,{element});
+        // useDefaultStyle && this.style({ 
+        //   position: "relative",
+        //   boxSizing:"border-box",
+        //   margin:0,
+        //   padding:0,
+        //   width : "auto",
+        //   height : "auto"
+        //  });
+        this.items = new UIStore();
+        globalThis.__Ziko__.__UI__[this.cache.name]?globalThis.__Ziko__.__UI__[this.cache.name]?.push(this):globalThis.__Ziko__.__UI__[this.cache.name]=[this];
+        element && render && this?.render?.();
+        globalThis.__Ziko__.__UI__.push(this);
+      }
+      get element(){
+        return this.cache.element;
+      }
+        [Symbol.iterator]() {
+        return this.items[Symbol.iterator]();
+      }
+      maintain() {
+        for (let i = 0; i < this.items.length; i++) {
+          Object.defineProperty(this, i, {
+            value: this.items[i],
+            writable: true,
+            configurable: true,
+            enumerable: false 
+            });
+        }
+      }
+      isInteractive(){
+        return this.cache.isInteractive;
+      }
+      isUIElement(){
+        return true;
+      }
+    }
+
+    function register_to_class(target, ...mixins){
+        mixins.forEach(n => _register_to_class_(target, n));
+    }
+    function _register_to_class_(target, mixin) {
+      const descriptors = Object.getOwnPropertyDescriptors(mixin);
+      for (const key of Reflect.ownKeys(descriptors)) {
+        const desc = descriptors[key];
+        if ('get' in desc || 'set' in desc || typeof desc.value !== 'function') {
+          Object.defineProperty(Object.getPrototypeOf(target), key, desc);
+        } else if (typeof desc.value === 'function') {
+          if (!Object.getPrototypeOf(target).hasOwnProperty(key)) {
+            Object.defineProperty(Object.getPrototypeOf(target), key, desc);
+          }
+        }
+      }
+    }
+
+    // export function mount(target = this.target) {
+    //   if(this.isBody) return ;
+    //   if(target?.isUIElement)target=target.element;
+    //   this.target=target;
+    //   this.target?.appendChild(this.element);
+    //   return this;
+    // }
+    // export function unmount(){
+    //   if(this.cache.parent)this.cache.parent.remove(this);
+    //   else if(this.target?.children?.length && [...this.target?.children].includes(this.element)) this.target.removeChild(this.element);
+    //   return this;
+    // }
+
+    // export function mountAfter(target = this.target, t = 1) {
+    //   setTimeout(() => this.mount(), t);
+    //   return this;
+    // }
+    // export function unmountAfter(t = 1) {
+    //   setTimeout(() => this.unmount(), t);
+    //   return this;
+    // }
+
+    function mount(target = this.target, delay = 0) {
+        if (delay > 0) {
+            setTimeout(() => this.mount(target, 0), delay);
+            return this;
+        }
+
+        if (this.isBody) return this;
+
+        if (target?.isUIElement) target = target.element;
+        this.target = target;
+
+        this.target?.appendChild(this.element);
+        return this;
+    }
+
+    function unmount(delay = 0) {
+        if (delay > 0) {
+            setTimeout(() => this.unmount(0), delay);
+            return this;
+        }
+
+        if (this.cache.parent) {
+            this.cache.parent.remove(this);
+        } else if (
+            this.target?.children?.length &&
+            [...this.target.children].includes(this.element)
+        ) {
+            this.target.removeChild(this.element);
         }
+
+        return this;
     }
 
+    var LifecycleMethods = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        mount: mount,
+        unmount: unmount
+    });
+
     if(!globalThis.__Ziko__) __init__global__();
 
     function useState(initialValue) {
@@ -2851,6 +2508,14 @@
         style: style
     });
 
+    // import { 
+    //   // useCustomEvent,
+    //   // useSwipeEvent,
+    //   // watchIntersection, 
+    //   // watchSize,
+    //   // watchAttr,
+    //   // watchChildren
+    // } from "../../--reactivity-deprecated/events/custom-event.js"
     let UIElement$1 = class UIElement extends UIElementCore{
       constructor({element, name ='', type='html', render = __Ziko__.__Config__.default.render}={}){
         super();
@@ -4077,213 +3742,591 @@
         filterByCols(item){
             return new Matrix(this.T.arr.filter(n=>n.includes(item)))
         }
-        sortAll(calback=undefined){
-            let newArr=this.arr.flat(1).sort(calback);
-            return new Matrix(this.rows, this.cols, newArr);         
+        sortAll(calback=undefined){
+            let newArr=this.arr.flat(1).sort(calback);
+            return new Matrix(this.rows, this.cols, newArr);         
+        }
+        count(n) {
+            return this.arr.flat(1).count(n);
+        }
+        // toBase(n) {
+        //     let newArr = this.arr.flat(1).toBase(n);
+        //     return new Matrix(this.rows, this.cols, newArr);
+        // }
+        
+        splice(r0,c0,deleteCount,...items){
+            
+        }
+        getRows(ri, rf = ri + 1) {
+            return this.slice(ri, 0, rf, this.cols);
+        }
+        getCols(ci, cf = ci + 1) {
+            return this.slice(0, ci, this.rows, cf);
+        }
+        static getRows(m, ri, rf = ri + 1) {
+            return m.slice(ri, 0, rf, m.cols);
+        }
+        static getCols(m, ci, cf = ci + 1) {
+            return m.slice(0, ci, m.rows, cf);
+        }
+        add(...matr) {
+            for (let k = 0; k < matr.length; k++) {
+                if (typeof matr[k] == "number"||matr[k] instanceof Complex) matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = add(this.arr[i][j],matr[k].arr[i][j]);
+            }
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
+        }
+        sub(...matr) {
+            for (let k = 0; k < matr.length; k++) {
+                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = sub(this.arr[i][j],matr[k].arr[i][j]);
+            }
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
+        }
+        static add(m1, ...m2) {
+            return m1.clone().add(...m2);
+        }
+        static sub(m1, ...m2) {
+            return m1.clone().sub(...m2);
+        }
+        mul(...matr) {
+            for (let k = 0; k < matr.length; k++) {
+                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+                for (var i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = mul(this.arr[i][j],matr[k].arr[i][j]);
+            }
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
+        }
+        div(...matr) {
+            for (let k = 0; k < matr.length; k++) {
+                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = div(this.arr[i][j],matr[k].arr[i][j]);
+            }
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
+        }
+        static div(m1, ...m2) {
+            return m1.clone().div(...m2);
+        }
+        static mul(m1, ...m2) {
+            return m1.clone().mul(...m2);
+        }
+        modulo(...matr) {
+            for (let k = 0; k < matr.length; k++) {
+                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
+                for (let i = 0; i < this.rows; i++) 
+                    for (var j = 0; j < this.cols; j++)
+                        this.arr[i][j]=modulo(this.arr[i][j],matr[k].arr[i][j]);
+            }
+            return new Matrix(this.rows, this.cols, this.arr.flat(1));
+        }
+        static modulo(m1, ...m2) {
+            return m1.clone().modulo(...m2);
+        }
+        dot(matrix) {
+            var res = [];
+            for (var i = 0; i < this.arr.length; i++) {
+                res[i] = [];
+                for (var j = 0; j < matrix.arr[0].length; j++) {
+                    res[i][j] = 0;
+                    for (var k = 0; k < this.arr[0].length; k++) {
+                        res[i][j] = add(
+                            res[i][j],
+                            mul(this.arr[i][k],matrix.arr[k][j])
+                            );
+                    }
+                }
+            }
+            return new Matrix(this.arr.length, matrix.arr[0].length, res.flat(1));
+        }
+        static dot(matrix1, matrix2) {
+            return matrix1.dot(matrix2);
+        }
+        pow(n) {
+            let a = this.clone(),
+                p = this.clone();
+            for (let i = 0; i < n - 1; i++) p = p.dot(a);
+            return p;
+        }
+        static pow(m, n) {
+            return m.clone().pow(n);
+        }
+        get somme() {
+            let S = 0;
+            for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) S += this.arr[i][j];
+            return S;
+        }
+        get hasComplex() {
+            return this.arr.flat(Infinity).some((n) => n instanceof Complex);
+        }
+        get min() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            let minRow = [];
+            for (let i = 0; i < this.rows; i++) minRow.push(min(...this.arr[i]));
+            return min(...minRow);
+        }
+        get max() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            let maxRow = [];
+            for (let i = 0; i < this.rows; i++) maxRow.push(max(...this.arr[i]));
+            return max(...maxRow);
+        }
+        get minRows() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            let minRow = [];
+            for (let i = 0; i < this.rows; i++) minRow.push(min(...this.arr[i]));
+            return minRow;
+        }
+        get maxRows() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            let maxRow = [];
+            for (let i = 0; i < this.rows; i++) maxRow.push(max(...this.arr[i]));
+            return maxRow;
+        }
+        get minCols() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            return this.T.minRows;
+        }
+        get maxCols() {
+            if (this.hasComplex) console.error("Complex numbers are not comparable");
+            return this.T.maxRows;
+        }
+        static fromVector(v) {
+            return new Matrix(v.length, 1, v);
+        }
+        get toArray() {
+            let arr = [];
+            for (let i = 0; i < this.rows; i++) {
+                for (let j = 0; j < this.cols; j++) {
+                    arr.push(this.arr[i][j]);
+                }
+            }
+            return arr;
+        }
+        get serialize() {
+            return JSON.stringify(this);
+        }
+        static deserialize(data) {
+            if (typeof data == "string") data = JSON.parse(data);
+            let matrix = new Matrix(data.rows, data.cols);
+            matrix.arr = data.arr;
+            return matrix;
+        }
+        sortTable(n=0,{type="num",order="asc"}={}) {
+            var obj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
+            var newObj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
+            if(type==="num"){
+                if(order==="asc")obj[n].sort((a,b)=>a.x-b.x);
+                else if(order==="desc")obj[n].sort((a,b)=>b.x-a.x);
+                else if(order==="toggle"){
+                   // console.log(obj[n][0])
+                    //console.log(obj[n][1])
+                    if(obj[n][0].x>obj[n][1].x)obj[n].sort((a,b)=>b.x-a.x);
+                    else obj[n].sort((a,b)=>a.x-b.x);
+                }
+            }
+            else if(type==="alpha"){
+                if(order==="asc")obj[n].sort((a,b)=>(""+a.x).localeCompare(""+b.x));
+                else if(order==="desc")obj[n].sort((a,b)=>(""+b.x).localeCompare(""+a.x));            
+            }
+            //var order=obj[n].map(n=>n.y);
+            order=obj[n].map(n=>n.y);
+            for(let i=0;i<obj.length;i++){
+                if(i!==n)obj[i].map((n,j)=>n.y=order[j]);
+            }
+            for(let i=0;i<obj.length;i++){
+                if(i!==n)newObj[i].map((n,j)=>n.x=obj[i][order[j]].x);
+            }
+            newObj[n]=obj[n];
+            var newArr=newObj.map(n=>n.map(m=>m.x));
+            return new Matrix(newArr).T;
+        }
+    }
+
+
+    /**
+    * @returns {Matrix}
+    */
+    const matrix=(r, c, element)=>new Matrix(r, c, element);
+    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 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;
         }
-        count(n) {
-            return this.arr.flat(1).count(n);
+    };
+
+    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))
         }
-        // toBase(n) {
-        //     let newArr = this.arr.flat(1).toBase(n);
-        //     return new Matrix(this.rows, this.cols, newArr);
-        // }
         
-        splice(r0,c0,deleteCount,...items){
-            
-        }
-        getRows(ri, rf = ri + 1) {
-            return this.slice(ri, 0, rf, this.cols);
-        }
-        getCols(ci, cf = ci + 1) {
-            return this.slice(0, ci, this.rows, cf);
-        }
-        static getRows(m, ri, rf = ri + 1) {
-            return m.slice(ri, 0, rf, m.cols);
-        }
-        static getCols(m, ci, cf = ci + 1) {
-            return m.slice(0, ci, m.rows, cf);
+    };
+
+    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;
         }
-        add(...matr) {
-            for (let k = 0; k < matr.length; k++) {
-                if (typeof matr[k] == "number"||matr[k] instanceof Complex) matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
-                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = add(this.arr[i][j],matr[k].arr[i][j]);
+        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 new Matrix(this.rows, this.cols, this.arr.flat(1));
+            return permutations;
         }
-        sub(...matr) {
-            for (let k = 0; k < matr.length; k++) {
-                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
-                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = sub(this.arr[i][j],matr[k].arr[i][j]);
+    }
+
+    class Combinaison {
+        static withDiscount(comboOptions, comboLength) {
+            if (comboLength === 1) {
+                return comboOptions.map((comboOption) => [comboOption]);
             }
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
-        }
-        static add(m1, ...m2) {
-            return m1.clone().add(...m2);
-        }
-        static sub(m1, ...m2) {
-            return m1.clone().sub(...m2);
+            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;
         }
-        mul(...matr) {
-            for (let k = 0; k < matr.length; k++) {
-                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
-                for (var i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = mul(this.arr[i][j],matr[k].arr[i][j]);
+        static withoutDiscount(comboOptions, comboLength) {
+            if (comboLength === 1) {
+                return comboOptions.map((comboOption) => [comboOption]);
             }
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
+            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;
         }
-        div(...matr) {
-            for (let k = 0; k < matr.length; k++) {
-                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
-                for (let i = 0; i < this.rows; i++) for (var j = 0; j < this.cols; j++) this.arr[i][j] = div(this.arr[i][j],matr[k].arr[i][j]);
-            }
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
+    }
+    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 div(m1, ...m2) {
-            return m1.clone().div(...m2);
+        static int(a, b) {
+            return Math.floor(this.float(a, b));
         }
-        static mul(m1, ...m2) {
-            return m1.clone().mul(...m2);
+        static char(upperCase){
+            upperCase=upperCase??this.bool();
+            const Char=String.fromCharCode(this.int(97,120));
+            return upperCase?Char.toUpperCase():Char;
         }
-        modulo(...matr) {
-            for (let k = 0; k < matr.length; k++) {
-                if (typeof matr[k] == "number") matr[k] = Matrix.nums(this.rows, this.cols, matr[k]);
-                for (let i = 0; i < this.rows; i++) 
-                    for (var j = 0; j < this.cols; j++)
-                        this.arr[i][j]=modulo(this.arr[i][j],matr[k].arr[i][j]);
-            }
-            return new Matrix(this.rows, this.cols, this.arr.flat(1));
+        static bool(){
+            return [false,true][Math.floor(Math.random()*2)];
         }
-        static modulo(m1, ...m2) {
-            return m1.clone().modulo(...m2);
+        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("");
         }
-        dot(matrix) {
-            var res = [];
-            for (var i = 0; i < this.arr.length; i++) {
-                res[i] = [];
-                for (var j = 0; j < matrix.arr[0].length; j++) {
-                    res[i][j] = 0;
-                    for (var k = 0; k < this.arr[0].length; k++) {
-                        res[i][j] = add(
-                            res[i][j],
-                            mul(this.arr[i][k],matrix.arr[k][j])
-                            );
-                    }
-                }
-            }
-            return new Matrix(this.arr.length, matrix.arr[0].length, res.flat(1));
+        static bin() {
+            return this.int(2);
         }
-        static dot(matrix1, matrix2) {
-            return matrix1.dot(matrix2);
+        static oct() {
+            return this.int(8);
         }
-        pow(n) {
-            let a = this.clone(),
-                p = this.clone();
-            for (let i = 0; i < n - 1; i++) p = p.dot(a);
-            return p;
+        static dec() {
+            return this.int(8);
         }
-        static pow(m, n) {
-            return m.clone().pow(n);
+        static hex() {
+            return this.int(16);
         }
-        get somme() {
-            let S = 0;
-            for (let i = 0; i < this.rows; i++) for (let j = 0; j < this.cols; j++) S += this.arr[i][j];
-            return S;
+        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)];
         }
-        get hasComplex() {
-            return this.arr.flat(Infinity).some((n) => n instanceof Complex);
+        static shuffleArr(arr){
+            return arr.sort(()=>0.5-Math.random())    
         }
-        get min() {
-            if (this.hasComplex) console.error("Complex numbers are not comparable");
-            let minRow = [];
-            for (let i = 0; i < this.rows; i++) minRow.push(min(...this.arr[i]));
-            return min(...minRow);
+        static floats(n, a, b) {
+            return new Array(n).fill(0).map(() => this.float(a, b));
         }
-        get max() {
-            if (this.hasComplex) console.error("Complex numbers are not comparable");
-            let maxRow = [];
-            for (let i = 0; i < this.rows; i++) maxRow.push(max(...this.arr[i]));
-            return max(...maxRow);
+        static ints(n, a, b) {
+            return new Array(n).fill(0).map(() => this.int(a, b));
         }
-        get minRows() {
-            if (this.hasComplex) console.error("Complex numbers are not comparable");
-            let minRow = [];
-            for (let i = 0; i < this.rows; i++) minRow.push(min(...this.arr[i]));
-            return minRow;
+        static bools(n){
+            return  new Array(n).fill(0).map(() => this.bool());
         }
-        get maxRows() {
-            if (this.hasComplex) console.error("Complex numbers are not comparable");
-            let maxRow = [];
-            for (let i = 0; i < this.rows; i++) maxRow.push(max(...this.arr[i]));
-            return maxRow;
+        static bins(n) {
+            return new Array(n).fill(0).map(() => this.int(2));
         }
-        get minCols() {
-            if (this.hasComplex) console.error("Complex numbers are not comparable");
-            return this.T.minRows;
+        static octs(n) {
+            return new Array(n).fill(0).map(() => this.int(8));
         }
-        get maxCols() {
-            if (this.hasComplex) console.error("Complex numbers are not comparable");
-            return this.T.maxRows;
+        static decs(n) {
+            return new Array(n).fill(0).map(() => this.int(10));
         }
-        static fromVector(v) {
-            return new Matrix(v.length, 1, v);
+        static hexs(n) {
+            return new Array(n).fill(0).map(() => this.int(16));
         }
-        get toArray() {
-            let arr = [];
-            for (let i = 0; i < this.rows; i++) {
-                for (let j = 0; j < this.cols; j++) {
-                    arr.push(this.arr[i][j]);
-                }
-            }
-            return arr;
+        static choices(n, choices, p) {
+            return new Array(n).fill(0).map(() => this.choice(choices, p));
         }
-        get serialize() {
-            return JSON.stringify(this);
+        static perm(...arr) {
+            // permutation
+            return arr.permS[this.int(arr.length)];
         }
-        static deserialize(data) {
-            if (typeof data == "string") data = JSON.parse(data);
-            let matrix = new Matrix(data.rows, data.cols);
-            matrix.arr = data.arr;
-            return matrix;
+        static color() {
+            return "#" + Base.dec2hex(this.float(16777216)).padStart(6,0);
         }
-        sortTable(n=0,{type="num",order="asc"}={}) {
-            var obj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
-            var newObj=this.T.arr.map(n=>n.map((n,i)=>Object.assign({},{x:n,y:i})));
-            if(type==="num"){
-                if(order==="asc")obj[n].sort((a,b)=>a.x-b.x);
-                else if(order==="desc")obj[n].sort((a,b)=>b.x-a.x);
-                else if(order==="toggle"){
-                   // console.log(obj[n][0])
-                    //console.log(obj[n][1])
-                    if(obj[n][0].x>obj[n][1].x)obj[n].sort((a,b)=>b.x-a.x);
-                    else obj[n].sort((a,b)=>a.x-b.x);
-                }
-            }
-            else if(type==="alpha"){
-                if(order==="asc")obj[n].sort((a,b)=>(""+a.x).localeCompare(""+b.x));
-                else if(order==="desc")obj[n].sort((a,b)=>(""+b.x).localeCompare(""+a.x));            
-            }
-            //var order=obj[n].map(n=>n.y);
-            order=obj[n].map(n=>n.y);
-            for(let i=0;i<obj.length;i++){
-                if(i!==n)obj[i].map((n,j)=>n.y=order[j]);
-            }
-            for(let i=0;i<obj.length;i++){
-                if(i!==n)newObj[i].map((n,j)=>n.x=obj[i][order[j]].x);
-            }
-            newObj[n]=obj[n];
-            var newArr=newObj.map(n=>n.map(m=>m.x));
-            return new Matrix(newArr).T;
+        static colors(n) {
+            return new Array(n).fill(null).map(()=>this.color());
         }
-    }
 
-
-    /**
-    * @returns {Matrix}
-    */
-    const matrix=(r, c, element)=>new Matrix(r, c, element);
-    const matrix2=(...element)=>new Matrix(2, 2, element);
-    const matrix3=(...element)=>new Matrix(3, 3, element);
-    const matrix4=(...element)=>new Matrix(4, 4, element);
+        // 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$1, sin: sin$1, acos, pow } = Math;