ziko 1.10.0 → 2.0.0-alpha.0

package/dist/ziko.cjs

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Wed Aug 26 2026 10:48:40 GMT+0100 (UTC+01:00)
+  Date : Wed Sep 02 2026 10:53:51 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
@@ -10,23 +10,23 @@
 
 'use strict';
 
-const { PI: PI$1, E } = Math;
+const { PI, E } = Math;
 const EPSILON=Number.EPSILON;
 
 const is_primitive$1 = value => typeof value !== 'object' && typeof value !== 'function' || value === null;
 
-const mapfun$1=(fun,...X)=>{
+const mapfun=(fun,...X)=>{
     const Y=X.map(x=>{
         if(is_primitive$1(x) || x?.__mapfun__) return fun(x)
-        if(x instanceof Array) return x.map(n=>mapfun$1(fun,n));
+        if(x instanceof Array) return x.map(n=>mapfun(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 instanceof Set) return new Set(mapfun(fun,...[...x]));
+        if(x instanceof Map) return new Map([...x].map(n=>[n[0],mapfun(fun,n[1])]));
+        if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun(x.arr.flat(1)))
         else if(x instanceof Object){
             return Object.fromEntries(
                 Object.entries(x).map(
-                    n=>n=[n[0],mapfun$1(fun,n[1])]
+                    n=>n=[n[0],mapfun(fun,n[1])]
                 )
             )
         }
@@ -44,7 +44,7 @@ const apply_fun = (x, fn) => {
         x.cols,
         x.arr.flat(1).map(fn)
     )
-    if (x instanceof Array) mapfun$1(fn, ...x);
+    if (x instanceof Array) mapfun(fn, ...x);
     return fn(x)
 };
 
@@ -370,21 +370,7 @@ class Random {
             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}
+}
 
 const complex_constructor = (Complex, a, b) => {
     let _a, _b;
@@ -617,7 +603,7 @@ const complex=(a,b)=>{
 
 const PRECESION = 8;
 
-const abs = (...x) => mapfun$1(
+const abs = (...x) => mapfun(
     x =>{
         if(x.isComplex?.()) return x.z;
         return Math.abs(x)
@@ -625,9 +611,9 @@ const abs = (...x) => mapfun$1(
     ...x
 );
 
-const pow$1 = (...x) => {
+const pow = (...x) => {
     const n = x.pop();
-    return mapfun$1(
+    return mapfun(
         x => {
             if(x.isComplex?.()) {
                 if(n.isComplex?.()) return new x.constructor({
@@ -646,7 +632,7 @@ const pow$1 = (...x) => {
     )
 };
 
-const sqrt$2 = (...x) => mapfun$1(
+const sqrt = (...x) => mapfun(
     x=>{
         if(x.isComplex?.()) 
             return new x.constructor({z: x.z**(1/2), phi: x.phi/2});
@@ -656,7 +642,7 @@ const sqrt$2 = (...x) => mapfun$1(
     ...x
 );
 
-const cbrt = (...x) => mapfun$1(
+const cbrt = (...x) => mapfun(
     x=>{
         if(x.isComplex?.()) 
             return new x.constructor({z: x.z**(1/3), phi: x.phi/3}).toFixed(PRECESION)
@@ -668,7 +654,7 @@ const cbrt = (...x) => mapfun$1(
 const nthr = (...x) => {
     const n = x.pop();
     if(typeof n !== 'number') throw Error('nthr expects a real number n');
-    return mapfun$1(
+    return mapfun(
         x => {
             if(x.isComplex?.()) return new x.constructor({z: x.z ** (1/n), phi: x.phi / n});
             if(x<0) return n %2 ===2 
@@ -683,7 +669,7 @@ const nthr = (...x) => {
 const croot = (...x) =>{
     const c = x.pop();
     if(!c.isComplex?.()) throw Error('croot expect Complex number as root')
-    return mapfun$1(
+    return mapfun(
         x => {
             if(typeof x === 'number') x = new c.constructor(x, 0);
             const {a : c_a, b : c_b} = c;
@@ -700,7 +686,7 @@ const croot = (...x) =>{
     )
 };
 
-const exp$1 = (...x) => mapfun$1(
+const exp = (...x) => mapfun(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.exp(x.a) * Math.cos(x.b),
@@ -711,7 +697,7 @@ const exp$1 = (...x) => mapfun$1(
     ,...x
 );
 
-const ln = (...x) => mapfun$1(
+const ln = (...x) => mapfun(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.log(x.z),
@@ -722,7 +708,7 @@ const ln = (...x) => mapfun$1(
     ,...x
 );
 
-const sign = (...x) => mapfun$1(
+const sign = (...x) => mapfun(
     x => {
         if(x.isComplex?.()){
             const {z, phi} = x;
@@ -734,7 +720,7 @@ const sign = (...x) => mapfun$1(
     ,...x
 );
 
-const floor = (...x) => mapfun$1(
+const floor = (...x) => mapfun(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.floor(x.a),
@@ -744,7 +730,7 @@ const floor = (...x) => mapfun$1(
     },
     ...x
 );
-const ceil = (...x) => mapfun$1(
+const ceil = (...x) => mapfun(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.ceil(x.a),
@@ -754,7 +740,7 @@ const ceil = (...x) => mapfun$1(
     },
     ...x
 );
-const round = (...x) => mapfun$1(
+const round = (...x) => mapfun(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.round(x.a),
@@ -765,7 +751,7 @@ const round = (...x) => mapfun$1(
     ...x
 );
 
-const trunc = (...x) => mapfun$1(
+const trunc = (...x) => mapfun(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.trunc(x.a),
@@ -776,7 +762,7 @@ const trunc = (...x) => mapfun$1(
     ...x
 );
 
-const fract = (...x) => mapfun$1(
+const fract = (...x) => mapfun(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             x.a - Math.trunc(x.a),
@@ -787,7 +773,7 @@ const fract = (...x) => mapfun$1(
     ...x
 );
 
-const cos$3 = (...x) => mapfun$1(
+const cos$1 = (...x) => mapfun(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.cos(x.a) * Math.cosh(x.b),
@@ -798,7 +784,7 @@ const cos$3 = (...x) => mapfun$1(
     ,...x
 );
 
-const sin$3 = (...x) => mapfun$1(
+const sin$1 = (...x) => mapfun(
     x =>{
         if(x?.isComplex) return new x.constructor(
             Math.sin(x.a) * Math.cosh(x.b),
@@ -809,7 +795,7 @@ const sin$3 = (...x) => mapfun$1(
     , ...x
 );
 
-const tan = (...x) => mapfun$1(
+const tan = (...x) => mapfun(
     x =>{
         if(x?.isComplex){
             const D = Math.cos(2*x.a) + Math.cosh(2*x.b);
@@ -823,7 +809,7 @@ const tan = (...x) => mapfun$1(
     ...x
 );
 
-const sec = (...x) => mapfun$1(
+const sec = (...x) => mapfun(
     x => {
         if(x.isComplex?.()) ;
         return + (1 / Math.cos(x)).toFixed(PRECESION)
@@ -831,7 +817,7 @@ const sec = (...x) => mapfun$1(
     ,...x
 );
 
-const acos$1 = (...x) => mapfun$1(
+const acos = (...x) => mapfun(
     x =>{
         if(x?.isComplex){
             const { a, b } = x;
@@ -849,7 +835,7 @@ const acos$1 = (...x) => mapfun$1(
     ...x
 );
 
-const asin = (...x) => mapfun$1(
+const asin = (...x) => mapfun(
     x => {
         if(x?.isComplex){
             const { a, b } = x;
@@ -865,7 +851,7 @@ const asin = (...x) => mapfun$1(
     ...x
 );
 
-const atan = (...x) => mapfun$1(
+const atan = (...x) => mapfun(
     x => {
         if(x?.isComplex){
             const { a, b } = x;
@@ -879,7 +865,7 @@ const atan = (...x) => mapfun$1(
     ...x
 );
 
-const acot = (...x) => mapfun$1(
+const acot = (...x) => mapfun(
     x => {
         if(x?.isComplex){
             const { a, b } = x;
@@ -894,7 +880,7 @@ const acot = (...x) => mapfun$1(
 );
 
 
-const cosh$2 = (...x) => mapfun$1(
+const cosh$1 = (...x) => mapfun(
     x =>{
         if(x?.isComplex) return new x.constructor(
             Math.cosh(x.a) * Math.cos(x.b),
@@ -904,7 +890,7 @@ const cosh$2 = (...x) => mapfun$1(
     },
     ...x
 );
-const sinh$1 = (...x) => mapfun$1(
+const sinh = (...x) => mapfun(
     x =>{
         if(x?.isComplex) return new x.constructor(
             Math.sinh(x.a) * Math.cos(x.b),
@@ -914,7 +900,7 @@ const sinh$1 = (...x) => mapfun$1(
     },
     ...x
 );
-const tanh = (...x) => mapfun$1(
+const tanh = (...x) => mapfun(
     x =>{
         if(x?.isComplex){
             const D = Math.cosh(2*a) + Math.cos(2*b);
@@ -928,7 +914,7 @@ const tanh = (...x) => mapfun$1(
     ...x
 );
 
-const coth = (...x) => mapfun$1(
+const coth = (...x) => mapfun(
     x =>{
         if(x?.isComplex){
             const {a, b} = x;
@@ -943,27 +929,27 @@ const coth = (...x) => mapfun$1(
     ...x
 );
 
-const acosh = (...x) => mapfun$1(
+const acosh = (...x) => mapfun(
     x =>{
         if(x?.isComplex){
-            return ln(x.clone().add(sqrt$2(x.clone().mul(x.clone()).sub(1))))
+            return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).sub(1))))
         } 
         return + Math.acosh(x).toFixed(PRECESION)
     },
     ...x
 );
 
-const asinh = (...x) => mapfun$1(
+const asinh = (...x) => mapfun(
     x =>{
         if(x?.isComplex){
-            return ln(x.clone().add(sqrt$2(x.clone().mul(x.clone()).add(1))))
+            return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).add(1))))
         } 
         return + Math.asinh(x).toFixed(PRECESION)
     },
     ...x
 );
 
-const atanh = (...x) => mapfun$1(
+const atanh = (...x) => mapfun(
     x =>{
         if(x?.isComplex); 
         return + Math.atanh(x).toFixed(PRECESION)
@@ -971,7 +957,7 @@ const atanh = (...x) => mapfun$1(
     ...x
 );
 
-const sig = (...x) => mapfun$1(
+const sig = (...x) => mapfun(
     x =>{
         if(x?.isComplex); 
         return 1/(1 + Math.exp(-x)).toFixed(PRECESION)
@@ -1036,8 +1022,8 @@ const modulo=(a,...b)=>{
     return res;
 };
 
-const deg2rad = (...deg) => mapfun$1(x => x * Math.PI / 180, ...deg);
-const rad2deg = (...rad) => mapfun$1(x => x / Math.PI * 180, ...rad);
+const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
+const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
 
 const norm = (x, min, max) => apply_fun(
     x, 
@@ -1068,10 +1054,10 @@ const hypot = (...x) => {
 
 const atan2 = (y, x, rad = true) => {
     if (y instanceof Array && !(x instanceof Array))
-        return mapfun$1(n => atan2(n, x, rad), ...y);
+        return mapfun(n => atan2(n, x, rad), ...y);
 
     if (x instanceof Array && !(y instanceof Array))
-        return mapfun$1(n => atan2(y, n, rad), ...x);
+        return mapfun(n => atan2(y, n, rad), ...x);
 
     if (y instanceof Array && x instanceof Array)
         return y.map((v, i) => atan2(v, x[i], rad));
@@ -1080,804 +1066,6 @@ const atan2 = (y, x, rad = true) => {
     return rad ? phi : phi * 180 / Math.PI;
 };
 
-const min = (...x) => Math.min(...x);
-const max = (...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;
-};
-
-// export const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
-
-// export 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;
-// };
-
-// export const std = (...x) => Math.sqrt(variance(...x));
-
-// export 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;
-};
-
-// export 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;
-// }
-
-// export const median = X => percentile(X, 50);
-
-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)
-        );
-    }
-
-    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 { 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);
-    }
-
-    return null;  // Return null if no Complex or Matrix found
-};
-
-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 or = (...x) => {
-    const result = handle_complex_and_matrix(x, or);
-    if (result !== null) return result;
-    return x.reduce((n, m) => (n |= m), 0);
-};
-
-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 nand = (...x) => not(and(...x));
-const nor = (...x) => not(or(...x));
-const xnor = (...x) => not(xor(...x));
-
-const matrix_constructor = (Matrix, rows, cols, element) => {
-  if (rows instanceof Matrix) {
-    arr = rows.arr;
-    rows = rows.rows;
-    cols = rows.cols;
-  } 
-  else {
-    let arr = [], i, j;
-    if (rows instanceof Array) {
-        arr = rows;
-        rows = arr.length;
-        cols = arr[0].length;
-    } 
-    else {
-      for (i = 0; i < rows; i++) {
-        arr.push([]);
-        arr[i].push(new Array(cols));
-        for (j = 0; j < cols; j++) {
-          arr[i][j] = element[i * cols + j];
-          if (element[i * cols + j] == undefined) arr[i][j] = 0;
-        }
-      }
-    }
-    return [
-        rows,
-        cols,
-        arr
-    ]
-  }
-};
-
-const maintain_indexes = (Matrix, oldRows) =>{
-    for (let i = 0; i < Matrix.arr.length; i++) {
-        Object.defineProperty(Matrix, i, {
-            value: Matrix.arr[i],
-            writable: true,
-            configurable: true,
-            enumerable: false
-        });
-    }
-    for (let i = Matrix.arr.length; i < oldRows; i++) {
-        delete Matrix[i];
-    }
-};
-
-function matrix_inverse(M) {
-    if(M.row !== M.cols) throw Error('is not a square matrix"')
-    if (M.det === 0) throw Error("determinant should not equal 0");
-    const { arr } = M;
-    if (arr.length !== arr[0].length) return;
-    var i = 0, ii = 0, j = 0, dim = arr.length, e = 0;
-    var I = [], C = [];
-    for (i = 0; i < dim; i += 1) {
-        I[I.length] = [];
-        C[C.length] = [];
-        for (j = 0; j < dim; j += 1) {
-            if (i == j) I[i][j] = 1;
-            else I[i][j] = 0;
-            C[i][j] = arr[i][j];
-        }
-    }
-    for (i = 0; i < dim; i += 1) {
-        e = C[i][i];
-        if (e == 0) {
-            for (ii = i + 1; ii < dim; ii += 1) {
-                if (C[ii][i] != 0) {
-                    for (j = 0; j < dim; j++) {
-                        e = C[i][j];
-                        C[i][j] = C[ii][j];
-                        C[ii][j] = e;
-                        e = I[i][j];
-                        I[i][j] = I[ii][j];
-                        I[ii][j] = e;
-                    }
-                    break;
-                }
-            }
-            e = C[i][i];
-            if (e == 0) return;
-        }
-        for (j = 0; j < dim; j++) {
-            C[i][j] = C[i][j] / e;
-            I[i][j] = I[i][j] / e;
-        }
-        for (ii = 0; ii < dim; ii++) {
-            if (ii == i) {
-                continue;
-            }
-            e = C[ii][i];
-            for (j = 0; j < dim; j++) {
-                C[ii][j] -= e * C[i][j];
-                I[ii][j] -= e * I[i][j];
-            }
-        }
-    }
-    return new M.constructor(I);
-}
-
-function matrix_det(M) {
-    if (!M.isSquare) return new Error("is not square matrix");
-    if (M.rows == 1) return M.arr[0][0];
-    function determinat(M) {
-        if (M.length == 2) {
-            if (M.flat(1).some((n) => n?.isMatrix?.())) {
-                console.warn("Tensors are not completely supported yet ...");
-                return;
-            }
-            return sub(mul(M[0][0],M[1][1]),mul(M[0][1],M[1][0]))
-        }
-        var answer = 0;
-        for (var i = 0; i < M.length; i++) {
-            //console.log(M[0][i]);
-            /*answer = answer.add(
-                pow(-1, i)
-                    .mul(M[0][i])
-                    .mul(determinat(deleteRowAndColumn(M, i)))
-            );*/
-            //const to_be_added=add(mul(pow(-1, i),mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
-            const to_be_added=add(mul(pow$1(-1, i),mul(M[0][i],determinat(deleteRowAndColumn(M, i)))));
-            answer=add(answer,to_be_added);
-        }
-        return answer;
-    }
-    return determinat(M.arr);
-}
-function deleteRowAndColumn(M, index) {
-    var temp = [];
-    for (let i = 0; i < M.length; i++) temp.push(M[i].slice(0));
-    temp.splice(0, 1);
-    for (let i = 0; i < temp.length; i++) temp[i].splice(index, 1);
-    return temp;
-}
-
-function hstack(M1, M2){
-    M1 = M1.clone();
-    M2 = M2.clone();
-    if (M1.rows !== M2.rows) return;
-    let newArr = M1.arr;
-    for (let i = 0; i < M1.rows; i++) 
-        for (let j = M1.cols; j < M1.cols + M2.cols; j++) 
-            newArr[i][j] = M2.arr[i][j - M1.cols];
-    M1.cols += M2.cols;
-    return new M1.constructor(M1.rows, M1.cols, newArr.flat(1));
-}
-
-function vstack(M1, M2){
-    M1 = M1.clone();
-    M2 = M2.clone();
-    if (M1.cols !== M2.cols) return;
-    let newArr = M1.arr;
-    for (let i = M1.rows; i < M1.rows + M2.rows; i++) {
-        newArr[i] = [];
-        for (let j = 0; j < M1.cols; j++) newArr[i][j] = M2.arr[i - M1.rows][j];
-    }
-    M1.rows += M2.rows;
-    return new M1.constructor(M1.rows, M1.cols, newArr.flat(1));
-}
-
-class Matrix{
-    constructor(rows, cols, element = [] ) {
-        [
-            this.rows, 
-            this.cols, 
-            this.arr
-        ] = matrix_constructor(Matrix, rows, cols, element);
-        maintain_indexes(this);
-    }
-    isMatrix(){
-        return true
-    }
-    clone() {
-        return new Matrix(this.rows, this.cols, this.arr.flat(1));
-    }
-    toComplex(){
-        this.arr = mapfun$1(
-            x => x?.isComplex?.() ? x : new Complex(x, 0),
-            ...this.arr
-        );
-        maintain_indexes(this);
-        return this;
-    }
-    [Symbol.iterator]() {
-      return this.arr[Symbol.iterator]();
-    }
-    get size() {
-        return this.rows * this.cols;
-    } 
-    get shape() {
-        return [this.rows, this.cols];
-    }
-    // toString(){
-    //     return arr2str(this.arr,false);
-    // }
-    at(i = 0, j = undefined) {
-        if(i < 0) i += this.rows;
-        if(i < 0 || i >= this.rows) throw new Error('Row index out of bounds');
-        if(j === undefined) return this.arr[i];
-        if(j < 0) j += this.cols;
-        if(j < 0 || j >= this.cols) throw new Error('Column index out of bounds');
-        return this.arr[i][j];
-    }
-    slice(r0=0, c0=0, r1 = this.rows-1, c1 = this.cols-1) {
-        if(r1 < 0) r1 = this.rows + r1;
-        if(c1 < 0 ) c1 = this.cols + c1;
-        let newRow = r1 - r0,
-            newCol = c1 - c0;
-        let newArr = new Array(newCol);
-        for (let i = 0; i < newRow; i++) {
-            newArr[i] = [];
-            for (let j = 0; j < newCol; j++) 
-                newArr[i][j] = this.arr[i + r0][j + c0];
-        }
-        this.arr = newArr;
-        maintain_indexes(this.rows);
-        this.rows = newRow;
-        this.cols = newCol;
-        return this;
-    }
-    reshape(newRows, newCols) {
-        if(!(newRows * newCols === this.rows * this.cols)) throw Error('size not matched');
-        const oldRows = this.rows;
-        Object.assign(this, new Matrix(newRows, newCols, this.arr.flat(1)));
-        maintain_indexes(oldRows);
-        return this;
-    }
-    get T() {
-        let transpose = [];
-        for (let i = 0; i < this.arr[0].length; i++) {
-            transpose[i] = [];
-            for (let j = 0; j < this.arr.length; j++) 
-                transpose[i][j] = this.arr[j][i];
-        }
-        return new Matrix(this.cols, this.rows, transpose.flat(1));
-    }
-    get det() {
-        return matrix_det(this)
-    }
-    get inv() {
-        return matrix_inverse(this)
-    }
-    // normalize names
-    static eye(size) {
-        let result = new Matrix(size, size);
-        for (let i = 0; i < size; i++) 
-            for (let j = 0; j < size; j++) i === j ? (result.arr[i][j] = 1) : (result.arr[i][j] = 0);
-        return result;
-    }
-    static zeros(rows, cols) {
-        let result = new Matrix(rows, cols);
-        for (let i = 0; i < rows; i++) 
-            for (var j = 0; j < cols; j++) result.arr[i][j] = 0;
-        return result;
-    }
-    static ones(rows, cols) {
-        let result = new Matrix(rows, cols);
-        for (let i = 0; i < rows; i++) 
-            for (let j = 0; j < cols; j++) result.arr[i][j] = 1;
-        return result;
-    }
-    static nums(rows, cols, number) {
-        let result = new Matrix(rows, cols);
-        for (let i = 0; i < rows; i++) 
-            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)
-            ),
-        }
-    }
-    get range(){
-        return {
-            map : (xmin, xmax, ymin, ymax) => {
-                this.arr = map$1(this.arr, xmin, xmax, ymin, ymax);
-                return this;
-            },
-            norm : (min, max) => {
-                this.arr = norm(this.arr, min, max);
-                return this;
-            },
-            lerp : (min, max) => {
-                this.arr = lerp(this.arr, min, max);
-                return this;
-            },
-            clamp : (min, max) => {
-                this.arr = clamp(this.arr, min, max);
-                return this;
-            },
-
-        }
-    }
-    hstack(...matrices) {
-        const M=[this, ...matrices].reduce((a,b)=>hstack(a, b));
-        Object.assign(this, M);
-        maintain_indexes(this);
-        return this;
-    }
-    vstack(...matrices){
-        const M=[this, ...matrices].reduce((a,b)=>vstack(a, b));
-        Object.assign(this, M);
-        maintain_indexes(this);
-        return this;
-    }
-    hqueue(...matrices){
-        const M=[this, ...matrices].reverse().reduce((a,b)=>hstack(a, b));
-        Object.assign(this, M);
-        maintain_indexes(this);
-        return this;
-    }
-    vqueue(...matrices){
-        const M=[this,...matrices].reverse().reduce((a, b)=>vstack(a, b));
-        Object.assign(this, M);
-        maintain_indexes(this);
-        return this;
-    }
-    forEach(fn){
-        this.arr.flat(1).forEach(fn);
-        return this;
-    }
-    forEachRow(fn){
-        this.arr.forEach(fn);
-        return this;
-    }
-    forEachCol(fn){
-        this.clone().T.forEachRow(fn);
-        return this
-    }
-    map(fn){
-        const arr = this.arr.flat(1).map(fn);
-        return new Matrix(
-            this.rows, 
-            this.cols,
-            arr
-        )
-    }
-    mapRows(fn = ()=>{}){
-        this.arr = this.arr.map(fn);
-        return this;
-    }
-    mapCols(fn){
-        return this.clone().T.mapRows(fn).T;
-    }
-    sort(fn = ()=>{}){
-        const arr = this.arr.flat(1).sort(fn);
-        return new Matrix(
-            this.rows, 
-            this.cols,
-            arr
-        )  
-    }
-    shuffle(){
-        return this.sort(() => 0.5-Math.random())
-    }
-    sortRows(fn = ()=>{}){
-        this.arr = this.arr.map(row => row.sort(fn));
-        return this;
-    }
-    shuffleRows(){
-        return this.sortRows(() => 0.5-Math.random())
-    }
-    sortCols(fn){
-        return this.clone().T.sortRows(fn).T;
-    }
-    shuffleCols(){
-        return this.sortCols(() => 0.5-Math.random())
-    }
-    reduce(fn, initialValue){
-        const value = initialValue 
-            ? this.arr.flat(1).reduce(fn, initialValue) 
-            : this.arr.flat(1).reduce(fn);
-        return new Matrix([[value]])
-    }
-    reduceRows(fn, initialValue){
-        const values = initialValue 
-            ? this.arr.map(row => row.reduce(fn, initialValue)) 
-            : this.arr.map(row => row.reduce(fn)); 
-        return new Matrix(1, this.cols, values)
-    }
-    reduceCols(fn, initialValue){
-        return this.T.reduceRows(fn, initialValue).T
-    }
-    filterRows(fn){
-        const mask = this.arr.map(n => n.some(m => fn(m)));
-        const arr = [];
-        let i;
-        for(i = 0; i < mask.length; i++)
-            if(mask[i]) arr.push(this.arr[i]);
-        return new Matrix(arr)
-    }
-    filterCols(fn){
-        const arr = this.T.filterRows(fn);
-        return new Matrix(arr).T
-    }
-    every(fn){
-        return this.arr.flat(1).every(fn)
-    }
-    everyRow(fn){
-        return this.arr.map(n => n.every(fn))
-    }
-    everyCol(fn){
-        return this.T.arr.map(n => n.every(fn))
-    }
-    some(fn){
-        return this.arr.flat(1).some(fn)
-    }
-    someRow(fn){
-        return this.arr.map(n => n.some(fn))
-    }
-    someCol(fn){
-        return this.T.arr.map(n => n.some(fn))
-    }
-    // Checkers
-    get isSquare() {
-        return this.rows === this.cols;
-    }
-    get isSym() {
-        if (!this.isSquare) return false;
-        for (let i = 0; i < this.rows; i++) {
-            for (let j = i + 1; j < this.cols; j++) {
-                if (this.arr[i][j] !== this.arr[j][i]) return false;
-            }
-        }
-        return true;
-    }
-    get isAntiSym() {
-        if (!this.isSquare) return false;
-        const n = this.rows;
-        for (let i = 0; i < n; i++) {
-            if (this.arr[i][i] !== 0) return false;
-            for (let j = i + 1; j < n; j++) {
-                if (this.arr[i][j] !== -this.arr[j][i]) return false;
-            }
-        }
-        return true;
-    }
-    get isDiag() {
-        if (!this.isSquare) return false;
-        const n = this.rows;
-        for (let i = 0; i < n; i++) {
-            for (let j = i + 1; j < n; j++) {
-                if (this.arr[i][j] !== 0 || this.arr[j][i] !== 0) return false;
-            }
-        }
-        return true;
-    }
-    get isOrtho() {
-        if (!this.isSquare) return false;
-        return this.isDiag && (this.det == 1 || this.det == -1);
-    }
-    get isIdemp() {
-        if (!this.isSquare) return false;
-        const n = this.rows;
-        const A = this.arr;
-        // Compute A * A
-        const MM = [];
-        for (let i = 0; i < n; i++) {
-            MM[i] = [];
-            for (let j = 0; j < n; j++) {
-                let sum = 0;
-                for (let k = 0; k < n; k++) {
-                    sum += A[i][k] * A[k][j];
-                }
-                MM[i][j] = sum;
-            }
-        }
-        // Check if A * A == A
-        for (let i = 0; i < n; i++) {
-            for (let j = 0; j < n; j++) {
-                if (MM[i][j] !== A[i][j]) return false;
-            }
-        }
-        return true;
-    }
-
-    get isUpperTri() {
-        if (!this.isSquare) return false;
-        const n = this.rows;
-        for (let i = 1; i < n; i++) {
-            for (let j = 0; j < i; j++) {
-                if (this.arr[i][j] !== 0) return false;
-            }
-        }
-        return true;
-    }
-    get isLowerTri() {
-        if (!this.isSquare) return false;
-        const n = this.rows;
-        for (let i = 0; i < n - 1; i++) {
-            for (let j = i + 1; j < n; j++) {
-                if (this.arr[i][j] !== 0) return false;
-            }
-        }
-        return true;
-    }
-    toPrecision(p) {
-        for (let i = 0; i < this.cols; i++) 
-            for (let j = 0; j < this.rows; j++) 
-                this.arr[i][j] = +this.arr[i][j].toPrecision(p);
-        return this;
-    }
-    toFixed(p) {
-        for (let i = 0; i < this.cols; i++) 
-            for (let j = 0; j < this.rows; j++) 
-                this.arr[i][j] = +this.arr[i][j].toFixed(p);
-        return this;
-    }
-    // max2min() {
-    //     let newArr = this.arr.flat(1).max2min;
-    //     return new Matrix(this.rows, this.cols, newArr);
-    // }
-    // min2max() {
-    //     let newArr = this.arr.flat(1).min2max;
-    //     return new Matrix(this.rows, this.cols, newArr);
-    // }
-    // count(n) {
-    //     return this.arr.flat(1).count(n);
-    // }
-    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);
-    }
-    #arithmetic(fn, ...matr){
-        for (let k = 0; k < matr.length; k++) {
-            if (typeof matr[k] == "number" || matr[k]?.isComplex?.()) 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] = fn(this.arr[i][j], matr[k].arr[i][j]);
-        }
-        return new Matrix(this.rows, this.cols, this.arr.flat(1));  
-    }
-    add(...matr) {
-        return this.#arithmetic(add, ...matr)
-    }
-    sub(...matr) {
-        return this.#arithmetic(sub, ...matr)
-    }
-    mul(...matr) {
-        return this.#arithmetic(mul, ...matr)
-    }
-    div(...matr) {
-        return this.#arithmetic(div, ...matr)
-    }
-    modulo(...matr) {
-        return this.#arithmetic(modulo, ...matr)
-    }
-    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));
-    }
-    pow(n) {
-        let a = this.clone(),
-            p = this.clone();
-        for (let i = 0; i < n - 1; i++) p = p.dot(a);
-        return p;
-    }
-    sum(){
-        let S = 0;
-        for (let i = 0; i < this.rows; i++) 
-            for (let j = 0; j < this.cols; j++) 
-                S = add(S, this.arr[i][j]);
-        return S;
-    }
-    prod(){
-        let S = 1;
-        for (let i = 0; i < this.rows; i++) 
-            for (let j = 0; j < this.cols; j++) 
-                S = mul(S, this.arr[i][j]);
-        return S;
-    }
-    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(Math.min(...this.arr[i]));
-        return Math.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(Math.max(...this.arr[i]));
-        return Math.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(Math.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(Math.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);
-    }
-    serialize() {
-        const arr = mapfun$1(x => x.serialize?.() || x, ...this.arr);
-        return JSON.stringify({
-            type : 'matrix',
-            data : {
-                rows : this.rows,
-                cols : this.cols,
-                arr,
-            }
-        });
-    }
-    static deserialize(json) {
-        if (typeof json == "string") json = JSON.parse(json);
-        const {type, data} = json;
-        if(type !== 'matrix') return TypeError('Not a valid Matrix')
-        let {arr} = data;
-        arr = mapfun$1(x => {
-            if(typeof x === 'string') {
-                const x_obj = JSON.parse(x);
-                const {type} = x_obj;
-                if(type === 'complex') return Complex.deserialize(x_obj)
-            }
-            return x
-        }, ...arr);
-        return new Matrix(arr)
-    }
-    flip(){
-        return this.flipeH().flipeV()
-    }
-    flipeH(){
-        this.arr = this.arr.map(row => [...row].reverse());
-        maintain_indexes(this);
-        return this;
-    }
-    flipeV(){
-        this.arr = this.arr.reverse();
-        maintain_indexes(this);
-        return this;
-    }
-}
-
-
-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);
-
 class UINode {
     constructor(node){
         this.cache = {
@@ -1894,7 +1082,7 @@ class UINode {
 
 // globalThis.node = (node) => new UINode(node);
 
-function parseQueryParams$2(queryString) {
+function parseQueryParams(queryString) {
     const params = {};
     queryString.replace(/[A-Z0-9]+?=([\w|:|\/\.]*)/gi, (match) => {
         const [key, value] = match.split('=');
@@ -1903,11 +1091,11 @@ function parseQueryParams$2(queryString) {
     return params;
 }
 
-function defineParamsGetter$1(target ){
+function defineParamsGetter(target ){
     Object.defineProperties(target, {
         'QueryParams': {
             get: function() {
-                return parseQueryParams$2(globalThis.location.search.substring(1));
+                return parseQueryParams(globalThis.location.search.substring(1));
             },
             configurable: false,
             enumerable: true 
@@ -1960,9 +1148,9 @@ const __Config__ = {
     default:{
         target:null,
         render:true,
-        math:{
-            mode:"deg"
-        }
+        // math:{
+        //     mode:"deg"
+        // }
     },
     setDefault:function(pairs){
         const keys=Object.keys(pairs);
@@ -1999,219 +1187,24 @@ const __CACHE__ = {
     }
 };
 
-class UseIPC {
-    #channel;
-    #eventData;
-    #handlers;
-    #uuid;
-    #subscribers;
-    #currentRooms;
-    constructor(name = "") {
-        this.#channel = new BroadcastChannel(name);
-        this.#eventData = new Map();
-        this.#handlers = new Map(); // Map<event, Array<{fn, rooms}>>
-        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) => {
-            const { last_sent_event, userId, eventData, rooms } = e.data;
-            if (userId === this.#uuid) return; // ignore own messages
-            // broadcast if no rooms, else check intersection
-            if (rooms && rooms.length && !rooms.some(r => this.#currentRooms.has(r))) return;
-            this.#subscribers.add(userId);
-            this.#eventData = new Map(eventData);
-            const handlersList = this.#handlers.get(last_sent_event);
-            if (!handlersList) return;
-            handlersList.forEach(({ fn, rooms: handlerRooms }) => {
-                // trigger if listener has no room filter, or intersects subscriber rooms
-                if (!handlerRooms || handlerRooms.length === 0 ||
-                    !rooms || rooms.some(r => handlerRooms.includes(r))) {
-                    fn(this.#eventData.get(last_sent_event));
-                }
-            });
-        });
-    }
-
-    emit(event, data, rooms) {
-        this.#eventData.set(event, data);
-        if(typeof rooms === 'string') rooms = [rooms];
-        this.#channel.postMessage({
-            eventData: Array.from(this.#eventData.entries()),
-            last_sent_event: event,
-            userId: this.#uuid,
-            rooms: rooms && rooms.length ? rooms : undefined
-        });
-        return this;
-    }
-    on(event, handler = console.log, rooms) {
-        if (!this.#handlers.has(event)) this.#handlers.set(event, []);
-        if(typeof rooms === 'string') rooms = [rooms];
-        this.#handlers.get(event).push({ fn: handler, rooms });
-        return this;
-    }
-    off(event, handler) {
-        if (!this.#handlers.has(event)) return this;
-        this.#handlers.set(
-            event,
-            this.#handlers.get(event).filter(h => h.fn !== handler)
-        );
-        return this;
-    }
-    once(event, handler, rooms) {
-        const wrapper = (data) => {
-            handler(data);
-            this.off(event, wrapper);
-        };
-        this.on(event, wrapper, rooms);
-        return this;
-    }
-    join(...rooms) {
-        rooms.forEach(r => this.#currentRooms.add(r));
-        return this;
-    }
-    leave(...rooms) {
-        if (!rooms.length) this.#currentRooms.clear();
-        else rooms.forEach(r => this.#currentRooms.delete(r));
-        return this;
-    }
-    close() {
-        this.#channel.close();
-        return this;
-    }
-}
-
-const useIPC = (name) => new UseIPC(name);
-
-class UseStorage {
-  static RESERVED_KEYS = new Set([
-    "cache", "items", "set", "add", "remove", "get", "clear", "onStorageUpdated"
-  ]);
-
-  constructor(storage, globalKey, initialValue, use_channel = true) {
-    this.cache = {
-      storage,
-      globalKey,
-      channel: use_channel ? useIPC(`Ziko:useStorage-${globalKey}`) : null,
-      oldItemKeys: new Set()
-    };
-
-    this.#init(initialValue, use_channel);
-  }
-
-  get items() {
-    const raw = this.cache.storage.getItem(this.cache.globalKey);
-    if (!raw) return {};
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return {};
-    }
-  }
-
-  #maintain() {
-    const currentItems = this.items;
-    const currentKeys = new Set(Object.keys(currentItems));
-
-    // Cleanup keys that were removed
-    this.cache.oldItemKeys.forEach(key => {
-      if (!currentKeys.has(key)) {
-        delete this[key];
-        this.cache.oldItemKeys.delete(key);
-      }
-    });
-
-    // Populate keys from storage onto `this`
-    for (const key in currentItems) {
-      if (!UseStorage.RESERVED_KEYS.has(key)) {
-        this[key] = currentItems[key];
-        this.cache.oldItemKeys.add(key);
-      }
-    }
-  }
-
-  #init(initialValue, use_channel) {
-    if (use_channel && this.cache.channel) {
-      this.cache.channel.on("Ziko-Storage-Updated", () => this.#maintain());
-    }
-
-    const hasStoredData = this.cache.storage.getItem(this.cache.globalKey) !== null;
-
-    if (hasStoredData) {
-      // Key already exists in storage -> Restore data to instance
-      this.#maintain();
-    } else if (initialValue !== undefined) {
-      // Key doesn't exist -> Seed with initialValue
-      this.set(initialValue);
-    } else {
-      // Key doesn't exist and no initialValue provided -> Default to empty
-      this.#maintain();
-    }
-  }
-
-  set(data) {
-    this.cache.storage.setItem(this.cache.globalKey, JSON.stringify(data));
-    if (this.cache.channel) {
-      this.cache.channel.emit("Ziko-Storage-Updated", data);
-    }
-    this.#maintain();
-    return this;
-  }
-
-  add(data) {
-    return this.set({
-      ...this.items,
-      ...data
-    });
-  }
-
-  remove(...keys) {
-    const items = { ...this.items };
-    keys.forEach(key => delete items[key]);
-    return this.set(items);
-  }
-
-  get(key) {
-    return this.items[key];
-  }
-
-  clear() {
-    this.cache.storage.removeItem(this.cache.globalKey);
-    this.#maintain();
-    return this;
-  }
-
-  onStorageUpdated(callback) {
-    if (this.cache.channel) {
-      this.cache.channel.on("Ziko-Storage-Updated", callback);
-    }
-    return this;
-  }
-}
-
-const useLocalStorage = (key, initialValue, use_channel = true) =>
-  new UseStorage(localStorage, key, initialValue, use_channel);
-
-const useSessionStorage = (key, initialValue, use_channel = true) =>
-  new UseStorage(sessionStorage, key, initialValue, use_channel);
-
-var __State__ = {
-    store : new Map(),
-    index : 0,
-    session_storage : null,
-    register: function(state){
-        // if(!import.meta?.env?.SSR && import.meta?.env?.DEV){
-        //     if(!this.session) this.session_storage = useSessionStorage('ziko-state', {})
-        //     const savedValue = this.session_storage.get(this.index)
-        //     if(!savedValue) this.session_storage.add({[this.index] : state.value});
-        //     else state.value = savedValue
-        // }
-        // this.store.set(this.index++, state)
-    },
-    update: function(index, value){
-    //    if(!import.meta?.env?.SSR && import.meta?.env?.DEV){
-    //         this.session_storage.add({[index] : value})
-    //     } 
-    },
+var __State__ = {
+    store : new Map(),
+    index : 0,
+    session_storage : null,
+    register: function(state){
+        // if(!import.meta?.env?.SSR && import.meta?.env?.DEV){
+        //     if(!this.session) this.session_storage = useSessionStorage('ziko-state', {})
+        //     const savedValue = this.session_storage.get(this.index)
+        //     if(!savedValue) this.session_storage.add({[this.index] : state.value});
+        //     else state.value = savedValue
+        // }
+        // this.store.set(this.index++, state)
+    },
+    update: function(index, value){
+    //    if(!import.meta?.env?.SSR && import.meta?.env?.DEV){
+    //         this.session_storage.add({[index] : value})
+    //     } 
+    },
 
 };
 
@@ -2225,7 +1218,7 @@ function __init__global__(){
                     __CACHE__,
                     __PROVIDERS__: {}
                 };
-        defineParamsGetter$1(__Ziko__);
+        defineParamsGetter(__Ziko__);
     }
 }
 
@@ -2267,11 +1260,9 @@ class UIElementCore extends UINode{
       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")
       }
@@ -2314,20 +1305,13 @@ class UIElementCore extends UINode{
       : globalThis.__Ziko__.__UI__[this.cache.name]=[this];
     element && render && this?.render?.();
     globalThis.__Ziko__.__UI__.push(this);
-
-    // console.log({props})
+    
     const parsed_props = parse_props(props);
-
     this.parsed_props = parsed_props;
-
     this.style(parsed_props.style);
     this.setAttr(parsed_props.attrs);
-
     const Events = Object.entries(parsed_props.events);
-
     Events.forEach(([ev, callback]) => this[ev](callback.bind(this)));
-    
-
     if(items.length > 0) this.append(...items);
   }
   get element(){
@@ -2489,14 +1473,11 @@ function useState(initialValue) {
 
 const isStateGetter = (arg) => typeof arg === "function" && arg[STATE_GETTER] === true;
 
-const camel2hyphencase = (text = '') => text.replace(/[A-Z]/g, match => '-' + match.toLowerCase());
-
-const is_camelcase = (text = '') =>{
-    if (text.length === 0) return false; 
-    const camelCasePattern = /^[a-z][a-zA-Z0-9]*$/;
-    return camelCasePattern.test(text);
-};
-
+// import { 
+//   is_camelcase,
+//   camel2hyphencase
+//  } from '../../../data/string/index.js'
+
 function setAttr(name, value) {
   if(name instanceof Object){
     const [names,values]=[Object.keys(name),Object.values(name)];
@@ -2516,7 +1497,7 @@ function removeAttr(...names) {
   return this;
 }
 function getAttr(name){
-  name = is_camelcase(name) ? camel2hyphencase(name) : name;
+  // name = is_camelcase(name) ? camel2hyphencase(name) : name;
   return this.element.attributes[name].value;
 }
 function setContentEditable(bool = true) {
@@ -2569,23 +1550,17 @@ function prepend(...ele) {
 }
 function insertAt(index, ...ele) {
     const target = this.itemsTarget;
-
     if (index >= target.items.length) return this.append(...ele);
-
     for (let i = 0; i < ele.length; i++) {
         if (["number", "string"].includes(typeof ele[i]))
             ele[i] = text(ele[i]);
-
         target.element?.insertBefore(
             ele[i].element,
             target.items[index].element
         );
-
         target.items.splice(index, 0, ele[i]);
     }
-
     target.maintain();
-
     return this;
 }
 function remove(...ele) {
@@ -2608,7 +1583,6 @@ function clear(){
 function replaceElementWith(new_element){
     this.cache.element.replaceWith(new_element);
     this.cache.element = new_element;
-
     // To do : Dispose Events and States 
     return this
 }
@@ -2622,14 +1596,9 @@ function before(ui){
   this.itemsTarget.element?.before(ui);
   return this;
 }
-
-
-
-
 async function __addItem__(adder, pusher, ...ele) {
   const itemsTarget_el = this.itemsTarget.element;
   const itemsTarget = this.itemsTarget;
-
   if (this.cache.isFrozzen) {
     console.warn("You can't append new item to frozzen element");
     return this;
@@ -2639,7 +1608,6 @@ async function __addItem__(adder, pusher, ...ele) {
         // Fix Items Latter
     if (ele[i] instanceof Function) {
       if (isStateGetter(ele[i])) {
-        console.log({s : ele[i]()});
         const getter = ele[i]();
         ele[i] = text(getter.value);
         getter._subscribe(
@@ -3129,7 +2097,7 @@ function register_swipe_event(
   };
 }
 
-let UIElement$1 = class UIElement extends UIElementCore{
+class UIElement extends UIElementCore{
   constructor({element, name ='', type = 'html', render = __Ziko__.__Config__.default.render, props}={}){
     super();
     this.exp = {
@@ -3216,9 +2184,9 @@ let UIElement$1 = class UIElement extends UIElementCore{
   get text(){
     return this.element.textContent;
   }
-  get isBody(){
-    return this.element === globalThis?.document.body;
-  }
+  // get isBody(){
+  //   return this.element === globalThis?.document.body;
+  // }
   get parent(){
     return this.cache.parent;
   }
@@ -3241,7 +2209,7 @@ let UIElement$1 = class UIElement extends UIElementCore{
     return this.element.getBoundingClientRect().left;
   }
 
-};
+}
 
 const is_primitive = (value) => typeof value !== 'object' && typeof value !== 'function' || value === null;
 
@@ -3478,874 +2446,154 @@ const tags = new Proxy({}, {
     if(MathMLTags.includes(tag)) type = 'mathml';
     return (...args) => {
       if(args.length === 0) {
-        return new UIElement$1({element : tag, name : tag, type})
+        return new UIElement({element : tag, name : tag, type})
       }
       if(
         ['string', 'number'].includes(typeof args[0]) 
-        || args[0] instanceof UIElement$1 
+        || args[0] instanceof UIElement 
         || isStateGetter(args[0])
         || args[0] instanceof HTMLElement
-      ) return new UIElement$1({element : tag, name : tag, type}).append(...args);
-      return new UIElement$1({element : tag, type, props : args.shift()}).append(...args)
+      ) return new UIElement({element : tag, name : tag, type}).append(...args);
+      return new UIElement({element : tag, type, props : args.shift()}).append(...args)
     }
   }
 });
 
-function define_wc(name, UI_Constructor, props = {}, { mode = 'open'} = {}) {
-    if (globalThis.customElements?.get(name)) {
-        console.warn(`Custom element "${name}" is already defined`);
-        return;
-    }
-    if(name.search('-') === -1){
-        console.warn(`"${name}" is not a valid custom element name`);
-        return; 
+const linear = t => t;
+
+class TimeAnimation {
+  constructor(callback, { ease = linear, step = 50, t0 = 0, start = true, duration = 3000 } = {}) {
+    this.callback = callback;
+    this.state = {
+      isRunning: false,
+      animationId: null,
+      startTime: null,
+      ease,
+      step,
+    //   interval: [t0, t1],
+      autoStart: start,
+      duration
+    };
+
+    this.t = 0;   // elapsed time
+    this.tx = 0;  // normalized [0,1]
+    this.ty = 0;  // eased value
+    this.i = 0;   // frame index
+
+    if (this.state.autoStart) {
+      this.start();
     }
-    globalThis.customElements?.define(
-        name,
-        class extends HTMLElement {
-            static get observedAttributes() {
-                return ['style', ...Object.keys(props)];
-            }
+  }
 
-            constructor() {
-                super();
-                this.attachShadow({ mode });
-                this.props = {};
-                this.mask = {
-                    ...props,
-                    // style: { type: Object }
-                };
-            }
+  // ---- private loop handler ----
+  #tick = () => {
+    this.t += this.state.step;
+    this.i++;
 
-            connectedCallback() {
-                this.render();
-            }
+    this.tx = map$1(this.t, 0, this.state.duration, 0, 1);
+    this.ty = this.state.ease(this.tx);
 
-            render() {
-                this.shadowRoot.innerHTML = '';
-                const item = UI_Constructor(this.props);
-                if(item instanceof Array) item.forEach(n => n.mount(this.shadowRoot)); 
-                else item.mount(this.shadowRoot);
-            }
+    this.callback(this);
 
-            attributeChangedCallback(name, _, newValue) {
-                Object.assign(this.props, {
-                    [name]: this.mask[name].type(newValue)
-                });
-                this.render();
-            }
-        }
-    );
-}
-
-class UIView extends UIElement$1{
-    constructor(...items){
-        super({element : 'div', name : 'view'});
-        this.append(...items);
+    if (this.t >= this.state.duration) {
+      clearInterval(this.state.animationId);
+      this.state.isRunning = false;
     }
-}
+  };
 
-const View = (...items) => new UIView(...items);
-
-function set_vertical(direction){
-  direction == 1
-    ? this.style({ flexDirection: "column" })
-    : direction == -1 && this.style({ flexDirection: "column-reverse" });
-  return this;
-}
-function set_horizontal(direction){
-    direction == 1
-        ? this.style({ flexDirection: "row" })
-        : direction == -1 && this.style({ flexDirection: "row-reverse" });
-    return this;
-}
-function map_pos_x(align){
-    let pos = ["flex-start", "center", "flex-end"];
-    if (typeof align === "number") align = pos[align + 1];
-    return align;
-}
-function map_pos_y(align){
-    return map_pos_x(-align);
-}
-
-class UIFlex extends UIElement$1 {
-  constructor({tag = "div", orientation = "h", order, w = "100%", h = "100%"} = {}) {
-    super({element : tag , name : "Flex"});
-    this.direction = "cols";
-    this.style({ display: "flex" });
-    // this.mount();
-  }
-  isFlex(){
-    return true;
-  }
-  responsify(respBreakPoint, wrap = true) {
-    this.wrap(wrap);
-    if (this.element.clientWidth < respBreakPoint) this.vertical();
-    else this.horizontal();
+  // ---- core runner ----
+  #run(reset = true) {
+    if (!this.state.isRunning) {
+      if (reset) this.reset(false);
+
+      this.state.isRunning = true;
+      this.state.startTime = Date.now();
+      this.state.animationId = setInterval(this.#tick, this.state.step);
+    }
     return this;
   }
-  setSpaceAround() {
-    this.style({ justifyContent: "space-around" });
-    return this;
+
+  // ---- lifecycle methods ----
+  start() {
+    return this.#run(true);
   }
-  setSpaceBetween() {
-    this.style({ justifyContent: "space-between" });
+
+  pause() {
+    if (this.state.isRunning) {
+      clearInterval(this.state.animationId);
+      this.state.isRunning = false;
+    }
     return this;
   }
-  setBaseline() {
-    this.style({ alignItems: "baseline" });
-    return this;
+
+  resume() {
+    return this.#run(false);
   }
-  gap(g) {
-    if (this.direction === "row") this.style({ columnGap: g });
-    else if (this.direction === "column") this.style({ rowGap: g });
+
+  stop() {
+    this.pause();
+    this.reset(false);
     return this;
   }
-  wrap(value = "wrap") {
-    const values = ["no-wrap", "wrap","wrap-reverse"];
-    this.style({
-      flexWrap: typeof value === "string" ? value : values[+value],
-    });
+
+  reset(restart = true) {
+    this.t = 0;
+    this.tx = 0;
+    this.ty = 0;
+    this.i = 0;
+
+    if (restart) this.start();
     return this;
   }
-  _justifyContent(align = "center") {
-    this.style({ justifyContent: align });
-    return this;
+}
+
+// Hook-style factory
+const animation = (callback, {ease, t0, t1, start, duration} = {}) =>
+  new TimeAnimation(callback, {ease, t0, t1, start, duration});
+
+class Tick {
+  constructor(fn, ms, count = Infinity, start) {
+    this.ms = ms;
+    this.fn = fn;
+    this.count = count;
+    this.frame = 1;
+    this.id = null;
+    this.running = false;
+    if(start) this.start();
   }
-  // verticalize
-  vertical(x, y, order = 1) {
-    set_vertical.call(this, order);
-    this.style({
-      alignItems: typeof(x)==="number"?map_pos_x.call(this,x):x,
-      justifyContent: typeof(y)=="number"?map_pos_y.call(this,y):y
-    });
+
+  start() {
+    if (!this.running) {
+      this.running = true;
+      this.frame = 1;
+      this.id = setInterval(() => {
+        if (this.frame > this.count) {
+          this.stop();
+          return;
+        }
+        this.fn.call(null, this);
+        this.frame++;
+      }, this.ms);
+    }
     return this;
   }
-  // horizontalize
-  horizontal(x, y, order = 1) {
-    set_horizontal.call(this, order);
-    this.style({
-      alignItems: typeof(y)=="number"?map_pos_y.call(this,y):y,
-      justifyContent: typeof(x)==="number"?map_pos_x.call(this,x):x
-    });
+
+  stop() {
+    if (this.running) {
+      this.running = false;
+      clearInterval(this.id);
+      this.id = null;
+    }
     return this;
   }
-  show() {
-    this.isHidden = false;
-    this.style({ display: "flex" });
-    return this;
+
+  isRunning() {
+    return this.running;
   }
 }
 
-const Flex = (...UIElement) =>{
-  let tag="div";
-  if(typeof UIElement[0]==="string"){
-    tag=UIElement[0];
-    UIElement.pop();
-  }
-  return new UIFlex(tag).append(...UIElement);
-};
-
-class UIElement extends UIElementCore{
-    constructor({element, name, type, render}){
-        super({element, name, type, render});
-    }
-}
-
-class UISuspense extends UIElement{
-    constructor(fallback_ui, callback){
-        super({element : "div", name : "suspense"});
-        this.setAttr({
-            dataTemp : "suspense"
-        });
-        this.fallback_ui = fallback_ui;
-        this.append(fallback_ui);
-        (async ()=>{
-            try{
-                const ui = await callback();
-                fallback_ui.unmount();
-                this.append(ui);
-            }
-            catch(error){
-                console.log({error});
-            }
-        })();
-    }
-}
-
-const Suspense = (fallback_ui, callback) => new UISuspense(fallback_ui, callback);
-
-class UISwap extends UIElement$1 {
-    #DISPLAYS_MAP = new WeakMap()
-    constructor({ activeIndex = 0 } = {}, ...items) {
-        super({ element: 'div' });
-        this.style({ display: 'contents' });
-        
-        this.states = {
-            activeIndex
-        };
-        
-        this.append(...items);
-        requestAnimationFrame(() => {
-            this.render();
-        });
-    }
-    get activeItem(){
-        return this.items[this.states.activeIndex]
-    }
-    render() {
-        this.items.forEach((n, i) => {
-
-            const initialDisplay = getComputedStyle(n.element).display;
-            this.#DISPLAYS_MAP.set(n, initialDisplay);
-
-            if (i !== this.states.activeIndex) {
-                n.style({ display: 'none' });
-            }
-        });
-    }
-    get DS(){
-        return this.#DISPLAYS_MAP
-    }
-    next(n = 1) {
-        return this.activate(this.states.activeIndex + n);
-    }
-    previous(n = 1) {
-        return this.activate(this.states.activeIndex - n);
-    }
-    activate(index) {
-        if (!this.items.length) return this;
-
-        const currentItem = this.items.at(this.states.activeIndex);
-
-        if (currentItem) {
-            currentItem.style({ display: 'none' });
-        }
-
-        const len = this.items.length;
-        this.states.activeIndex = ((index % len) + len) % len;
-
-        const activeItem = this.items.at(this.states.activeIndex);
-        if (activeItem) {
-            const restoredDisplay = this.#DISPLAYS_MAP.get(activeItem) || 'block';
-            activeItem.style({ display: restoredDisplay === 'none' ? 'block' : restoredDisplay });
-        }
-
-        return this;
-    }
-}
-
-const Swap = call_with_optional_props(UISwap);
-
-class UIFragment extends UIElement$1{
-    constructor(...items){
-        super({ element : document.createDocumentFragment()});
-        this.append(...items);
-    }
-    isFragment(){
-        return true
-    }
-}
-
-const Fragment = (...items) => new UIFragment(...items);
-
-class UIFor extends UIFragment{
-    constructor({each, fallback, mapFn = () => {}} = {}){
-        super();
-        this.config = {
-            each,
-            fallback,
-            mapFn
-        };
-        this.append(
-            ...this.config.each.map((n,i) => this.config.mapFn(n, i))
-        );
-    }
-}
-
-const For = ({each, fallback, mapFn} = {}) => new UIFor({each, fallback, mapFn});
-
-class UISwitch extends UIElement$1{
-    constructor(key, cases){
-        super();
-        this.key = key; 
-        this.cases = cases;
-        this.init();
-    }
-    init(){
-        Object.values(this.cases).filter(n=>n != this.current).forEach(n=>n.unmount());
-        super.init(this.current.element);
-    }
-    get current(){
-        const matched = Object.keys(this.cases).find(n => n == this.key) ?? 'default';
-        return this.cases[matched]
-    }
-    updateKey(key){
-        this.key = key;
-        this.replaceElementWith(this.current.element);
-        // this.cache.element.replaceWith(this.current.element)
-        // this.cache.element = this.current.element;
-        return this;
-    }
-    
-}
-
-const Switch=({key, cases})=> new UISwitch(key, cases);
-
-// export const Switch=({key, cases}) => {
-//     const matched = Object.keys(cases).find(n => n == key) ?? 'default';
-//     return this.cases[matched]()
-// }
-
-class UIHTMLWrapper extends UIElement$1 {
-    constructor(content){
-        super({element : 'div', name : 'html_wrappper'});
-        this.element.append(html2dom(content));
-        this.style({
-            display : 'contents'
-        });
-    }
-}
-
-function html2dom(htmlString) {
-    if(globalThis?.DOMParser){
-        const parser = new DOMParser();
-        const doc = parser.parseFromString(`<div>${htmlString}</div>`, 'text/html');
-        doc.body.firstChild.style.display = "contents";
-        return doc.body.firstChild;
-    }
-}
-
-const HTMLWrapper = (content) => new UIHTMLWrapper(content);
-
-class UISVGWrapper extends UIElement$1 {
-    constructor(content){
-        super({element : 'div', name : 'html_wrappper'});
-        this.element.append(svg2dom(content));
-        this.style({
-            display : 'contents'
-        });
-    }
-}
-
-function svg2dom(svgString) {
-  if (typeof DOMParser !== "undefined") {
-    const parser = new DOMParser();
-    const doc = parser.parseFromString(svgString.trim(), "image/svg+xml");
-    const svg = doc.documentElement;
-
-    if (svg.nodeName === "parsererror") {
-      throw new Error("Invalid SVG string");
-    }
-    if(svg.hasAttribute('xmlns')) return svg
-    // TO Fix ...
-    const {children, attributes} = svg;
-    const element = document.createElementNS("http://www.w3.org/2000/svg", "svg");
-    for(let {name, value} of attributes){
-      element.setAttribute(name, value);
-    }
-    element.append(...children);
-
-    globalThis.svg = svg;
-    globalThis.children = children; 
-    globalThis.attributes = attributes;
-    globalThis.element = element;
-    return element;
-  }
-  throw new Error("DOMParser is not available in this environment");
-}
-
-
-
-const SVGWrapper = (content) => new UISVGWrapper(content);
-
-class UICanvas extends UIElement$1{
-    constructor(w,h){
-        super("canvas","canvas");
-        this.ctx = this.element?.getContext("2d");
-        this.style({
-            border:"1px red solid",
-        });
-        this.transformMatrix = new Matrix([
-            [1,0,0],
-            [0,1,0],
-            [0,0,1]
-        ]);
-        this.axisMatrix = new Matrix([
-            [-10,-10],
-            [10,10]
-        ]);
-        // setTimeout(()=>this.resize(w,h),0);
-        requestAnimationFrame(()=>this.resize(w,h),0);
-        this.on("sizeupdated",()=>this.adjust());
-    }
-    get Xmin(){
-        return this.axisMatrix[0][0];
-    }
-    get Ymin(){
-        return this.axisMatrix[0][1];
-    }
-    get Xmax(){
-        return this.axisMatrix[1][0];
-    }
-    get Ymax(){
-        return this.axisMatrix[1][1];
-    }
-    get ImageData(){
-        return this.ctx.getImageData(0,0,c.Width,c.Height);
-    }
-    draw(all=true){
-        if(all){
-            this.clear();  
-            this.items.forEach(element => {
-                element.parent=this;
-                element.draw(this.ctx);
-            });
-        }
-        else {
-            this.items.at(-1).parent=this;
-            this.items.at(-1).draw(this.ctx);
-        }
-        this.maintain();
-        return this;
-    }
-    applyTransformMatrix(){
-        this.ctx.setTransform(
-            this.transformMatrix[0][0],
-            this.transformMatrix[1][0],
-            this.transformMatrix[0][1],
-            this.transformMatrix[1][1],
-            this.transformMatrix[0][2],
-            this.transformMatrix[1][2],
-        );
-        return this;
-    }
-    resize(w,h){
-        this.size(w,h);
-        this.lineWidth();
-        this.view(this.axisMatrix[0][0], this.axisMatrix[0][1], this.axisMatrix[1][0], this.axisMatrix[1][1]);
-        this.emit("sizeupdated");
-        return this;
-    }
-    adjust(){
-        this.element.width =this.element?.getBoundingClientRect().width;
-        this.element.height =this.element?.getBoundingClientRect().height;
-        this.view(this.axisMatrix[0][0], this.axisMatrix[0][1], this.axisMatrix[1][0], this.axisMatrix[1][1]);
-        return this;
-    }
-    view(xMin,yMin,xMax,yMax){
-        this.transformMatrix[0][0]=this.width/(xMax-xMin); // scaleX
-        this.transformMatrix[1][1]=-this.height/(yMax-yMin); // scaleY
-        this.transformMatrix[0][2]=this.width/2;
-        this.transformMatrix[1][2]=this.height/2;
-        this.axisMatrix=new Matrix([
-            [xMin,yMin],
-            [xMax,yMax]
-        ]);
-        
-        this.applyTransformMatrix(); 
-        this.clear();
-        this.lineWidth(1);
-        this.draw();
-        return this;
-    }
-    reset(){
-        this.ctx.setTransform(1,0,0,0,0,0);
-        return this;
-    }
-    append(element){
-        this.items.push(element);
-        this.draw(false);
-        return this;
-    }
-    background(color){
-        this.ctx.fillStyle = color;
-        this.ctx.setTransform(1, 0, 0, 1, 0, 0);
-        this.ctx.fillRect(0, 0, this.width, this.height);
-        this.applyTransformMatrix();
-        this.draw();
-    }
-    lineWidth(w){
-        this.ctx.lineWidth=w/this.transformMatrix[0][0];
-        return this
-    }
-    getImageData(x=0,y=0,w=this.width,h=this.height){
-        return this.ctx.getImageData(x,y,w,h);
-    }
-    clear(){
-        this.ctx.setTransform(1, 0, 0, 1, 0, 0);
-        this.ctx.clearRect(0, 0, this.width, this.height);
-        this.applyTransformMatrix(); 
-        return this;
-    }
-    clone(){
-        console.log(this.width);
-        const canvas=new UICanvas();
-        canvas.items=this.items;
-        canvas.transformMatrix=this.transformMatrix;
-        canvas.axisMatrix=this.axisMatrix;
-        Object.assign(canvas.cache,{...this.cache});
-        //waitForUIElm(this)
-        //console.log(element)
-        this.size(this.element.style.width,this.element.style.width);
-        this.applyTransformMatrix();
-        this.draw();
-        this.adjust();
-        return canvas;
-    }
-    toImage() {
-        this.img = document?.createElement("img");
-        this.img.src = this.element?.toDataURL("image/png");
-        return this;
-    }
-    toBlob() {
-        var canvas = this.element;
-        canvas.toBlob(function (blob) {
-            var newImg = document?.createElement("img"),
-                url = URL.createObjectURL(blob);
-            newImg.onload = function () {
-                URL.revokeObjectURL(url);
-            };
-            newImg.src = url;
-            console.log(newImg);
-        });
-    }
-    zoomIn(){
-
-    }
-    zoomOut(){
-        
-    }
-    undo(n){
-
-    }
-    redo(n){
-
-    }
-    stream(){
-
-    }
-}
-
-const Canvas=(w,h)=>new UICanvas(w,h);
-
-class UISvg extends UIElement$1 {
-    constructor(w=360,h=300) {
-      super("svg","svg");
-      //this.cache={};
-      // this.setAttr("width",w);
-      // this.setAttr("height",h);
-      // this.setAttr({
-      //   width : w,
-      //   height : h
-      // })
-      this.style({border:"1px black solid"});
-      //this.view(-w/2,-h/2,w/2,h/2);
-      this.size(w, h);
-      this.view(-10,-10,10,10);
-    }
-    size(w, h){
-      this.setAttr({
-        width : w,
-        height : h
-      });
-      return this
-    }
-    view(x1,y1,x2,y2){
-      let width=Math.abs(x2-x1);
-      let height=Math.abs(y2-y1);
-      this.setAttr("viewBox",[x1,y1,width,height].join(" "));
-      this.st.scaleY(-1);
-      return this;
-    }
-    add(...svgElement){
-      for(let i=0;i<svgElement.length;i++){
-        this.element.append(svgElement[i].element);
-        this.items.push(svgElement[i]);
-      }
-      this.maintain();
-      return this;
-    }
-    remove(...svgElement){
-      for(let i=0;i<svgElement.length;i++){
-        this.element?.removeChild(svgElement[i].element);
-        this.items=this.items.filter(n=>!svgElement);
-      }
-      this.maintain();
-      return this;     
-    }
-    mask(){
-  
-    }
-    toString(){
-      return  (new XMLSerializer()).serializeToString(this.element);
-    }
-    btoa(){
-      return btoa(this.toString())
-    }
-    toImg(){
-      return 'data:image/svg+xml;base64,'+this.btoa()
-    }
-    toImg2(){
-      return "data:image/svg+xml;charset=utf8,"+this.toString().replaceAll("<","%3C").replaceAll(">","%3E").replaceAll("#","%23").replaceAll('"',"'");
-    }
-    
-  }
-
-  const Svg =(w,h)=>new UISvg(w,h);
-
-const { PI, sqrt: sqrt$1, cos: cos$2, sin: sin$2, acos, pow } = Math;
-
-const linear = t => t;
-
-// --- Sin ---
-const in_sin = t => 1 - cos$2((t * PI) / 2);
-const out_sin = t => sin$2((t * PI) / 2);
-const in_out_sin = t => -(cos$2(PI * t) - 1) / 2;
-
-// --- Quad ---
-const in_quad = t => t ** 2;
-const out_quad = t => 1 - (1 - t) ** 2;
-const in_out_quad = t =>
-    t < 0.5 ? 2 * (t ** 2) : 1 - (-2 * t + 2) ** 2 / 2;
-
-// --- Cubic ---
-const in_cubic = t => t ** 3;
-const out_cubic = t => 1 - (1 - t) ** 3;
-const in_out_cubic = t =>
-    t < 0.5 ? 4 * (t ** 3) : 1 - (-2 * t + 2) ** 3 / 2;
-
-// --- Quart ---
-const in_quart = t => t ** 4;
-const out_quart = t => 1 - (1 - t) ** 4;
-const in_out_quart = t =>
-    t < 0.5 ? 8 * (t ** 4) : 1 - (-2 * t + 2) ** 4 / 2;
-
-// --- Quint ---
-const in_quint = t => t ** 5;
-const out_quint = t => 1 - (1 - t) ** 5;
-const in_out_quint = t =>
-    t < 0.5 ? 16 * (t ** 5) : 1 - (-2 * t + 2) ** 5 / 2;
-
-// --- Expo ---
-const in_expo = t => (t === 0 ? 0 : 2 ** (10 * t - 10));
-const out_expo = t => (t === 1 ? 1 : 1 - 2 ** (-10 * t));
-const in_out_expo = t =>
-    t === 0
-        ? 0
-        : t === 1
-        ? 1
-        : t < 0.5
-        ? 2 ** (20 * t - 10) / 2
-        : (2 - 2 ** (-20 * t + 10)) / 2;
-
-// --- Circ ---
-const in_circ = t => 1 - sqrt$1(1 - t ** 2);
-const out_circ = t => sqrt$1(1 - (t - 1) ** 2);
-const in_out_circ = t =>
-    t < 0.5
-        ? (1 - sqrt$1(1 - (2 * t) ** 2)) / 2
-        : (sqrt$1(1 - (-2 * t + 2) ** 2) + 1) / 2;
-
-// --- Arc ---
-const arc = t => 1 - sin$2(acos(t));
-
-// --- Back ---
-const back = (t, x = 1) => (t ** 2) * ((x + 1) * t - x);
-
-// --- Elastic ---
-const elastic = t =>
-    -2 * pow(2, 10 * (t - 1)) * cos$2((20 * PI * t) / 3 * t);
-
-// --- Back variations ---
-const in_back = (t, c1 = 1.70158, c3 = c1 + 1) =>
-    c3 * pow(t, 3) - c1 * (t ** 2);
-
-const out_back = (t, c1 = 1.70158, c3 = c1 + 1) =>
-    1 + c3 * pow(t - 1, 3) + c1 * pow(t - 1, 2);
-
-const in_out_back = (t, c1 = 1.70158, c2 = c1 * 1.525) =>
-    t < 0.5
-        ? (pow(2 * t, 2) * ((c2 + 1) * 2 * t - c2)) / 2
-        : (pow(2 * t - 2, 2) * ((c2 + 1) * (t * 2 - 2) + c2) + 2) / 2;
-
-// --- Elastic variations ---
-const in_elastic = (t, c4 = (2 * PI) / 3) =>
-    t === 0
-        ? 0
-        : t === 1
-        ? 1
-        : -pow(2, 10 * t - 10) * sin$2((t * 10 - 10.75) * c4);
-
-const out_elastic = (t, c4 = (2 * PI) / 3) =>
-    t === 0
-        ? 0
-        : t === 1
-        ? 1
-        : pow(2, -10 * t) * sin$2((t * 10 - 0.75) * c4) + 1;
-
-const in_out_elastic = (t, c5 = (2 * PI) / 4.5) =>
-    t === 0
-        ? 0
-        : t === 1
-        ? 1
-        : t < 0.5
-        ? -(pow(2, 20 * t - 10) * sin$2((20 * t - 11.125) * c5)) / 2
-        : (pow(2, -20 * t + 10) * sin$2((20 * t - 11.125) * c5)) / 2 + 1;
-
-// --- Bounce ---
-const in_bounce = (t, n1 = 7.5625, d1 = 2.75) =>
-    1 - out_bounce(1 - t, n1, d1);
-
-const out_bounce = (t, n1 = 7.5625, d1 = 2.75) => {
-    if (t < 1 / d1) return n1 * t * t;
-    if (t < 2 / d1) return n1 * (t -= 1.5 / d1) * t + 0.75;
-    if (t < 2.5 / d1) return n1 * (t -= 2.25 / d1) * t + 0.9375;
-    return n1 * (t -= 2.625 / d1) * t + 0.984375;
-};
-
-const in_out_bounce = (t, n1 = 7.5625, d1 = 2.75) =>
-    t < 0.5
-        ? out_bounce(1 - 2 * t, n1, d1) / 2
-        : out_bounce(2 * t - 1, n1, d1) / 2;
-
-// --- Step / Discrete ---
-const step = (t, steps = 5) => Math.floor(t * steps) / steps;
-const discret = (t, segments = 5) => Math.ceil(t * segments) / segments;
-
-class TimeAnimation {
-  constructor(callback, { ease = linear, step = 50, t0 = 0, start = true, duration = 3000 } = {}) {
-    this.callback = callback;
-    this.state = {
-      isRunning: false,
-      animationId: null,
-      startTime: null,
-      ease,
-      step,
-    //   interval: [t0, t1],
-      autoStart: start,
-      duration
-    };
-
-    this.t = 0;   // elapsed time
-    this.tx = 0;  // normalized [0,1]
-    this.ty = 0;  // eased value
-    this.i = 0;   // frame index
-
-    if (this.state.autoStart) {
-      this.start();
-    }
-  }
-
-  // ---- private loop handler ----
-  #tick = () => {
-    this.t += this.state.step;
-    this.i++;
-
-    this.tx = map$1(this.t, 0, this.state.duration, 0, 1);
-    this.ty = this.state.ease(this.tx);
-
-    this.callback(this);
-
-    if (this.t >= this.state.duration) {
-      clearInterval(this.state.animationId);
-      this.state.isRunning = false;
-    }
-  };
-
-  // ---- core runner ----
-  #run(reset = true) {
-    if (!this.state.isRunning) {
-      if (reset) this.reset(false);
-
-      this.state.isRunning = true;
-      this.state.startTime = Date.now();
-      this.state.animationId = setInterval(this.#tick, this.state.step);
-    }
-    return this;
-  }
-
-  // ---- lifecycle methods ----
-  start() {
-    return this.#run(true);
-  }
-
-  pause() {
-    if (this.state.isRunning) {
-      clearInterval(this.state.animationId);
-      this.state.isRunning = false;
-    }
-    return this;
-  }
-
-  resume() {
-    return this.#run(false);
-  }
-
-  stop() {
-    this.pause();
-    this.reset(false);
-    return this;
-  }
-
-  reset(restart = true) {
-    this.t = 0;
-    this.tx = 0;
-    this.ty = 0;
-    this.i = 0;
-
-    if (restart) this.start();
-    return this;
-  }
-}
-
-// Hook-style factory
-const animation = (callback, {ease, t0, t1, start, duration} = {}) =>
-  new TimeAnimation(callback, {ease, t0, t1, start, duration});
-
-class Tick {
-  constructor(fn, ms, count = Infinity, start) {
-    this.ms = ms;
-    this.fn = fn;
-    this.count = count;
-    this.frame = 1;
-    this.id = null;
-    this.running = false;
-    if(start) this.start();
-  }
-
-  start() {
-    if (!this.running) {
-      this.running = true;
-      this.frame = 1;
-      this.id = setInterval(() => {
-        if (this.frame > this.count) {
-          this.stop();
-          return;
-        }
-        this.fn.call(null, this);
-        this.frame++;
-      }, this.ms);
-    }
-    return this;
-  }
-
-  stop() {
-    if (this.running) {
-      this.running = false;
-      clearInterval(this.id);
-      this.id = null;
-    }
-    return this;
-  }
-
-  isRunning() {
-    return this.running;
-  }
-}
-
-// Helper factory
-const tick = (fn, ms, count = Infinity, start = true) => new Tick(fn, ms, count, start);
+// Helper factory
+const tick = (fn, ms, count = Infinity, start = true) => new Tick(fn, ms, count, start);
 
 class Clock extends Tick {
   constructor(tickMs = 1000 / 60) {
@@ -4648,461 +2896,39 @@ const timeTaken = callback => {
     return r;
 };
 
-const csv2arr = (csv, delimiter = ",")=>csv.trim().trimEnd().split("\n").map(n=>n.split(delimiter));
-const csv2matrix = (csv, delimiter = ",")=>new Matrix(csv2arr(csv,delimiter));
-const csv2object = (csv, delimiter = ",") => {
-    const [header, ...rows] = csv2arr(csv,delimiter);
-    const result = rows.map(row => {
-        const obj = {};
-        header.forEach((key, index) => {
-            obj[key] = row[index];
-        });
-        return obj;
-    });
-    return result;
-};
-const csv2json = (csv, delimiter = ",") => JSON.stringify(csv2object(csv,delimiter));
-const csv2sql=(csv, Table)=>{
-    const sanitizeId = s => s.trim().replace(/[^a-zA-Z0-9_]/g, '');
-    const escapeVal = s => "'" + s.trim().replace(/'/g, "''") + "'";
-    const lines = csv.trim().trimEnd().split('\n').filter(n=>n);
-    const columns = lines[0].split(',').map(sanitizeId);
-    let sqlQuery = "INSERT INTO " + sanitizeId(Table) + " (" + columns.join(', ') + ") Values ";
-    let sqlValues = [];
-    for (let i = 1; i < lines.length; i++) {
-      const values = lines[i].split(',').map(escapeVal);
-      sqlValues.push("(" + values.join(', ') + ")");
-    }
-    return sqlQuery+sqlValues.join(",\n");
-  };
-
-const _objects2arr=data=>data instanceof Array?[Object.keys(data[0]),...data.map(n=>Object.values(n))]:[Object.keys(data)];
-const _objects2csv=(data,delimiter)=>_objects2arr(data).map(n=>n.join(delimiter)).join("\n");
-const json2arr=json=>json instanceof Object?_objects2arr(json):_objects2arr(JSON.parse(json));
-const json2csv=(json,delimiter=",")=>json instanceof Object?_objects2csv(json,delimiter):_objects2csv(JSON.parse(json),delimiter);
-const json2csvFile=(json,delimiter)=>{
-    const str=json2csv(json,delimiter);
-    const blob=new Blob([str], { type: 'text/csv;charset=utf-8;' });
-    return {
-       str,
-       blob,
-       url:URL.createObjectURL(blob)
-    }
-};
-const _processObject=(obj, indent)=>{
-    const yml = [];
-    if (Array.isArray(obj)) {
-        obj.forEach(item => {
-            if (typeof item === 'object' && item !== null) {
-                yml.push(`${indent}-`);
-                const nestedLines = _processObject(item, `${indent}  `);
-                yml.push(...nestedLines);
-            } else yml.push(`${indent}- ${item}`);
-        });
-    } else {
-        for (const key in obj) {
-            if (obj.hasOwnProperty(key)) {
-                const value = obj[key];
-                if (typeof value === 'object' && value !== null) {
-                    yml.push(`${indent}${key}:`);
-                    const nestedLines = _processObject(value, `${indent}  `);
-                    yml.push(...nestedLines);
-                } else {
-                    yml.push(`${indent}${key}: ${value}`);
-                }
-            }
-        }
-    }
-    return yml;
-};
-const _object2yml=(object,indent="")=>_processObject(object,indent).join('\n');
-const json2yml=(json,indent)=>json instanceof Object?_object2yml(json,indent):_object2yml(JSON.parse(json),indent);
-const json2ymlFile=(json,indent)=>{
-    const str=json2yml(json,indent);
-    const blob=new Blob([str], { type: 'text/yml;charset=utf-8;' });
-    return {
-       str,
-       blob,
-       url:URL.createObjectURL(blob)
-    }
-};
-const json2xml=(json, indent = 1)=>{
-    let xml = '';
-    for (const key in json) {
-      if (json.hasOwnProperty(key)) {
-        const value = json[key];
-        xml += '\n' + ' '.repeat(indent) + `<${key}>`;
-        (typeof value === 'object') ? xml += json2xml(value, indent + 2) : xml += `${value}`;
-        xml += `</${key}>`;
-      }
-    }
-    return xml.trim();
-  };
-const json2xmlFile=(json,indent)=>{
-    const str=json2xml(json,indent);
-    const blob=new Blob([str], { type: 'text/xml;charset=utf-8;' });
-    return {
-       str,
-       blob,
-       url:URL.createObjectURL(blob)
-    }
-};
-
-const svg2str=svg=>(new XMLSerializer()).serializeToString(svg);
-const svg2ascii=svg=>btoa(svg2str(svg));
-const svg2imgUrl=svg=>'data:image/svg+xml;base64,'+svg2ascii(svg);
-const svg2img=(svg,render=true)=>tags.img(svg2imgUrl(svg)).mount(render);
-
-const json2css=(json, indentLevel = 0)=>{
-    json = trimKeys(json);
-    let cssText = '';
-    const indent = '  '.repeat(indentLevel); 
-
-    for (let selector in json) {
-        if (typeof json[selector] === 'object') {
-            cssText += `${indent}${selector} {\n`;
-            const properties = json[selector];
-            for (let property in properties) {
-                if (typeof properties[property] === 'object') {
-                    cssText += json2css({ [property]: properties[property] }, indentLevel + 1);
-                } else {
-                    cssText += `${indent}  ${property.replace(/[A-Z]/g, match => '-' + match.toLowerCase())}: ${properties[property]};\n`;
-                }
-            }
-
-            cssText += `${indent}}\n`; 
-        }
-    }
-
-    return cssText;
-};
-function trimKeys(obj) {
-    if (typeof obj !== 'object' || obj === null) {
-        return obj; 
-    }
-
-    return Object.keys(obj).reduce((acc, key) => {
-        const trimmedKey = key.trim();
-        acc[trimmedKey] = trimKeys(obj[key]);
-        return acc;
-    }, Array.isArray(obj) ? [] : {});
-}
-
-function parseXML(xmlString) {
-    const parser = new DOMParser();
-    const xmlDoc = parser.parseFromString(xmlString, 'text/xml');
-    const rootNode = xmlDoc.documentElement;
-    const result = parseNode(rootNode);
-    return result;
-  }
-  
-  function parseNode(node) {
-    const obj = {
-      type: node.nodeName,
-      attributes: {},
-      children: []
-    };
-    for (let i = 0; i < node.attributes.length; i++) {
-      const attr = node.attributes[i];
-      obj.attributes[attr.name] = attr.value;
-    }
-    for (let i = 0; i < node.childNodes.length; i++) {
-      const child = node.childNodes[i];
-      if (child.nodeType === Node.ELEMENT_NODE) {
-        obj.children.push(parseNode(child));
-      } else if (child.nodeType === Node.TEXT_NODE) {
-        obj.text = child.textContent.trim();
-      }
-    }
-    return obj;
-  }
-
-// import { ZikoHead , useHead} from "../reactivity/hooks/head/index.js";
-class ZikoApp {
-    constructor({head = null, wrapper = null, target = null}){
-        this.head = head;
-        this.wrapper = wrapper;
-        this.target = target;
-        this.init();        
-    }
-    get isZikoApp(){
-        return true;
-    }
-    init(){
-        this.head && this.setHead(this.head);
-        this.wrapper && this.setWrapper(this.wrapper);
-        this.target && this.setTarget(this.target);
-        if(this.wrapper && this.target)this.wrapper.mount(this.target);
-    }
-    setTarget(target){
-        if(target instanceof HTMLElement) this.target = target;
-        else if (typeof target === "string") this.target = globalThis?.document?.querySelector(target);
-        return this;
-    }
-    setWrapper(wrapper){
-        if(wrapper?.isUIElement) this.wrapper = wrapper;
-        else if(typeof wrapper === "function") this.wrapper = wrapper();
-        return this;
-    }
-    // setHead(head){
-    //     if(head instanceof ZikoHead) this.head = head;
-    //     else this.head = useHead(head);
-    //     return this;  
-    // }
-    
-}
-const App = ({head, wrapper, target}) => new ZikoApp({head, wrapper, target});
-
-function routesMatcher(mask, route) {
-    const maskSegments = mask.split('/');
-    const routeSegments = route.split('/');
-    if (maskSegments.length !== routeSegments.length) {
-        return false;
-    }
-    for (let i = 0; i < maskSegments.length; i++) {
-        const maskSegment = maskSegments[i];
-        const routeSegment = routeSegments[i];
-        if (maskSegment.startsWith(':')) {
-            continue;
-        } else if (maskSegment !== routeSegment) {
-            return false;
-        }
-    }    
-    return true;
-}
-function dynamicRoutesParser(mask, route) {
-    const maskSegments = mask.split('/');
-    const routeSegments = route.split('/');
-    const params = {};
-    if (maskSegments.length !== routeSegments.length) {
-        return params; 
-    }
-    for (let i = 0; i < maskSegments.length; i++) {
-        const maskSegment = maskSegments[i];
-        const routeSegment = routeSegments[i];
-        if (maskSegment.startsWith(':')) {
-            const paramName = maskSegment.slice(1); 
-            params[paramName] = routeSegment;
-        } else if (maskSegment !== routeSegment) {
-            return {};
-        }
-    }
-    return params;
-}
+function useDerived(deriveFn, sources) {
+    const getValue = () => deriveFn(...sources.map(source => source().value));
 
-function isDynamic(path) {
-    const DynamicPattern = /:\w+/;    
-    return DynamicPattern.test(path);
-  }
+    let value = getValue();
+    const subscribers = new Set();
 
-// // Example usage:
-// const mask = "app/lang/:lang/id/:id";
-// const route = "app/lang/en/id/7";
-// console.log(dynamicRoutesParser(mask, route)); // Should return { lang: "en", id: "7" }
-
-class ZikoSPA extends ZikoApp{
-    constructor({head, wrapper, target, routes}){
-        super({head, wrapper, target});
-        this.routes=new Map([
-            ["404",text("Error 404")],
-            ...Object.entries(routes)
-        ]);
-        this.clear();
-        globalThis.onpopstate = this.mount(location.pathname);
-    }
-    clear(){
-        [...this.routes].forEach(n=>{
-            !isDynamic(n[0]) && n[1]?.isUIElement && n[1].unmount();
-        });   
-        // this.wrapper.clear();
-        return this;
-    }
-    mount(path){
-        const [mask, callback] = [...this.routes].find(route=>routesMatcher(route[0],path));
-        let element ;
-        if(isDynamic(mask)){
-            const params = dynamicRoutesParser(mask, path);
-            element = callback.call(this,params);
-        }
-        else {
-            callback?.isUIElement && callback.mount(this.wrapper); 
-            if(typeof callback === "function") element = callback();  
-        }
-        if(element?.isUIElement) element.mount(this.wrapper);
-        // if(element?.isZikoApp) element.mount(this.wrapper);
-        if(element instanceof Promise){
-            element.then(e=>e.mount(this.wrapper));
-        }
-        globalThis.history.pushState({}, "", path);
-        return this;
-    }
-}
-const SPA=({head, wrapper, target, routes})=>new ZikoSPA({head, wrapper, target, routes});
+    const notify = () => {
+        const newValue = getValue();
 
+        if (Object.is(newValue, value)) return;
 
-/*
- // Static 
-  S.get("/url",wrapper)
-// Dynamique 
- s.get("/url/name/:name/id/:id",(path,name,id)=>handler())
-// regEx
-*/
-
-function parseQueryParams$1(queryString) {
-    return Object.fromEntries(
-            new URLSearchParams(location.search)
-        );
-}
+        value = newValue;
+        subscribers.forEach(fn => fn(value));
+    };
 
-function defineParamsGetter(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 
-        }
+    sources.map(source => {
+        const state = source();
+        return state._subscribe(notify);
     });
-}
-
-// import.meta.glob('./src/pages/**/*.js')
-async function FileBasedRouting(pages /* use import.meta.glob */){
-   const routes = Object.keys(pages);
-   const root = findCommonPath(routes);
-   const pairs = {};
-   for(let i=0; i<routes.length; i++){
-      const module = await pages[routes[i]]();
-      const component = await module.default;
-      Object.assign(pairs,{[customPath(routes[i], root)]:component});
-   }
-   return SPA({
-      target : document.body,
-      routes : {
-         "/" : ()=>{},
-         ...pairs
-      },
-      wrapper : tags.section()
-   })   
-}
-function customPath(inputPath, root = './src/pages', extensions = ['js', 'ts']) {
-   if(root.at(-1)==="/") root = root.slice(0, -1);
-   const normalizedPath = inputPath.replace(/\\/g, '/').replace(/\[(\w+)\]/g, '$1/:$1');
-   const parts = normalizedPath.split('/');
-   const rootParts = root.split('/');
-   const rootIndex = parts.indexOf(rootParts.at(-1));
-   if (rootIndex !== -1) {
-       const subsequentParts = parts.slice(rootIndex + 1);
-       const lastPart = parts.at(-1);
-       const isIndexFile = lastPart === 'index.js' || lastPart === 'index.ts';
-    //    console.log({extensions, subsequentParts, lastPart, isIndexFile, rootParts, rootIndex, parts})
-       const hasValidExtension = extensions.some(ext => lastPart === `.${ext}` || lastPart.endsWith(`.${ext}`));
-       if (isIndexFile) {
-           return '/' + (subsequentParts.length > 1 ? subsequentParts.slice(0, -1).join('/') : '');
-       }
-       if (hasValidExtension) {
-           return '/' + subsequentParts.join('/').replace(/\.(js|ts)$/, '');
-       }
-   }
-   return '';
-}
-function findCommonPath(paths) {
-   if (paths.length === 0) return '';
-   const splitPaths = paths.map(path => path.split('/'));
-   const minLength = Math.min(...splitPaths.map(parts => parts.length));
-   let commonParts = [];
-   for (let i = 0; i < minLength; i++) {
-       const part = splitPaths[0][i]; 
-       if (splitPaths.every(parts => parts[i] === part || parts[i].startsWith('['))) {
-           commonParts.push(part);
-       } else {
-           break; 
-       }
-   }
-   const commonPath = commonParts.join('/') + (commonParts.length ? '/' : '');
-   return commonPath;
-}
-
-function useDerived(deriveFn, sources) {
-    let value = deriveFn(...sources.map(s => s().value));
-    const subscribers = new Set();
-
-    // const unsubscribers = sources.map(source => {
-    //     const srcValue = source();
-
-    //     return srcValue._subscribe(() => {
-    //         const newVal = deriveFn(...sources.map(s => s().value));
-
-    //         if (!Object.is(newVal, value)) {
-    //             value = newVal;
-    //             subscribers.forEach(fn => fn(value));
-    //         }
-    //     });
-    // });
 
     const getter = () => ({
         value,
-        _subscribe: (fn) => {
+        _subscribe(fn) {
             subscribers.add(fn);
             return () => subscribers.delete(fn);
         },
     });
 
     getter[STATE_GETTER] = true;
-    return getter
+
+    return getter;
 }
 
-const mapfun=(fun,...X)=>{
-    const Y=X.map(x=>{
-        if(
-            x===null||
-            ["number","string","boolean","bigint","undefined"].includes(typeof x)||
-            x?.__mapfun__
-        ) return fun(x)
-        if(x instanceof Array) return x.map(n=>mapfun(fun,n));
-        if(ArrayBuffer.isView(x)) return x.map(n=>fun(n));
-        if(x instanceof Set) return new Set(mapfun(fun,...[...x]));
-        if(x instanceof Map) return new Map([...x].map(n=>[n[0],mapfun(fun,n[1])]));
-        if(x.isMatrix?.()) return new x.constructor(x.rows, x.cols, mapfun(x.arr.flat(1)))
-        // if(x.isComplex?.()){
-        //     const [a,b,z,phi]=[x.a,x.b,x.z,x.phi];
-        //     switch(fun){
-        //         // Moved to Fixed to avoid Circular Dep
-        //         // case Math.log: return new x.constructor(ln(z),phi); // Done
-        //         // case Math.exp: return new x.constructor(e(a)*cos(b),e(a)*sin(b)); // Done
-        //         // case Math.abs: return z; // Done
-        //         // case Math.sqrt: return new x.constructor(sqrt(z)*cos(phi/2),sqrt(z)*sin(phi/2)); // Done
-        //         // case Fixed.cos: return new x.constructor(cos(a)*cosh(b),-(sin(a)*sinh(b)));
-        //         // case Fixed.sin: return new x.constructor(sin(a)*cosh(b),cos(a)*sinh(b));
-        //         // case Fixed.tan:{
-        //         //     const DEN = cos(2*a)+cosh(2*b);
-        //         //     return new x.constructor(sin(2*a)/DEN,sinh(2*b)/DEN);
-        //         // }
-        //         // case Fixed.cosh:return new x.constructor(cosh(a)*cos(b),sinh(a)*sin(b));
-        //         // case Fixed.sinh:return new x.constructor(sinh(a)*cos(b),cosh(a)*sin(b));
-        //         // case Fixed.tanh:{
-        //         //     const DEN=cosh(2*a)+cos(2*b);
-        //         //     return new x.constructor(sinh(2*a)/DEN,sin(2*b)/DEN)
-        //         // }
-        //         default : return fun(x)
-        //     }
-        // }
-        else if(x instanceof Object){
-            return Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun(fun,n[1])]))
-            // return fun(Object) || Object.fromEntries(Object.entries(x).map(n=>n=[n[0],mapfun(fun,n[1])]))
-        }
-    });
-   return Y.length==1? Y[0]: Y; 
-};
-
 const useReactive = (nested_value) => mapfun(
     n => {
         const state = useState(n);
@@ -5114,37 +2940,29 @@ const useReactive = (nested_value) => mapfun(
     nested_value
 );
 
-const useEffect = (callback, deps = []) =>{
+const useEffect = (callback, deps = []) => {
     const states = deps.filter(isStateGetter);
-
     let cleanup;
 
+    const getValues = () =>
+        states.map(state => state().value);
+
     const execute = () => {
-        // Cleanup previous effect
         if (typeof cleanup === "function") {
             cleanup();
         }
 
-        // Read current state values
-        const values = states.map(state => state().value);
-
-        // Execute effect
-        cleanup = callback(...values);
+        cleanup = callback(getValues());
     };
 
-    // Subscribe to states
     const unsubscribers = states.map(state =>
         state()._subscribe(execute)
     );
 
-    // Initial execution
     execute();
 
-    // Return effect cleanup
     return () => {
-        unsubscribers.forEach(unsubscribe => {
-            unsubscribe();
-        });
+        unsubscribers.forEach(unsubscribe => unsubscribe());
 
         if (typeof cleanup === "function") {
             cleanup();
@@ -5153,60 +2971,6 @@ const useEffect = (callback, deps = []) =>{
     };
 };
 
-class UseThread {
-    #worker;
-    #callbacks = new Map();
-    #idCounter = 0;
-
-    constructor() {
-        const workerCode = `
-            this.onmessage = function(e) {
-                const { id, funStr, args, close } = e.data;
-                try {
-                    const func = new Function("return " + funStr)();
-                    const result = func(...args);
-                    postMessage({ id, result });
-                } catch (error) {
-                    postMessage({ id, error: error.message });
-                } finally {
-                    if (close) self.close();
-                }
-            }
-        `;
-        const blob = new Blob([workerCode], { type: "text/javascript" });
-        this.#worker = new Worker(URL.createObjectURL(blob));
-
-        this.#worker.addEventListener("message", (e) => {
-            const { id, result, error } = e.data;
-            const callback = this.#callbacks.get(id);
-            if (!callback) return;
-
-            callback(result, error);
-            this.#callbacks.delete(id);
-        });
-    }
-    call(func, callback, args = [], close = true) {
-        if (typeof func !== "function") throw new TypeError("func must be a function");
-        const id = ++this.#idCounter;
-        this.#callbacks.set(id, callback);
-
-        this.#worker.postMessage({
-            id,
-            funStr: func.toString(),
-            args,
-            close
-        });
-
-        return this;
-    }
-
-    terminate() {
-        this.#worker.terminate();
-    }
-}
-
-const useThread = (func, callback, args = [], close = true) => new UseThread().call(func, callback, args, close);
-
 class UseEventEmitter {
     constructor(maxListeners = 10) {
         this.events = {};
@@ -5274,485 +3038,169 @@ class UseEventEmitter {
 
 const useEventEmitter = (maxListeners) => new UseEventEmitter(maxListeners);
 
-/*
- [
-    {
-        query: '(min-width: 600px)',
-        callback: () => console.log(1)
-    },
-    {
-        query: '(max-width: 300px)',
-        callback: () => console.log(2)
-    }
- ]
-*/
-
-class UseMediaQuery {
-    #mediaQueryRules;
-    #fallback;
-    #lastCalledCallback = null;
-
-    constructor(mediaQueryRules = [], fallback = () => {}) {
-        this.#mediaQueryRules = mediaQueryRules;
-        this.#fallback = fallback;
-
-        this.#init();
-    }
-
-    // PRIVATE: check if ANY rule matches
-    #checkAllRules() {
-        return this.#mediaQueryRules.some(
-            ({ query }) => globalThis.matchMedia(query).matches
-        );
-    }
-
-    // PRIVATE: installs listeners and initial checks
-    #init() {
-        this.#mediaQueryRules.forEach(({ query, callback }) => {
-            const mediaQueryList = globalThis.matchMedia(query);
-
-            const checkMatches = () => {
-                const anyMatch = this.#checkAllRules();
-
-                if (mediaQueryList.matches) {
-                    callback();
-                    this.#lastCalledCallback = callback;
-                } else if (!anyMatch && this.#lastCalledCallback !== this.#fallback) {
-                    this.#fallback();
-                    this.#lastCalledCallback = this.#fallback;
-                }
-            };
-
-            checkMatches();
-            mediaQueryList.addEventListener("change", checkMatches);
-        });
-    }
-}
-
-const useMediaQuery = (mediaQueryRules, fallback) =>
-    new UseMediaQuery(mediaQueryRules, fallback);
-
-class UseTitle {
-    constructor(title = document.title, withEmitter = true) {
-        this.cache = {
-            emitter: null
-        };
-
-        if (withEmitter) this.useEventEmitter();
-        this.set(title);
-    }
-
-    useEventEmitter() {
-        this.cache.emitter = useEventEmitter();
-        return this;
-    }
-
-    setTitle(title) {
-        if (title !== document.title) {
-            document.title = title;
-
-            if (this.cache.emitter) {
-                this.cache.emitter.emit("ziko:title-changed", title);
-            }
-        }
-        return this;
-    }
-
-    get current() {
-        return document.title;
-    }
-
-    onChange(callback) {
-        if (this.cache.emitter) {
-            this.cache.emitter.on("ziko:title-changed", callback);
-        }
-        return this;
-    }
-}
-
-const useTitle = (title, withEmitter = true) => new UseTitle(title, withEmitter);
-
-class UseRoot {
-    constructor(PropsMap, { namespace = 'Ziko', ValidateCssProps = false } = {}) {
-        this.currentPropsMap = PropsMap;
-        this.namespace = namespace;
-        this.ValidateCssProps = ValidateCssProps;
-        this.use(PropsMap);
-    }
-
-    use(PropsMap) {
-        if (this.ValidateCssProps) ValidateCssPropsFn(PropsMap);
-        this.currentPropsMap = PropsMap;
-        this.#maintain();
-        return this;
-    }
-
-    #maintain() {
-        const root = globalThis?.document?.documentElement?.style;
-        for (const prop in this.currentPropsMap) {
-            const cssProp = this.namespace ? `--${this.namespace}-${prop}` : `--${prop}`;
-            root.setProperty(cssProp, this.currentPropsMap[prop]);
-
-            Object.defineProperty(this, prop, {
-                value: `var(${cssProp})`,
-                writable: true,
-                configurable: true,
-                enumerable: false
-            });
-        }
-    }
-}
-
-function ValidateCssPropsFn(PropsMap) {
-    const validProps = new Set(Object.keys(document.documentElement.style));
-    for (const key in PropsMap) {
-        if (!validProps.has(key)) {
-            throw new Error(`Invalid CSS property: "${key}"`);
-        }
-    }
-}
-
-const useRoot = (PropsMap, options = {}) => new UseRoot(PropsMap, options);
+const camel2hyphencase$1 = (text = '') => text.replace(/[A-Z]/g, match => '-' + match.toLowerCase());
+const camel2snakecase = (text = '') => text.replace(/[A-Z]/g, match => '_' + match.toLowerCase());
+const camel2pascalcase = (text = '') => text.charAt(0).toUpperCase() + text.slice(1);
+const camel2constantcase = (text = '') => text.replace(/[A-Z]/g, match => '_' + match).toUpperCase();
 
+const pascal2snakecase = (text = '') => text.replace(/([A-Z])/g, (match, offset) => offset ? '_' + match.toLowerCase() : match.toLowerCase());
+const pascal2hyphencase = (text = '') => text.replace(/([A-Z])/g, (match, offset) => offset ? '-' + match.toLowerCase() : match.toLowerCase());
+const pascal2camelcase = (text = '') => text.charAt(0).toLowerCase() + text.slice(1);
+const pascal2constantcase = (text = '') => text.replace(/([A-Z])/g, (match, offset) => offset ? '_' + match : match).toUpperCase();
 
-// Usage 
+const snake2camelcase = (text = '') => text.replace(/(_\w)/g, match => match[1].toUpperCase());
+const snake2hyphencase = (text = '') => text.replace(/_/g, "-");
+const snake2pascalcase = (text = '') => text.split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
+const snake2constantcase = (text = '') => text.toUpperCase();
 
-/*
-const Styles = {
- S1 : {
-  background : 'white',
-  color : 'darkblue'
-  border : '2px darkblue solid"'
- },
- S2 : {
-  background : 'darkblue',
-  color : 'white'
-  border : '2px green solid"'
- }
-}
-const {use, border, background, color} = useRoot(Style.S1)
-
-tags.p("Test useRoot ").style({
-  border,
-  color,
-  background,
-  padding : '10px'
-})
+const hyphen2camelcase = (text = '') => text.replace(/-([a-z])/g, match => match[1].toUpperCase());
+const hyphen2snakecase = (text = '') => text.replace(/-/g, '_');
+const hyphen2pascalcase = (text = '') => text.split('-').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
+const hyphen2constantcase = (text = '') => text.replace(/-/g, '_').toUpperCase();
 
-*/
+const constant2camelcase = (text = '') => text.toLowerCase().replace(/_([a-z])/g, match => match[1].toUpperCase());
+const constant2snakecase = (text = '') => text.toLowerCase();
+const constant2pascalcase = (text = '') => text.toLowerCase().split('_').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join('');
+const constant2hyphencase = (text = '') => text.toLowerCase().replace(/_/g, '-');
 
-const parseQueryParams = queryString => Object.fromEntries(new URLSearchParams(globalThis?.location?.search));
-
-function useQueryParams() {
-    const getParams = () =>
-        parseQueryParams();
-
-    const setParams = (updates, merge = true) => {
-        const current = getParams();
-
-        const next =
-            typeof updates === "function"
-                ? updates(current)
-                : updates;
-
-        const finalParams = merge
-            ? { ...current, ...next }
-            : next;
-
-        const search = new URLSearchParams(finalParams).toString();
-
-        window.history.pushState(
-            {},
-            "",
-            `${window.location.pathname}${search ? `?${search}` : ""}`
-        );
-
-        window.dispatchEvent(
-            new CustomEvent("queryparamschange", {
-                detail: finalParams
-            })
-        );
-    };
-
-    return [getParams, setParams];
-}
-
-function watchQueryParams(callback) {
-    let previousSearch = location.search;
-
-    const notify = () => {
-        const currentSearch = location.search;
-
-        if (currentSearch === previousSearch) {
-            return;
-        }
-
-        previousSearch = currentSearch;
-        callback(parseQueryParams());
-    };
-
-    window.addEventListener("popstate", notify);
-
-    const pushState = history.pushState;
-    history.pushState = function (...args) {
-        pushState.apply(this, args);
-        notify();
-    };
-
-    const replaceState = history.replaceState;
-    history.replaceState = function (...args) {
-        replaceState.apply(this, args);
-        notify();
-    };
-
-    callback(parseQueryParams());
+const is_camelcase$1 = (text = '') =>{
+    if (text.length === 0) return false; 
+    const camelCasePattern = /^[a-z][a-zA-Z0-9]*$/;
+    return camelCasePattern.test(text);
+};
+const is_hyphencase = (text = '') => text.split('-').length > 0;
+const is_snakeCase = (text = '') => text.split('_').length > 0;
+const is_pascalcalse = (text = '') => {
+    if (text.length === 0) return false;
+    const PascalCasePattern = /^[A-Z][a-zA-Z0-9]*$/;
+    return PascalCasePattern.test(text);
+};
 
-    return () => {
-        window.removeEventListener("popstate", notify);
-    };
-}
-
-let {sqrt, cos: cos$1, sin: sin$1, exp, log, cosh: cosh$1, sinh} = Math;
-// Math.abs = new Proxy(Math.abs, {
-//   apply(target, thisArg, args) {
-//     const x = args[0]
-//       if(typeof x === 'number') return target.apply(thisArg, args);
-//       if(x?.isComplex?.()){
-//         const {a, b, z, phi} = x
-//         const complex = (a, b) => new x.constructor(a, b) 
-//         switch(target.name){
-//           case 'abs' : return a.z;
-//           case 'sqrt' : return complex(sqrt(z)*cos(phi/2),sqrt(z)*sin(phi/2));
-//         }
-//       }
-      
-//   }
-// });
+const is_palindrome = text =>{
+    const str = text.toLocaleLowerCase();
+    let l = str.length,i;
+    for(i=0;i<l/2;i++)if(str[i]!=str[l-i-1])return false;
+    return true;
+};
 
+const is_anagram = (word, words) =>{
+        word=word.split("").sort();
+        words=words.split("").sort();
+        return JSON.stringify(word)===JSON.stringify(words);    
+};
 
-for (const key of Object.getOwnPropertyNames(Math)) {
-  const fn = Math[key];
-  if (typeof fn === "function") {
-    Math[key] = new Proxy(fn, {
-      apply(target, thisArg, args) {
-        // console.log(target)
-        const x = args[0];
-        if(typeof x === 'number' || args.length === 0) return target.apply(thisArg, args);
-        if(x?.isComplex?.()){
-            const {a, b, z, phi} = x;
-            const complex = (a, b) => new x.constructor(a, b);
-            switch(target.name){
-                case 'abs' : return x.z;
-                case 'sqrt' : return complex(sqrt(z)*cos$1(phi/2),sqrt(z)*sin$1(phi/2));
-                case 'log' : return complex(log(z), phi);
-                case 'exp' : return complex(exp(a)*cos$1(b),exp(a)*sin$1(b));
-                case 'cos' : return complex(cos$1(a)*cosh$1(b),-(sin$1(a)*sinh(b)));
-                case 'sin' : return complex(sin$1(a)*cosh$1(b),cos$1(a)*sinh(b));
-                case 'tan' : {
-                    const DEN = cos$1(2*a)+cosh$1(2*b);
-                    return complex(sin$1(2*a) /DEN, sinh(2*b)/DEN);
-                }
-                case 'cosh' : return complex(cosh$1(a)*cos$1(b),sinh(a)*sin$1(b));
-                case 'sinh' : return complex(sinh(a)*cos$1(b),cosh$1(a)*sin$1(b));
-                case 'tanh' : {
-                    const DEN=cosh$1(2*a)+cos$1(2*b);
-                    return complex(sinh(2*a)/DEN,sin$1(2*b)/DEN)
-                }
-                default : return target.apply(thisArg, args)
-             }
-        }
-        // if( x.isMatrix?.()){
-        //     const {rows, cols, arr} = x
-        //     // return new x.constructor(rows, cols, arr.flat(1).map(n=>));
-        // }
-        throw new TypeError(`Math.${key} expects only numbers`);
-      }
-    });
-  }
-}
+const is_isogram = (text = '') => [...new Set(text.toLowerCase())].length === text.length;
 
 if(globalThis?.document){
     document?.addEventListener("DOMContentLoaded", __Ziko__.__Config__.init());
-}
+}
+
+// import './math/functions/proxy.js'
 
-exports.App = App;
-exports.Canvas = Canvas;
 exports.ClickAwayEvent = ClickAwayEvent;
 exports.ClickListeners = ClickListeners;
 exports.Clock = Clock;
 exports.CloneElement = CloneElement;
-exports.Complex = Complex;
 exports.E = E;
 exports.EPSILON = EPSILON;
 exports.EventController = EventController;
-exports.FileBasedRouting = FileBasedRouting;
-exports.Flex = Flex;
-exports.For = For;
-exports.Fragment = Fragment;
-exports.HTMLWrapper = HTMLWrapper;
 exports.KeyListeners = KeyListeners;
-exports.Matrix = Matrix;
-exports.PI = PI$1;
+exports.PI = PI;
 exports.PtrListeners = PtrListeners;
 exports.Random = Random;
-exports.SPA = SPA;
-exports.SVGWrapper = SVGWrapper;
 exports.Scheduler = Scheduler;
-exports.Suspense = Suspense;
-exports.Svg = Svg;
-exports.Swap = Swap;
 exports.SwipeEvent = SwipeEvent;
-exports.Switch = Switch;
 exports.Tick = Tick;
 exports.TimeAnimation = TimeAnimation;
 exports.TimeLoop = TimeLoop;
 exports.TimeScheduler = TimeScheduler;
-exports.UICanvas = UICanvas;
-exports.UIElement = UIElement$1;
-exports.UIFlex = UIFlex;
-exports.UIFragment = UIFragment;
-exports.UIHTMLWrapper = UIHTMLWrapper;
+exports.UIElement = UIElement;
 exports.UINode = UINode;
-exports.UISVGWrapper = UISVGWrapper;
-exports.UISuspense = UISuspense;
-exports.UISvg = UISvg;
-exports.UISwap = UISwap;
-exports.UISwitch = UISwitch;
-exports.UIView = UIView;
-exports.UseRoot = UseRoot;
-exports.UseThread = UseThread;
-exports.View = View;
 exports.ViewEvent = ViewEvent;
 exports.ViewListeners = ViewListeners;
-exports.ZikoApp = ZikoApp;
-exports.ZikoSPA = ZikoSPA;
 exports.ZikoUIText = ZikoUIText;
 exports.abs = abs;
 exports.accum_max = accum_max;
 exports.accum_min = accum_min;
-exports.accum_prod = accum_prod;
 exports.accum_product = accum_product;
 exports.accum_sum = accum_sum;
-exports.acos = acos$1;
+exports.acos = acos;
 exports.acosh = acosh;
 exports.acot = acot;
 exports.add = add;
 exports.add_class = add_class;
 exports.add_vendor_prefix = add_vendor_prefix;
-exports.and = and;
 exports.animation = animation;
-exports.apply_fun = apply_fun;
-exports.arc = arc;
 exports.asin = asin;
 exports.asinh = asinh;
 exports.atan = atan;
 exports.atan2 = atan2;
 exports.atanh = atanh;
-exports.back = back;
-exports.binomial = binomial;
 exports.call_with_optional_props = call_with_optional_props;
+exports.camel2constantcase = camel2constantcase;
+exports.camel2hyphencase = camel2hyphencase$1;
+exports.camel2pascalcase = camel2pascalcase;
+exports.camel2snakecase = camel2snakecase;
 exports.cbrt = cbrt;
 exports.ceil = ceil;
 exports.clamp = clamp;
 exports.clock = clock;
 exports.cloneUI = cloneUI;
-exports.complex = complex;
+exports.constant2camelcase = constant2camelcase;
+exports.constant2hyphencase = constant2hyphencase;
+exports.constant2pascalcase = constant2pascalcase;
+exports.constant2snakecase = constant2snakecase;
 exports.contraharmonic_mean = contraharmonic_mean;
-exports.cos = cos$3;
-exports.cosh = cosh$2;
+exports.cos = cos$1;
+exports.cosh = cosh$1;
 exports.coth = coth;
 exports.croot = croot;
-exports.csv2arr = csv2arr;
-exports.csv2json = csv2json;
-exports.csv2matrix = csv2matrix;
-exports.csv2object = csv2object;
-exports.csv2sql = csv2sql;
 exports.debounce = debounce;
-exports.defineParamsGetter = defineParamsGetter;
-exports.define_wc = define_wc;
 exports.deg2rad = deg2rad;
-exports.discret = discret;
 exports.div = div;
-exports.elastic = elastic;
 exports.ema = ema;
-exports.exp = exp$1;
+exports.exp = exp;
 exports.floor = floor;
 exports.fract = fract;
 exports.geo_mean = geo_mean;
 exports.harmonic_mean = harmonic_mean;
+exports.hyphen2camelcase = hyphen2camelcase;
+exports.hyphen2constantcase = hyphen2constantcase;
+exports.hyphen2pascalcase = hyphen2pascalcase;
+exports.hyphen2snakecase = hyphen2snakecase;
 exports.hypot = hypot;
-exports.in_back = in_back;
-exports.in_bounce = in_bounce;
-exports.in_circ = in_circ;
-exports.in_cubic = in_cubic;
-exports.in_elastic = in_elastic;
-exports.in_expo = in_expo;
-exports.in_out_back = in_out_back;
-exports.in_out_bounce = in_out_bounce;
-exports.in_out_circ = in_out_circ;
-exports.in_out_cubic = in_out_cubic;
-exports.in_out_elastic = in_out_elastic;
-exports.in_out_expo = in_out_expo;
-exports.in_out_quad = in_out_quad;
-exports.in_out_quart = in_out_quart;
-exports.in_out_quint = in_out_quint;
-exports.in_out_sin = in_out_sin;
-exports.in_quad = in_quad;
-exports.in_quart = in_quart;
-exports.in_quint = in_quint;
-exports.in_sin = in_sin;
 exports.interquartile_mean = interquartile_mean;
 exports.iqr = iqr;
 exports.isStateGetter = isStateGetter;
+exports.is_anagram = is_anagram;
+exports.is_camelcase = is_camelcase$1;
+exports.is_hyphencase = is_hyphencase;
+exports.is_isogram = is_isogram;
+exports.is_palindrome = is_palindrome;
+exports.is_pascalcalse = is_pascalcalse;
 exports.is_primitive = is_primitive;
-exports.json2arr = json2arr;
-exports.json2css = json2css;
-exports.json2csv = json2csv;
-exports.json2csvFile = json2csvFile;
-exports.json2xml = json2xml;
-exports.json2xmlFile = json2xmlFile;
-exports.json2yml = json2yml;
-exports.json2ymlFile = json2ymlFile;
+exports.is_snakeCase = is_snakeCase;
 exports.lerp = lerp;
-exports.linear = linear;
 exports.linkStyle = linkStyle;
 exports.ln = ln;
 exports.loop = loop;
 exports.map = map$1;
-exports.mapfun = mapfun$1;
-exports.matrix = matrix;
-exports.matrix2 = matrix2;
-exports.matrix3 = matrix3;
-exports.matrix4 = matrix4;
-exports.max = max;
 exports.mean = mean;
 exports.median = median;
 exports.midhinge = midhinge;
 exports.midrange = midrange;
-exports.min = min;
 exports.modulo = modulo;
 exports.mul = mul;
-exports.nand = nand;
-exports.nor = nor;
 exports.norm = norm;
 exports.normalize_css_value = normalize_css_value;
-exports.not = not;
 exports.nthr = nthr;
-exports.or = or;
-exports.out_back = out_back;
-exports.out_bounce = out_bounce;
-exports.out_circ = out_circ;
-exports.out_cubic = out_cubic;
-exports.out_elastic = out_elastic;
-exports.out_expo = out_expo;
-exports.out_quad = out_quad;
-exports.out_quart = out_quart;
-exports.out_quint = out_quint;
-exports.out_sin = out_sin;
-exports.parseXML = parseXML;
 exports.parse_props = parse_props;
+exports.pascal2camelcase = pascal2camelcase;
+exports.pascal2constantcase = pascal2constantcase;
+exports.pascal2hyphencase = pascal2hyphencase;
+exports.pascal2snakecase = pascal2snakecase;
 exports.percentile = percentile;
-exports.pow = pow$1;
+exports.pow = pow;
 exports.power_mean = power_mean;
 exports.q1 = q1;
 exports.q3 = q3;
@@ -5771,20 +3219,19 @@ exports.script = script;
 exports.sec = sec;
 exports.sig = sig;
 exports.sign = sign;
-exports.sin = sin$3;
-exports.sinh = sinh$1;
+exports.sin = sin$1;
+exports.sinh = sinh;
 exports.sleep = sleep;
 exports.sma = sma;
-exports.sqrt = sqrt$2;
+exports.snake2camelcase = snake2camelcase;
+exports.snake2constantcase = snake2constantcase;
+exports.snake2hyphencase = snake2hyphencase;
+exports.snake2pascalcase = snake2pascalcase;
+exports.sqrt = sqrt;
 exports.std = std;
-exports.step = step;
 exports.step_fps = step_fps;
 exports.style = style;
 exports.sub = sub;
-exports.svg2ascii = svg2ascii;
-exports.svg2img = svg2img;
-exports.svg2imgUrl = svg2imgUrl;
-exports.svg2str = svg2str;
 exports.tags = tags;
 exports.tan = tan;
 exports.tanh = tanh;
@@ -5799,26 +3246,15 @@ exports.trunc = trunc;
 exports.useDerived = useDerived;
 exports.useEffect = useEffect;
 exports.useEventEmitter = useEventEmitter;
-exports.useIPC = useIPC;
-exports.useLocalStorage = useLocalStorage;
-exports.useMediaQuery = useMediaQuery;
-exports.useQueryParams = useQueryParams;
 exports.useReactive = useReactive;
-exports.useRoot = useRoot;
-exports.useSessionStorage = useSessionStorage;
 exports.useState = useState;
-exports.useThread = useThread;
-exports.useTitle = useTitle;
 exports.variance = variance;
 exports.wait = wait;
 exports.waitElm = waitElm;
 exports.waitForUIElm = waitForUIElm;
 exports.waitForUIElmSync = waitForUIElmSync;
-exports.watchQueryParams = watchQueryParams;
 exports.weighted_mean = weighted_mean;
 exports.weighted_std = weighted_std;
 exports.weighted_variance = weighted_variance;
 exports.winsorized_mean = winsorized_mean;
 exports.wma = wma;
-exports.xnor = xnor;
-exports.xor = xor;