ziko 2.0.0-alpha.0 → 2.0.0-beta.1

package/dist/ziko.cjs

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Wed Sep 02 2026 10:53:51 GMT+0100 (UTC+01:00)
+  Date : Sat Sep 05 2026 12:37:55 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
@@ -13,11 +13,11 @@
 const { PI, E } = Math;
 const EPSILON=Number.EPSILON;
 
-const is_primitive$1 = value => typeof value !== 'object' && typeof value !== 'function' || value === null;
+const is_primitive = value => typeof value !== 'object' && typeof value !== 'function' || value === null;
 
 const mapfun=(fun,...X)=>{
     const Y=X.map(x=>{
-        if(is_primitive$1(x) || x?.__mapfun__) return fun(x)
+        if(is_primitive(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]));
@@ -48,1117 +48,141 @@ const apply_fun = (x, fn) => {
     return fn(x)
 };
 
-const base2base = (value, fromBase, toBase) => {
-
-    const dec = parseInt(value, fromBase);
-    if (Number.isNaN(dec)) throw new TypeError('Invalid value for the given base');
-
-    return dec.toString(toBase);
-};
-
-const percentile = (X, p) => {
-  if (X.length === 0) 
-    return NaN;
-  let a = X.sort((x, y) => x - y);
-  let index = (p / 100) * (a.length - 1);
-  let i = Math.floor(index);
-  let f = index - i;
-  if (i === a.length - 1) 
-    return a[i]; 
-  return a[i] * (1 - f) + a[i + 1] * f;
-};
-
-const q1 = X => percentile(X, 25); 
-const median = X => percentile(X, 50); 
-const q3 = X => percentile(X, 75); 
-
-// Interquartile Range
-const iqr = X => q3(X) - q1(X);
-
-// Mean
-const mean = (...x) => x.reduce((a, b) => a + b) / x.length;
-const geo_mean = (...x) => (x.reduce((a, b) => a * b)) ** (1/x.length);
-// Quadratic Mean
-const rms = (...x) => {
-    const n = x.length;
-    return (Math.hypot(...x)/n)**(1/n)
-};
-
-const weighted_mean=(values, weights)=>{
-  let sum = 0, sw = 0;
-  for (let i = 0; i < values.length; i++) {
-    sum += values[i] * weights[i];
-    sw += weights[i];
-  }
-  return sum / sw;
-};
-
-const harmonic_mean = (...x) => {
-  let s = 0, i = 0;
-  for(i=0; i<x.length; i++) 
-    s += 1/x[i];
-  return x.length / s;
-};
-
-const power_mean = (X, p) =>{
-  let s = 0, i = 0, l = X.length;
-  for(i=0; i < l; i++) 
-    s+= X[i]**p;
-  return (s / l) ** (1 / p);
-};
-
-const trimmed_mean = (X, k) =>{
-  let a = [...X].sort((a,b)=>a-b).slice(k, X.length - k);
-  return mean(...a);
-};
-
-const winsorized_mean = (X, k) =>{
-  let a = [...X].sort((a,b)=>a-b);
-  let low = a[k], high = a[a.length - k - 1];
-  a = a.map(x => Math.max(low, Math.min(high, x)));
-  return mean(a);
-};
-
-const midrange = (x) =>{
-  let min = Math.min(...x);
-  let max = Math.max(...x);
-  return (min + max) / 2;
-};
-
-const midhinge = (...x) =>{
-  let a = x.sort((a,b)=>a-b);
-  let q1 = a[Math.floor((a.length - 1) * 0.25)];
-  let q3 = a[Math.floor((a.length - 1) * 0.75)];
-  return (q1 + q3) / 2;
-};
-
-
-const interquartile_mean = (...x) =>{
-  let a = x.sort((a,b)=>a-b);
-  let q1 = a[Math.floor((a.length - 1) * 0.25)];
-  let q3 = a[Math.floor((a.length - 1) * 0.75)];
-  let m = a.filter(x => x >= q1 && x <= q3);
-  return mean(m);
-};
-
-
-const contraharmonic_mean = (...x) =>{
-  let num = 0, den = 0, i, l = x.length;
-  for(i = 0; i < l; i++){
-    num += x[i]**2;
-    den += x[i];
-  }
-  return num / den;
-};
-
-// Population Variance
-const variance = (...x) => {
-  const n = x.length;
-  if (n === 0) return NaN;
-  const x_mean = mean(...x);
-  return x.reduce((sum, xi) => sum + (xi - x_mean) ** 2, 0) / n;
-};
-const std = (...x) => Math.sqrt(variance(...x));
+const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
+const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
 
-const sample_variance = (...x) => {
-  const n = x.length;
-  if (n < 2) return NaN;
-  const x_mean = mean(...x);
-  return x.reduce((sum, xi) => sum + (xi - x_mean) ** 2, 0) / (n - 1);
-};
-const sample_std = (...x) => Math.sqrt(sample_variance(...x));
-
-const weighted_variance = (X, weights) => {
-  const n = X.length;
-  if (n === 0 || weights.length !== n) return NaN;
-  const sw = weights.reduce((sum, w) => sum + w, 0);
-  const mean = X.reduce((sum, x, i) => sum + x * weights[i], 0) / sw;
-  return X.reduce((sum, x, i) => sum + weights[i] * (x - mean) ** 2, 0) / sw;
-};
-const weighted_std = (X, weights) => Math.sqrt(weighted_variance(X, weights));
+const norm = (x, min, max) => apply_fun(
+    x, 
+    v => min !== max ? (v - min) / (max - min) : 0
+);
+const lerp = (x, min, max) => apply_fun(
+    x, 
+    v => (max - min) * v + min
+);
+const clamp = (x, min, max) => apply_fun(
+    x, 
+    v => Math.min(Math.max(v, min), max)
+);
+const map$1 = (x, a, b, c, d) => apply_fun(
+    x, 
+    v => lerp(norm(v, a, b), c, d)
+);
 
-const rolling_variance = (X, windowSize) => {
-  if (windowSize < 1 || X.length < windowSize) return [];
-  let result = [];
-  for (let i = 0; i <= X.length - windowSize; i++) {
-    const w = X.slice(i, i + windowSize);
-    result.push(sample_variance(w)); // usually sample variance for rolling
+const hypot = (...x) => {
+  const c0 = x.find(a => a.isComplex?.());
+  if (c0) {
+    const W = x.map(n => n.isComplex?.() ? n : new c0.constructor(n, 0));
+    return Math.hypot(...W.map(c => c.z));
   }
-  return result;
-};
-const rolling_std = (X, windowSize) => Math.sqrt(rolling_variance(X, windowSize));
-
-// Simple Moving Average
-const sma = (X, w) =>{
-  let r = [];
-  for (let i = 0; i <= X.length - w; i++) {
-    let s = 0;
-    for (let j = 0; j < w; j++) s += X[i + j];
-    r.push(s / w);
-  }
-  return r;
+  return Math.hypot(...x);
 };
 
-// exponential Moving Average
-const ema = (X, alpha) =>{
-  let r = [], prev = X[0];
-  r.push(prev);
-  for (let i = 1; i < X.length; i++) {
-    prev = alpha * X[i] + (1 - alpha) * prev;
-    r.push(prev);
-  }
-  return r;
-};
 
-// weightedMovingAverage
-const wma = (X, weights) =>{
-  let k = weights.length;
-  let sw = weights.reduce((a,b)=>a+b, 0);
-  let r = [];
-  for (let i = 0; i <= X.length - k; i++) {
-    let s = 0;
-    for (let j = 0; j < k; j++) s += X[i+j] * weights[j];
-    r.push(s / sw);
-  }
-  return r;
-};
-
-const accum_sum = (arr) => {
-  let result = [];
-  let total = 0;
-  for (let x of arr) {
-    total += x;
-    result.push(total);
-  }
-  return result;
-};
+const atan2 = (y, x, rad = true) => {
+    if (y instanceof Array && !(x instanceof Array))
+        return mapfun(n => atan2(n, x, rad), ...y);
 
-const accum_product = (arr) => {
-  let result = [];
-  let prod = 1;
-  for (let x of arr) {
-    prod *= x;
-    result.push(prod);
-  }
-  return result;
-};
+    if (x instanceof Array && !(y instanceof Array))
+        return mapfun(n => atan2(y, n, rad), ...x);
 
-const accum_max = (arr) => {
-  let result = [];
-  let m = -Infinity;
-  for (let x of arr) {
-    m = Math.max(m, x);
-    result.push(m);
-  }
-  return result;
-};
+    if (y instanceof Array && x instanceof Array)
+        return y.map((v, i) => atan2(v, x[i], rad));
 
-const accum_min = (arr) => {
-  let result = [];
-  let m = Infinity;
-  for (let x of arr) {
-    m = Math.min(m, x);
-    result.push(m);
-  }
-  return result;
+    const phi = Math.atan2(y, x);
+    return rad ? phi : phi * 180 / Math.PI;
 };
 
-class Random {
-    static int(a, b){
-        return Math.floor(this.float(a, b));
-    }
-    static float(a, b){
-        return b !== undefined
-            ? Math.random() * (b - a) + a
-            : Math.random() * a;
-    }
-    static bin(){
-        return this.int(2);
-    }
-    static oct(){
-        return this.int(8);
-    }
-    static dec(){
-        return this.int(10);
-    }
-    static hex(){
-        return base2base(this.int(16), 10, 16);
-    }
-    static char(upperCase = false){
-        const i = upperCase
-            ? this.int(65, 91)
-            : this.int(97, 123);
-        return String.fromCharCode(i);
-    }
-    static bool(){
-        return Boolean(this.int(2));
-    }
-    static get color(){
-        return {
-            hex : () =>
-                `#${this.int(0xffffff).toString(16).padStart(6, '0')}`,
-
-            hexa : () => {
-                const [r,g,b,a] = Array.from(
-                    {length:4},
-                    () => this.int(0xff).toString(16).padStart(2,'0')
-                );
-                return `#${r}${g}${b}${a}`;
-            },
-            rgb : () => {
-                const [r,g,b] = Array.from({length:3}, () => this.int(0xff));
-                return `rgb(${r}, ${g}, ${b})`;
-            },
-            rgba : () => {
-                const [r,g,b] = Array.from({length:3}, () => this.int(0xff));
-                const a = Math.random().toFixed(2);
-                return `rgba(${r}, ${g}, ${b}, ${a})`;
-            },
-            hsl : () => {
-                const h = this.int(360);
-                const s = this.int(100);
-                const l = this.int(100);
-                return `hsl(${h}, ${s}%, ${l}%)`;
-            },
-            hsla : () => {
-                const h = this.int(360);
-                const s = this.int(100);
-                const l = this.int(100);
-                const a = Math.random().toFixed(2);
-                return `hsla(${h}, ${s}%, ${l}%, ${a})`;
-            },
-            gray : () => {
-                const g = this.int(0xff);
-                return `rgb(${g}, ${g}, ${g})`;
-            }
-        };
-    }
-    static get sample(){
-        const R = this;
-        return {
-            int   : (n, a, b) => Array.from({length:n}, () => R.int(a, b)),
-            float : (n, a, b) => Array.from({length:n}, () => R.float(a, b)),
-            char  : (n, upper=false) => Array.from({length:n}, () => R.char(upper)),
-            bool  : n => Array.from({length:n}, () => R.bool()),
-            bin   : n => Array.from({length:n}, () => R.bin()),
-            oct   : n => Array.from({length:n}, () => R.oct()),
-            dec   : n => Array.from({length:n}, () => R.dec()),
-            hex   : n => Array.from({length:n}, () => R.hex()),
-            get color(){
-                return {
-                    hex  : n => Array.from({length:n}, () => R.color.hex()),
-                    hexa : n => Array.from({length:n}, () => R.color.hexa()),
-                    rgb  : n => Array.from({length:n}, () => R.color.rgb()),
-                    rgba : n => Array.from({length:n}, () => R.color.rgba()),
-                    hsl  : n => Array.from({length:n}, () => R.color.hsl()),
-                    hsla : n => Array.from({length:n}, () => R.color.hsla()),
-                    gray : n => Array.from({length:n}, () => R.color.gray())
-                };
-            },
-            choice : (n, choices, p) =>
-                Array.from({length:n}, () => R.choice(choices, p))
+class UINode {
+    constructor(node){
+        this.cache = {
+            node
         };
     }
-    static shuffle(arr){
-        return [...arr].sort(() => 0.5 - Math.random());
-    }
-    static choice(choices = [1,2,3], p = new Array(choices.length).fill(1 / choices.length)){
-        const acc = accum_sum(...p).map(v => v * 100);
-        const pool = new Array(100);
-        pool.fill(choices[0], 0, acc[0]);
-        for(let i=1;i<choices.length;i++)
-            pool.fill(choices[i], acc[i-1], acc[i]);
-        return pool[this.int(pool.length)];
-    }
-}
-
-const complex_constructor = (Complex, a, b) => {
-    let _a, _b;
-  if (a instanceof Complex) {
-    _a = a.a;
-    _b = a.b;
-  } 
-  else if (typeof a === "object") {
-    if ("a" in a && "b" in a) {
-      _a = a.a;
-      _b = a.b;
-    } 
-    else if ("a" in a && "z" in a) {
-      _a = a.a;
-      _b = Math.sqrt(a.z ** 2 - a.a ** 2);
-    } 
-    else if ("a" in a && "phi" in a) {
-      _a = a.a;
-      _b = a.a * Math.tan(a.phi);
-    } 
-    else if ("b" in a && "z" in a) {
-      _b = a.b;
-      _a = Math.sqrt(a.z ** 2 - a.b ** 2);
-    } 
-    else if ("b" in a && "phi" in a) {
-      _b = b;
-      _a = a.b / Math.tan(a.phi);
-    } 
-    else if ("z" in a && "phi" in a) {
-      _a = +a.z * Math.cos(a.phi).toFixed(15);
-      _b = +a.z * Math.sin(a.phi).toFixed(15);
-    }
-  } 
-  else if (typeof a === "number" && typeof b === "number") {
-    _a = +a.toFixed(32);
-    _b = +b.toFixed(32);
-  }
-  return [_a, _b]
-};
-
-class Complex{
-    constructor(a = 0, b = 0) {
-        [
-            this.a,
-            this.b
-        ] = complex_constructor(Complex, a, b);
-    }
-    get __mapfun__(){
-        return true
-    }
-    isComplex(){
+    isUINode(){
         return true
     }
-    toString(){
-        let str = "";
-        if (this.a !== 0)
-          this.b >= 0
-            ? (str = `${this.a}+${this.b}*i`)
-            : (str = `${this.a}-${Math.abs(this.b)}*i`);
-        else
-          this.b >= 0
-            ? (str = `${this.b}*i`)
-            : (str = `-${Math.abs(this.b)}*i`);
-        return str;
-    }
-    serialize() {
-        return JSON.stringify({
-            type : 'complex',
-            data : this
-        });
-    }
-    static deserialize(json){
-        if(typeof json === 'string') json = JSON.parse(json);
-        let {data, type} = json;
-        return (type === 'complex' && ('a' in data) && ('b' in data))
-            ? new Complex(data.a, data.b)
-            : TypeError('Not a valid complex')
+    get node(){
+        return this.cache.node;
     } 
-    toFixed(n){
-        this.a = + this.a.toFixed(n);
-        this.b = + this.b.toFixed(n);
-        return this; 
-    }  
-    toPrecision(n){
-        this.a = + this.a.toPrecision(n);
-        this.b = + this.b.toPrecision(n);
-        return this; 
-    }  
-    clone() {
-        return new Complex(this.a, this.b);
-    }
-    get z(){
-        return Math.hypot(this.a,this.b);    
-    }
-    get phi(){
-        return Math.atan2(this.b , this.a);        
-    }
-    static zero() {
-        return new Complex(0, 0);
-    }
-    static fromPolar(z, phi) {
-        return new Complex(
-            +(z * cos(phi)).toFixed(13), 
-            +(z * sin(phi)).toFixed(13)
-        );
-    }
-    
-    static get random(){
-        return {
-            int : (a, b)=> new Complex(...Random.sample.int(2, a, b) ),
-            float : (a, b)=> new Complex(...Random.sample.float(2, a, b) ),
-        }
-    }
-    static twiddle(K, N){
-        const phi = -2 * Math.PI * K / N;
-        return new Complex(
-            Math.cos(phi), 
-            Math.sin(phi)
-        );
-    }
-    get conj() {
-        return new Complex(this.a, -this.b);
-    }
-    get inv() {
-        return new Complex(
-            this.a / Math.hypot(this.a, this.b),
-            -this.b / Math.hypot(this.a, this.b)
-        );
-    }
-    add(...c) {
-        for (let i = 0; i < c.length; i++) {
-            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
-            this.a += c[i].a;
-            this.b += c[i].b;
-        }
-        return this;
-    }
-    sub(...c) {
-        for (let i = 0; i < c.length; i++) {
-            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
-            this.a -= c[i].a;
-            this.b -= c[i].b;
-        }
-        return this;
-    }
-    mul(...c){
-        let {z, phi} = this;
-        for (let i = 0; i < c.length; i++) {
-            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
-            z *= c[i].z;
-            phi += c[i].phi;
-        }
-        this.a = z * Math.cos(phi);
-        this.b = z * Math.sin(phi);  
-        return this.toFixed(8);
-    }
-    div(...c){
-        let {z, phi} = this;
-        for (let i = 0; i < c.length; i++) {
-            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
-            z /= c[i].z;
-            phi -= c[i].phi;
-        }
-        this.a = z * Math.cos(phi);
-        this.b = z * Math.sin(phi);  
-        return this.toFixed(8);    }
-    modulo(...c) {
-        for (let i = 0; i < c.length; i++) {
-            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
-            this.a %= c[i].a;
-            this.b %= c[i].b;
+}
+
+function parseQueryParams(queryString) {
+    const params = {};
+    queryString.replace(/[A-Z0-9]+?=([\w|:|\/\.]*)/gi, (match) => {
+        const [key, value] = match.split('=');
+        params[key] = value;
+    });
+    return params;
+}
+
+function defineParamsGetter(target ){
+    Object.defineProperties(target, {
+        'QueryParams': {
+            get: function() {
+                return parseQueryParams(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 
         }
-        return this;
+    });
+}
+
+class UIStore extends Array {
+    constructor(...args) {
+        super(...args); 
     }
-    pow(...c){
-        let {z, phi} = this;
-        for (let i = 0; i < c.length; i++) {
-            if (typeof c[i] === "number") c[i] = new Complex(c[i], 0);
-            z *= Math.exp(c[i].a * Math.log(z) - c[i].b * phi);
-            phi += c[i].b * Math.log(z) + c[i].a * phi;
-        }
-        this.a = z * Math.cos(phi);
-        this.b = z * Math.sin(phi);  
+    clear(){
+        this.length = 0;
         return this;
     }
-    get expo() {
-        return [this.z, this.phi];
-    }
-    nthr(n=2){
-        return complex({z: this.z ** (1/n), phi: this.phi / n});
-    }
-    get sqrt(){
-        return this.nthr(2);
-    }
-    get cbrt(){
-        return this.nthr(3);
+    getItemById(id) {
+        return this.find(n => n.element.id === id);
     }
-    get log(){
-        return complex(this.z, this.phi);
+    getItemsByTagName(tag) {
+        return this.filter(n => n.element.tagName.toLowerCase() === tag.toLowerCase());
     }
-    get cos(){
-        return complex(
-            Math.cos(this.a) * Math.cosh(this.b),
-            Math.sin(this.a) * Math.sinh(this.b)
-        )
+    getElementsByClassName(className) {
+        return this.filter(n => n.element.classList?.contains(className));
     }
-    get sin(){
-        return complex(
-            Math.sin(this.a) * Math.cosh(this.b),
-            Math.cos(this.a) * Math.sinh(this.b)
-        )
+    querySelector(selector) {
+        const el = globalThis?.document?.querySelector(selector);
+        if (!el) return null;
+        return this.find(ui => ui.element === el) || null;
     }
-    get tan(){
-        const D=cos(this.a*2)+cosh(this.b*2);
-        return complex(
-            Math.sin(2 * this.a) / D,
-            Math.sinh(2 * this.b) / D
-        );
+    querySelectorAll(selector) {
+        const els = globalThis?.document?.querySelectorAll(selector);
+        return Array.from(els)
+            .map(el => this.find(ui => ui.element === el))
+            .filter(Boolean);
     }
 }
-const complex=(a,b)=>{
-    if((a instanceof Array||ArrayBuffer.isView(a)) && (b instanceof Array||ArrayBuffer.isView(a)))return a.map((n,i)=>complex(a[i],b[i]));
-    if(a.isMatrix?.() && b.isMatrix?.()){
-        if((a.shape[0]!==b.shape[0])||(a.shape[1]!==b.shape[1]))return Error(0)
-        const arr=a.arr.map((n,i)=>complex(a.arr[i],b.arr[i]));
-        return new a.constructor(a.rows,a.cols,...arr)
-    }
-    return new Complex(a,b)
-};
-
-const PRECESION = 8;
 
-const abs = (...x) => mapfun(
-    x =>{
-        if(x.isComplex?.()) return x.z;
-        return Math.abs(x)
+// create the singleton
+const __UI__ = new UIStore();
+
+const __Config__ = {
+    default:{
+        target:null,
+        render:true,
+        // math:{
+        //     mode:"deg"
+        // }
     },
-    ...x
-);
-
-const pow = (...x) => {
-    const n = x.pop();
-    return mapfun(
-        x => {
-            if(x.isComplex?.()) {
-                if(n.isComplex?.()) return new x.constructor({
-                    z: Math.exp(n.a * Math.log(x.z) - n.b * x.phi),
-                    phi: n.b * Math.log(x.z) + n.a * x.phi
-                })
-                return new x.constructor({z: x.z ** n, phi: x.phi * n});
-            }
-            if(n.isComplex?.()) return new x.constructor({
-                    z: Math.exp(n.a * Math.log(x)),
-                    phi: n.b * Math.log(x)
-            })
-            return Math.pow(x, n)
-        },
-        ...x
-    )
-};
-
-const sqrt = (...x) => mapfun(
-    x=>{
-        if(x.isComplex?.()) 
-            return new x.constructor({z: x.z**(1/2), phi: x.phi/2});
-        if(x < 0) return complex(0, Math.sqrt(-x)).toFixed(PRECESION)
-        return + Math.sqrt(x).toFixed(PRECESION);
+    setDefault:function(pairs){
+        const keys=Object.keys(pairs);
+        const values=Object.values(pairs);
+        for(let i=0; i<keys.length; i++) this.default[keys[i]]=values[i];
     },
-    ...x
-);
-
-const cbrt = (...x) => mapfun(
-    x=>{
-        if(x.isComplex?.()) 
-            return new x.constructor({z: x.z**(1/3), phi: x.phi/3}).toFixed(PRECESION)
-        return + Math.cbrt(x).toFixed(PRECESION);
-    },
-    ...x
-);
-
-const nthr = (...x) => {
-    const n = x.pop();
-    if(typeof n !== 'number') throw Error('nthr expects a real number n');
-    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 
-                ? complex(0, (-x)**(1/n)).toFixed(PRECESION)
-                : + (-1 * (-x)**(1/n)).toFixed(PRECESION)                
-            return + (x**(1/n)).toFixed(PRECESION)
-        },
-        ...x
-    )
-};
-
-const croot = (...x) =>{
-    const c = x.pop();
-    if(!c.isComplex?.()) throw Error('croot expect Complex number as root')
-    return mapfun(
-        x => {
-            if(typeof x === 'number') x = new c.constructor(x, 0);
-            const {a : c_a, b : c_b} = c;
-            const {z, phi} = x;
-            const D = Math.hypot(c_a, c_b);
-            const A = Math.exp((Math.log(z)*c_a + phi*c_b)/D);
-            const B = (phi*c_a - Math.log(z)*c_b)/D;
-            return new c.constructor(
-                A * Math.cos(B),
-                A * Math.sin(B)
-            ).toFixed(PRECESION)
-        },
-        ...x
-    )
-};
-
-const exp = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            Math.exp(x.a) * Math.cos(x.b),
-            Math.exp(x.a) * Math.sin(x.b)
-        ).toFixed(PRECESION);
-        return + Math.exp(x).toFixed(PRECESION)
-    }
-    ,...x
-);
-
-const ln = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            Math.log(x.z),
-            x.phi
-        ).toFixed(PRECESION);
-        return + Math.log(x).toFixed(PRECESION)
-    }
-    ,...x
-);
-
-const sign = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()){
-            const {z, phi} = x;
-            if(z===0) return new x.constructor(0, 0);
-            return new x.constructor({z:1, phi})
-        }
-        return Math.sign(x)
-    }
-    ,...x
-);
-
-const floor = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            Math.floor(x.a),
-            Math.floor(x.b)
-        )
-        return Math.floor(x)
-    },
-    ...x
-);
-const ceil = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            Math.ceil(x.a),
-            Math.ceil(x.b)
-        )
-        return Math.ceil(x)
-    },
-    ...x
-);
-const round = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            Math.round(x.a),
-            Math.round(x.b)
-        )
-        return Math.round(x)
-    },
-    ...x
-);
-
-const trunc = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            Math.trunc(x.a),
-            Math.trunc(x.b)
-        )
-        return Math.trunc(x)
-    },
-    ...x
-);
-
-const fract = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            x.a - Math.trunc(x.a),
-            x.b - Math.trunc(x.b)
-        )
-        return x - Math.trunc(x)
-    },
-    ...x
-);
-
-const cos$1 = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) return new x.constructor(
-            Math.cos(x.a) * Math.cosh(x.b),
-            -Math.sin(x.a) * Math.sinh(x.b)
-        ).toFixed(PRECESION);
-        return + Math.cos(x).toFixed(PRECESION)
-    }
-    ,...x
-);
-
-const sin$1 = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex) return new x.constructor(
-            Math.sin(x.a) * Math.cosh(x.b),
-            Math.cos(x.a) * Math.sinh(x.b)
-        ).toFixed(PRECESION);
-        return + Math.sin(x).toFixed(PRECESION)
-    }
-    , ...x
-);
-
-const tan = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex){
-            const D = Math.cos(2*x.a) + Math.cosh(2*x.b);
-            return new x.constructor(
-                Math.sin(2*x.a) / D,
-                Math.sinh(2*x.b) / D
-            ).toFixed(PRECESION);
-        } 
-        return + Math.tan(x).toFixed(PRECESION)
-    },
-    ...x
-);
-
-const sec = (...x) => mapfun(
-    x => {
-        if(x.isComplex?.()) ;
-        return + (1 / Math.cos(x)).toFixed(PRECESION)
-    }
-    ,...x
-);
-
-const acos = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex){
-            const { a, b } = x;
-            const Rp = Math.hypot(a + 1, b);
-            const Rm = Math.hypot(a - 1, b);
-            globalThis.Rp = Rp;
-            globalThis.Rm = Rm;
-            return new x.constructor(
-                Math.acos((Rp - Rm) / 2),
-                -Math.acosh((Rp + Rm) / 2),
-            ).toFixed(PRECESION)
-        } 
-        return + Math.acos(x).toFixed(PRECESION) 
-    },
-    ...x
-);
-
-const asin = (...x) => mapfun(
-    x => {
-        if(x?.isComplex){
-            const { a, b } = x;
-            const Rp = Math.hypot(a + 1, b);
-            const Rm = Math.hypot(a - 1, b);
-            return new x.constructor(
-                Math.asin((Rp - Rm) / 2), 
-                Math.acosh((Rp + Rm) / 2)
-            ).toFixed(PRECESION);
-        }
-        return + Math.asin(x).toFixed(PRECESION);
-    },
-    ...x
-);
-
-const atan = (...x) => mapfun(
-    x => {
-        if(x?.isComplex){
-            const { a, b } = x;
-            return new x.constructor(
-                Math.atan((a*2/(1-a**2-b**2)))/2,
-                Math.log((a**2 + (1+b)**2)/(a**2 + (1-b)**2))/4
-            ).toFixed(PRECESION)
-        }
-        return + Math.atan(x).toFixed(PRECESION);
-    },
-    ...x
-);
-
-const acot = (...x) => mapfun(
-    x => {
-        if(x?.isComplex){
-            const { a, b } = x;
-            return new x.constructor(
-                Math.atan(2*a/(a**2+(b-1)*(b+1)))/2,
-                Math.log((a**2 + (b-1)**2)/(a**2 + (b+1)**2))/4   
-            ).toFixed(PRECESION)
-        }
-        return + (Math.PI/2 - Math.atan(x)).toFixed(PRECESION);
-    },
-    ...x
-);
-
-
-const cosh$1 = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex) return new x.constructor(
-            Math.cosh(x.a) * Math.cos(x.b),
-            Math.sinh(x.a) * Math.sin(x.b)
-        ).toFixed(PRECESION); 
-        return + Math.cosh(x).toFixed(PRECESION)
-    },
-    ...x
-);
-const sinh = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex) return new x.constructor(
-            Math.sinh(x.a) * Math.cos(x.b),
-            Math.cosh(x.a) * Math.sin(x.b)
-        ).toFixed(PRECESION); 
-        return + Math.sinh(x).toFixed(PRECESION)
-    },
-    ...x
-);
-const tanh = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex){
-            const D = Math.cosh(2*a) + Math.cos(2*b);
-            return new x.constructor(
-                Math.sinh(2*a) / D,
-                Math.sin(2*b) / D
-            ).toFixed(PRECESION)
-        } 
-        return + Math.tanh(x).toFixed(PRECESION)
-    },
-    ...x
-);
-
-const coth = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex){
-            const {a, b} = x;
-            const D = (Math.sinh(a)**2)*(Math.cos(b)**2) + (Math.cosh(a)**2)*(Math.sin(b)**2); 
-            return new x.constructor(
-                Math.cosh(a) * Math.sinh(a) / D,
-                - Math.sin(b) * Math.cos(b) / D
-            ).toFixed(PRECESION)
-        } 
-        return + (1 / Math.tanh(x)).toFixed(PRECESION)
-    },
-    ...x
-);
-
-const acosh = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex){
-            return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).sub(1))))
-        } 
-        return + Math.acosh(x).toFixed(PRECESION)
-    },
-    ...x
-);
-
-const asinh = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex){
-            return ln(x.clone().add(sqrt(x.clone().mul(x.clone()).add(1))))
-        } 
-        return + Math.asinh(x).toFixed(PRECESION)
-    },
-    ...x
-);
-
-const atanh = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex); 
-        return + Math.atanh(x).toFixed(PRECESION)
-    },
-    ...x
-);
-
-const sig = (...x) => mapfun(
-    x =>{
-        if(x?.isComplex); 
-        return 1/(1 + Math.exp(-x)).toFixed(PRECESION)
-    },
-    ...x
-);
-
-const arithmetic_helper=(op, x, y)=>{
-    if(typeof x === 'number'){
-        if(typeof y === 'number'){
-            switch(op){
-                case 'add' : return x + y;
-                case 'sub' : return x - y;
-                case 'mul' : return x * y;
-                case 'div' : return x / y;
-                case 'modulo' : return x % y;
-            }
-        }
-        if(y?.isComplex?.()) x = new y.constructor(x, 0);
-        if(y?.isMatrix?.()) x = y.constructor.nums(y.rows, y.cols, x);
-        return x[op](y)
-    }
-    if(x?.isComplex?.()){
-        if(typeof y === 'number' || y?.isComplex?.()) return x.clone()[op](y);
-        if(y?.isMatrix?.()){
-            x = y.constructor.nums(y.rows, y.cols, x);
-            return x.clone()[op](y)
-        }
-    }
-    if(x?.isMatrix?.()){
-        return x.clone()[op](y)
-    }    
-};
-const add=(a,...b)=>{
-    let res = a;
-    for(let i=0; i<b.length; i++)
-        res = arithmetic_helper('add', res, b[i]);
-    return res;
-};
-const sub=(a,...b)=>{
-    let res = a;
-    for(let i=0; i<b.length; i++)
-        res = arithmetic_helper('sub', res, b[i]);
-    return res;
-};
-const mul=(a,...b)=>{
-    let res = a;
-    for(let i=0; i<b.length; i++)
-        res = arithmetic_helper('mul', res, b[i]);
-    return res;
-};
-const div=(a,...b)=>{
-    let res = a;
-    for(let i=0; i<b.length; i++)
-        res = arithmetic_helper('div', res, b[i]);
-    return res;
-};
-const modulo=(a,...b)=>{
-    let res = a;
-    for(let i=0; i<b.length; i++)
-        res = arithmetic_helper('modulo', res, b[i]);
-    return res;
-};
-
-const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
-const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
-
-const norm = (x, min, max) => apply_fun(
-    x, 
-    v => min !== max ? (v - min) / (max - min) : 0
-);
-const lerp = (x, min, max) => apply_fun(
-    x, 
-    v => (max - min) * v + min
-);
-const clamp = (x, min, max) => apply_fun(
-    x, 
-    v => Math.min(Math.max(v, min), max)
-);
-const map$1 = (x, a, b, c, d) => apply_fun(
-    x, 
-    v => lerp(norm(v, a, b), c, d)
-);
-
-const hypot = (...x) => {
-  const c0 = x.find(a => a.isComplex?.());
-  if (c0) {
-    const W = x.map(n => n.isComplex?.() ? n : new c0.constructor(n, 0));
-    return Math.hypot(...W.map(c => c.z));
-  }
-  return Math.hypot(...x);
-};
-
-
-const atan2 = (y, x, rad = true) => {
-    if (y instanceof Array && !(x instanceof Array))
-        return mapfun(n => atan2(n, x, rad), ...y);
-
-    if (x instanceof Array && !(y instanceof Array))
-        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));
-
-    const phi = Math.atan2(y, x);
-    return rad ? phi : phi * 180 / Math.PI;
-};
-
-class UINode {
-    constructor(node){
-        this.cache = {
-            node
-        };
-    }
-    isUINode(){
-        return true
-    }
-    get node(){
-        return this.cache.node;
-    } 
-}
-
-// globalThis.node = (node) => new UINode(node);
-
-function parseQueryParams(queryString) {
-    const params = {};
-    queryString.replace(/[A-Z0-9]+?=([\w|:|\/\.]*)/gi, (match) => {
-        const [key, value] = match.split('=');
-        params[key] = value;
-    });
-    return params;
-}
-
-function defineParamsGetter(target ){
-    Object.defineProperties(target, {
-        'QueryParams': {
-            get: function() {
-                return parseQueryParams(globalThis.location.search.substring(1));
-            },
-            configurable: false,
-            enumerable: true 
-        },
-        'HashParams': {
-            get: function() {
-                const hash = globalThis.location.hash.substring(1);
-                return hash.split("#");
-            },
-            configurable: false,
-            enumerable: true 
-        }
-    });
-}
-
-class UIStore extends Array {
-    constructor(...args) {
-        super(...args); 
-    }
-    clear(){
-        this.length = 0;
-        return this;
-    }
-    getItemById(id) {
-        return this.find(n => n.element.id === id);
-    }
-    getItemsByTagName(tag) {
-        return this.filter(n => n.element.tagName.toLowerCase() === tag.toLowerCase());
-    }
-    getElementsByClassName(className) {
-        return this.filter(n => n.element.classList?.contains(className));
-    }
-    querySelector(selector) {
-        const el = globalThis?.document?.querySelector(selector);
-        if (!el) return null;
-        return this.find(ui => ui.element === el) || null;
-    }
-    querySelectorAll(selector) {
-        const els = globalThis?.document?.querySelectorAll(selector);
-        return Array.from(els)
-            .map(el => this.find(ui => ui.element === el))
-            .filter(Boolean);
-    }
-}
-
-// create the singleton
-const __UI__ = new UIStore();
-
-const __Config__ = {
-    default:{
-        target:null,
-        render:true,
-        // math:{
-        //     mode:"deg"
-        // }
-    },
-    setDefault:function(pairs){
-        const keys=Object.keys(pairs);
-        const values=Object.values(pairs);
-        for(let i=0; i<keys.length; i++) this.default[keys[i]]=values[i];
-    },
-    init:()=>{
-        // document.documentElement.setAttribute("data-engine","zikojs")
+    init:()=>{
+        // document.documentElement.setAttribute("data-engine","zikojs")
     },
     renderingMode :"spa",
     isSSC : false,
@@ -1250,7 +274,7 @@ const parse_props = (props = {}) => {
 };
 
 __init__global__();
-class UIElementCore extends UINode{
+let UIElement$1 = class UIElement extends UINode{
   constructor(){
     super();
   }
@@ -1336,7 +360,7 @@ class UIElementCore extends UINode{
   isUIElement(){
     return true;
   }
-}
+};
 
 function register_to_class(target, ...mixins){
     mixins.forEach(n => _register_to_class_(target, n));
@@ -1355,28 +379,6 @@ function _register_to_class_(target, mixin) {
   }
 }
 
-// export function mount(target = this.target) {
-//   if(this.isBody) return ;
-//   if(target?.isUIElement)target=target.element;
-//   this.target=target;
-//   this.target?.appendChild(this.element);
-//   return this;
-// }
-// export function unmount(){
-//   if(this.cache.parent)this.cache.parent.remove(this);
-//   else if(this.target?.children?.length && [...this.target?.children].includes(this.element)) this.target.removeChild(this.element);
-//   return this;
-// }
-
-// export function mountAfter(target = this.target, t = 1) {
-//   setTimeout(() => this.mount(), t);
-//   return this;
-// }
-// export function unmountAfter(t = 1) {
-//   setTimeout(() => this.unmount(), t);
-//   return this;
-// }
-
 function mount(target = this.target, delay = 0) {
     if (delay > 0) {
         setTimeout(() => this.mount(target, 0), delay);
@@ -1418,9 +420,6 @@ var LifecycleMethods = /*#__PURE__*/Object.freeze({
 
 const STATE_GETTER = Symbol.for("ziko/hooks/STATE_GETTER");
 
-// import { __init__global__ } from "../__ziko__/index.js";
-
-
 function useState(initialValue) {
     const state = {
         value: initialValue,
@@ -1529,7 +528,7 @@ var AttrsMethods = /*#__PURE__*/Object.freeze({
    setContentEditable: setContentEditable
 });
 
-class ZikoUIText extends UINode {
+class UIText extends UINode {
     constructor(...value) {
       super("span", "text", false, ...value);
       this.element = globalThis?.document?.createTextNode(...value);
@@ -1538,7 +537,7 @@ class ZikoUIText extends UINode {
       return true
     }
 }
-const text = (...str) => new ZikoUIText(...str);
+const text = (...str) => new UIText(...str);
 
 function append(...ele) {
   __addItem__.call(this, "append", "push", ...ele);
@@ -1679,7 +678,7 @@ var IndexingMethods = /*#__PURE__*/Object.freeze({
    map: map
 });
 
-function style$1(styles){
+function style(styles){
     if(!this.element?.style) return this;
     for(let key in styles){
         const value = styles[key];
@@ -1718,7 +717,7 @@ var StyleMethods = /*#__PURE__*/Object.freeze({
    hide: hide,
    show: show,
    size: size,
-   style: style$1
+   style: style
 });
 
 class EventController {
@@ -1920,28 +919,218 @@ const KeyListeners = {
     
 };
 
-const debounce=(fn,delay=1000)=>{
-    let id;
-    return (...args) => id ? clearTimeout(id) : setTimeout(()=>fn(...args),delay);
-};
-const throttle=(fn,delay)=>{
-    let lastTime=0;
-    return (...args) => {
-        const now = new Date().getTime();
-        if(now-lastTime < delay) return;
-        lastTime = now;
-        fn(...args); 
-    }
-};
-
-class ViewEvent extends CustomEvent {
-    constructor(type, detail, { bubbles = true, cancelable = true } = {}) {
-        super(type, { detail, bubbles, cancelable });
-    }
-}
+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();
+  }
 
-function register_view_event(
-    element,
+  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);
+
+class Clock extends Tick {
+  constructor(tickMs = 1000 / 60) {
+    super(tickMs, () => this._tick());
+    this.elapsed = 0;
+    this._lastTime = performance.now();
+    this._callbacks = new Set();
+  }
+
+  _tick() {
+    const now = performance.now();
+    const delta = now - this._lastTime;
+    this.elapsed += delta;
+    this._lastTime = now;
+
+    for (const cb of this._callbacks) {
+      cb({ elapsed: this.elapsed, delta });
+    }
+  }
+
+  onTick(cb) {
+    this._callbacks.add(cb);
+    return () => this._callbacks.delete(cb); 
+  }
+
+  reset() {
+    this.elapsed = 0;
+    this._lastTime = performance.now();
+  }
+
+  pause() {
+    super.stop();
+  }
+
+  resume() {
+    this._lastTime = performance.now();
+    super.start();
+  }
+}
+
+const clock = (tickMs) => new Clock(tickMs);
+
+
+/* 
+
+    const clock = new Clock(200);
+
+    clock.onTick(({ elapsed, delta }) => {
+      console.log(`Elapsed: ${elapsed.toFixed(0)}ms, Delta: ${delta.toFixed(0)}ms`);
+    });
+
+    clock.start();
+
+    setTimeout(() => clock.pause(), 1000);  
+    setTimeout(() => clock.resume(), 2000); 
+
+*/
+
+const debounce=(fn,delay=1000)=>{
+    let id;
+    return (...args) => id ? clearTimeout(id) : setTimeout(()=>fn(...args),delay);
+};
+
+class TimeScheduler {
+  constructor(tasks = [], { repeat = 1, loop = false } = {}) {
+    this.tasks = tasks;
+    this.repeat = repeat;
+    this.loop = loop;
+
+    this.stopped = false;
+    this.running = false;
+
+    // lifecycle hooks
+    this.onStart = null;
+    this.onTask = null;
+    this.onEnd = null;
+  }
+
+  async run() {
+    if (this.running) return;
+    this.running = true;
+    this.stopped = false;
+
+    if (this.onStart) this.onStart();
+
+    let repeatCount = this.repeat;
+
+    do {
+      for (const task of this.tasks) {
+        if (this.stopped) return;
+
+        if (Array.isArray(task)) {
+          // Parallel tasks
+          await Promise.all(
+            task.map(({ fn, delay = 0 }) =>
+              new Promise(async (resolve) => {
+                if (delay > 0) await new Promise(r => setTimeout(r, delay));
+                if (this.onTask) this.onTask(fn);
+                await fn();
+                resolve();
+              })
+            )
+          );
+        } else {
+          // Single task
+          const { fn, delay = 0 } = task;
+          if (delay > 0) await new Promise(r => setTimeout(r, delay));
+          if (this.onTask) this.onTask(fn);
+          await fn();
+        }
+      }
+    } while (this.loop && !this.stopped && (repeatCount === Infinity || repeatCount-- > 1));
+
+    if (!this.stopped && this.onEnd) this.onEnd();
+    this.running = false;
+  }
+
+  stop() {
+    this.stopped = true;
+    this.running = false;
+  }
+
+  addTask(task) {
+    this.tasks.push(task);
+  }
+
+  clearTasks() {
+    this.tasks = [];
+  }
+}
+
+const Scheduler = (tasks, { repeat = null} = {}) => new TimeScheduler(tasks, { repeat});
+
+const sleep= ms => new Promise(res => setTimeout(res, ms));
+
+const throttle=(fn,delay)=>{
+    let lastTime=0;
+    return (...args) => {
+        const now = new Date().getTime();
+        if(now-lastTime < delay) return;
+        lastTime = now;
+        fn(...args); 
+    }
+};
+
+function timeout(ms, fn) {
+  let id;
+  const promise = new Promise((resolve) => {
+    id = setTimeout(() => {
+      if (fn) fn();
+      resolve();
+    }, ms);
+  });
+
+  return {
+    id,
+    clear: () => clearTimeout(id),
+    promise
+  };
+}
+
+class ViewEvent extends CustomEvent {
+    constructor(type, detail, { bubbles = true, cancelable = true } = {}) {
+        super(type, { detail, bubbles, cancelable });
+    }
+}
+
+function register_view_event(
+    element,
     {
         intersection = true,
         resize = true,
@@ -2097,7 +1286,7 @@ function register_swipe_event(
   };
 }
 
-class UIElement extends UIElementCore{
+class UIElement extends UIElement$1{
   constructor({element, name ='', type = 'html', render = __Ziko__.__Config__.default.render, props}={}){
     super();
     this.exp = {
@@ -2211,95 +1400,6 @@ class UIElement extends UIElementCore{
 
 }
 
-const is_primitive = (value) => typeof value !== 'object' && typeof value !== 'function' || value === null;
-
-const call_with_optional_props = (Component) => {
-    return (...args) => {
-        const first = args[0];
-
-        const isChild = first?.isUIElement?.() || is_primitive(first);
-
-        if (isChild) {
-            return new Component({}, ...args);
-        }
-
-        return new Component(first, ...args.slice(1));
-    };
-};
-
-function add_vendor_prefix(property) {
-	const propertyUC = property.slice(0, 1).toUpperCase() + property.slice(1);
-	const vendors = ['Webkit', 'Moz', 'O', 'ms'];
-	for(let i = 0, len = vendors.length; i < len; i++) {
-		const vendor = vendors[i];
-		if(typeof (globalThis?.document?.body).style[vendor + propertyUC] !== 'undefined') return vendor + propertyUC;
-	}
-	return property;
-}
-const normalize_css_value = value => typeof value === 'number' ? value+'px' : value;
-const add_class = (UIElement, name) => UIElement.element.className = UIElement.element.className.replace(/\s+$/gi, '') + ' ' + name;
-const remove_class =(UIElement, name) => UIElement.element.className = UIElement.element.className.replace(name, '');
-
-// const addSuffixeToNumber=(value,suffixe="px")=>{
-//   if(typeof value === "number") value+=suffixe;
-//   if(value instanceof Array)value=value.map(n=>typeof n==="number"?n+=suffixe:n).join(" ");
-//   return value;
-// }
-
-// const Id = (a) => document.getElementById(a);
-// const Class = (a) => [...document.getElementsByClassName(a)];
-// const $=(...selector)=>{
-//   var ele=[]
-//   for(let i=0;i<selector.length;i++){
-//     if(typeof selector[i]=="string")ele.push(...document.querySelectorAll(selector[i]));
-//     if(selector[i] instanceof UIElement)ele.push(selector[i].element)
-//   }
-//   return ele.length===1?ele[0]:ele;
-// }
-
-const style = (el, styles) => {if(el)Object.assign(el.style, styles);};
-
-function script(src) {
-  const Script = document?.createElement("script");
-  Script.setAttribute("src", src);
-  document.head.appendChild(Script);
-}
-function linkStyle(href) {
-  const link = document?.createElement("link");
-  link.setAttribute("rel", "stylesheet");
-  link.setAttribute("href", href);
-  document.head.appendChild(link);
-}
-const CloneElement = (UIElement) => {
-  var clone = new UIElement.__proto__.constructor();
-  //waitForUIElm(UIElement).then(e=>console.log(e)).then(()=>clone = new UIElement.__proto__.constructor())
-  //let a = new UIElement.__proto__.constructor()
-  return clone;
-};
-const cloneUI=UIElement=>{
-  return Object.assign(Object.create(Object.getPrototypeOf(UIElement)),UIElement)
-};
-// function isPrimitive(value) {
-//     return typeof value !== 'object' && typeof value !== 'function' || value === null;
-// }
-const waitElm=(UIElement)=>{
-    return new Promise(resolve => {
-        if (UIElement) {
-            return resolve(UIElement);
-        }
-        const observer = new MutationObserver(() => {
-            if (UIElement) {
-                resolve(UIElement);
-                observer.disconnect();
-            }
-        });
-        observer.observe(document?.body, {
-            childList: true,
-            subtree: true
-        });
-    });
-  };
-
 const HTMLTags = [
   'a',
   'abb',
@@ -2459,443 +1559,6 @@ const tags = new Proxy({}, {
   }
 });
 
-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();
-    }
-  }
-
-  // ---- 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);
-
-class Clock extends Tick {
-  constructor(tickMs = 1000 / 60) {
-    super(tickMs, () => this._tick());
-    this.elapsed = 0;
-    this._lastTime = performance.now();
-    this._callbacks = new Set();
-  }
-
-  _tick() {
-    const now = performance.now();
-    const delta = now - this._lastTime;
-    this.elapsed += delta;
-    this._lastTime = now;
-
-    for (const cb of this._callbacks) {
-      cb({ elapsed: this.elapsed, delta });
-    }
-  }
-
-  onTick(cb) {
-    this._callbacks.add(cb);
-    return () => this._callbacks.delete(cb); 
-  }
-
-  reset() {
-    this.elapsed = 0;
-    this._lastTime = performance.now();
-  }
-
-  pause() {
-    super.stop();
-  }
-
-  resume() {
-    this._lastTime = performance.now();
-    super.start();
-  }
-}
-
-const clock = (tickMs) => new Clock(tickMs);
-
-
-/* 
-
-    const clock = new Clock(200);
-
-    clock.onTick(({ elapsed, delta }) => {
-      console.log(`Elapsed: ${elapsed.toFixed(0)}ms, Delta: ${delta.toFixed(0)}ms`);
-    });
-
-    clock.start();
-
-    setTimeout(() => clock.pause(), 1000);  
-    setTimeout(() => clock.resume(), 2000); 
-
-*/
-
-class TimeScheduler {
-  constructor(tasks = [], { repeat = 1, loop = false } = {}) {
-    this.tasks = tasks;
-    this.repeat = repeat;
-    this.loop = loop;
-
-    this.stopped = false;
-    this.running = false;
-
-    // lifecycle hooks
-    this.onStart = null;
-    this.onTask = null;
-    this.onEnd = null;
-  }
-
-  async run() {
-    if (this.running) return;
-    this.running = true;
-    this.stopped = false;
-
-    if (this.onStart) this.onStart();
-
-    let repeatCount = this.repeat;
-
-    do {
-      for (const task of this.tasks) {
-        if (this.stopped) return;
-
-        if (Array.isArray(task)) {
-          // Parallel tasks
-          await Promise.all(
-            task.map(({ fn, delay = 0 }) =>
-              new Promise(async (resolve) => {
-                if (delay > 0) await new Promise(r => setTimeout(r, delay));
-                if (this.onTask) this.onTask(fn);
-                await fn();
-                resolve();
-              })
-            )
-          );
-        } else {
-          // Single task
-          const { fn, delay = 0 } = task;
-          if (delay > 0) await new Promise(r => setTimeout(r, delay));
-          if (this.onTask) this.onTask(fn);
-          await fn();
-        }
-      }
-    } while (this.loop && !this.stopped && (repeatCount === Infinity || repeatCount-- > 1));
-
-    if (!this.stopped && this.onEnd) this.onEnd();
-    this.running = false;
-  }
-
-  stop() {
-    this.stopped = true;
-    this.running = false;
-  }
-
-  addTask(task) {
-    this.tasks.push(task);
-  }
-
-  clearTasks() {
-    this.tasks = [];
-  }
-}
-
-const Scheduler = (tasks, { repeat = null} = {}) => new TimeScheduler(tasks, { repeat});
-
-const step_fps = (step_or_fps) => 1000 / step_or_fps;
-
-const sleep= ms => new Promise(res => setTimeout(res, ms));
-function timeout(ms, fn) {
-  let id;
-  const promise = new Promise((resolve) => {
-    id = setTimeout(() => {
-      if (fn) fn();
-      resolve();
-    }, ms);
-  });
-
-  return {
-    id,
-    clear: () => clearTimeout(id),
-    promise
-  };
-}
-
-class TimeLoop {
-  constructor(callback, { step = 1000, t0 = 0, t1 = Infinity, autoplay = true } = {}) {
-    this.callback = callback;
-    this.cache = {
-      isRunning: false,
-      id: null,
-      last_tick: null,
-      step,
-      t0,
-      t1,
-      autoplay,
-      pauseTime: null,
-      frame : 0,
-    };
-
-    if (autoplay) {
-      t0 ? this.startAfter(t0) : this.start();
-      if (t1 !== Infinity) this.stopAfter(t1);
-    }
-  }
-
-  get frame(){
-    return this.cache.frame;
-  }
-  get elapsed(){
-    return this.cache.elapsed;
-  }
-
-  start() {
-    if (!this.cache.isRunning) {
-      this.cache.frame = 0;
-      this.cache.isRunning = true;
-      this.cache.last_tick = Date.now();
-      this.animate();
-    }
-    return this;
-  }
-
-  pause() {
-    if (this.cache.isRunning) {
-      clearTimeout(this.cache.id);
-      this.cache.isRunning = false;
-      this.cache.pauseTime = Date.now();
-    }
-    return this;
-  }
-
-  resume() {
-    if (!this.cache.isRunning) {
-      this.cache.isRunning = true;
-      if (this.cache.pauseTime) {
-        // adjust start time so delta stays consistent
-        const pausedDuration = Date.now() - this.cache.pauseTime;
-        this.cache.last_tick += pausedDuration;
-      }
-      this.animate();
-    }
-    return this;
-  }
-
-  stop() {
-    this.pause();
-    this.cache.frame = 0;
-    return this;
-  }
-
-  startAfter(t = 1000) {
-    setTimeout(() => this.start(), t);
-    return this;
-  }
-
-  stopAfter(t = 1000) {
-    setTimeout(() => this.stop(), t);
-    return this;
-  }
-
-  animate = () => {
-    if (this.cache.isRunning) {
-      const now = Date.now();
-      const delta = now - this.cache.last_tick;
-
-      if (delta >= this.cache.step) {
-        this.cache.elapsed = now - (this.cache.t0 || 0);
-        this.callback(this);
-        this.cache.frame++;
-        this.cache.last_tick = now - (delta % this.cache.step);
-      }
-
-      this.cache.id = setTimeout(this.animate, 0);
-    }
-  }
-}
-
-const loop = (callback, options = {}) => new TimeLoop(callback, options);
-
-
-// Helpers
-// const useFps = (fps) => 1000 / fps;
-
-// const _loop = loop( e => {
-//   console.log("Frame:", e.frame, " Elapsed: ", e.elapsed);
-// });
-
-const time_memory_Taken = (callback) => {
-    const t0 = Date.now();
-    const m0 = performance.memory.usedJSHeapSize;
-    const result = callback();
-    const t1 = Date.now();
-    const m1 = performance.memory.usedJSHeapSize;
-    const elapsedTime = t1 - t0;
-    const usedMemory = m1 - m0;
-    return { 
-        elapsedTime,
-        usedMemory, 
-        result 
-    };
-  };
-
-const waitForUIElm=(UIElement)=>{
-    return new Promise(resolve => {
-        if (UIElement.element) {
-            return resolve(UIElement.element);
-        }
-  
-        const observer = new MutationObserver(() => {
-            if (UIElement.element) {
-                resolve(UIElement.element);
-                observer.disconnect();
-            }
-        });
-  
-        observer.observe(document?.body, {
-            childList: true,
-            subtree: true
-        });
-    });
-  };
-  const waitForUIElmSync=(UIElement,timeout=2000)=>{
-    const t0=Date.now();
-    while(Date.now()-t0<timeout){
-      if(UIElement.element)return UIElement.element
-    }
-  };
-
-// import Ease from "./ease.js";
-const wait=(delayInMS)=>{
-    return new Promise((resolve) => setTimeout(resolve, delayInMS));
-};
-const timeTaken = callback => {
-    console.time('timeTaken');
-    const r = callback();
-    console.timeEnd('timeTaken');
-    return r;
-};
-
 function useDerived(deriveFn, sources) {
     const getValue = () => deriveFn(...sources.map(source => source().value));
 
@@ -3100,77 +1763,38 @@ if(globalThis?.document){
 exports.ClickAwayEvent = ClickAwayEvent;
 exports.ClickListeners = ClickListeners;
 exports.Clock = Clock;
-exports.CloneElement = CloneElement;
 exports.E = E;
 exports.EPSILON = EPSILON;
 exports.EventController = EventController;
 exports.KeyListeners = KeyListeners;
 exports.PI = PI;
 exports.PtrListeners = PtrListeners;
-exports.Random = Random;
 exports.Scheduler = Scheduler;
 exports.SwipeEvent = SwipeEvent;
 exports.Tick = Tick;
-exports.TimeAnimation = TimeAnimation;
-exports.TimeLoop = TimeLoop;
 exports.TimeScheduler = TimeScheduler;
 exports.UIElement = UIElement;
-exports.UINode = UINode;
 exports.ViewEvent = ViewEvent;
 exports.ViewListeners = ViewListeners;
-exports.ZikoUIText = ZikoUIText;
-exports.abs = abs;
-exports.accum_max = accum_max;
-exports.accum_min = accum_min;
-exports.accum_product = accum_product;
-exports.accum_sum = accum_sum;
-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.animation = animation;
-exports.asin = asin;
-exports.asinh = asinh;
-exports.atan = atan;
+exports.apply_fun = apply_fun;
 exports.atan2 = atan2;
-exports.atanh = atanh;
-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.constant2camelcase = constant2camelcase;
 exports.constant2hyphencase = constant2hyphencase;
 exports.constant2pascalcase = constant2pascalcase;
 exports.constant2snakecase = constant2snakecase;
-exports.contraharmonic_mean = contraharmonic_mean;
-exports.cos = cos$1;
-exports.cosh = cosh$1;
-exports.coth = coth;
-exports.croot = croot;
 exports.debounce = debounce;
 exports.deg2rad = deg2rad;
-exports.div = div;
-exports.ema = ema;
-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.interquartile_mean = interquartile_mean;
-exports.iqr = iqr;
 exports.isStateGetter = isStateGetter;
 exports.is_anagram = is_anagram;
 exports.is_camelcase = is_camelcase$1;
@@ -3178,83 +1802,30 @@ 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.is_snakeCase = is_snakeCase;
 exports.lerp = lerp;
-exports.linkStyle = linkStyle;
-exports.ln = ln;
-exports.loop = loop;
 exports.map = map$1;
-exports.mean = mean;
-exports.median = median;
-exports.midhinge = midhinge;
-exports.midrange = midrange;
-exports.modulo = modulo;
-exports.mul = mul;
+exports.mapfun = mapfun;
 exports.norm = norm;
-exports.normalize_css_value = normalize_css_value;
-exports.nthr = nthr;
-exports.parse_props = parse_props;
 exports.pascal2camelcase = pascal2camelcase;
 exports.pascal2constantcase = pascal2constantcase;
 exports.pascal2hyphencase = pascal2hyphencase;
 exports.pascal2snakecase = pascal2snakecase;
-exports.percentile = percentile;
-exports.pow = pow;
-exports.power_mean = power_mean;
-exports.q1 = q1;
-exports.q3 = q3;
 exports.rad2deg = rad2deg;
 exports.register_click_away_event = register_click_away_event;
 exports.register_swipe_event = register_swipe_event;
 exports.register_view_event = register_view_event;
-exports.remove_class = remove_class;
-exports.rms = rms;
-exports.rolling_std = rolling_std;
-exports.rolling_variance = rolling_variance;
-exports.round = round;
-exports.sample_std = sample_std;
-exports.sample_variance = sample_variance;
-exports.script = script;
-exports.sec = sec;
-exports.sig = sig;
-exports.sign = sign;
-exports.sin = sin$1;
-exports.sinh = sinh;
 exports.sleep = sleep;
-exports.sma = sma;
 exports.snake2camelcase = snake2camelcase;
 exports.snake2constantcase = snake2constantcase;
 exports.snake2hyphencase = snake2hyphencase;
 exports.snake2pascalcase = snake2pascalcase;
-exports.sqrt = sqrt;
-exports.std = std;
-exports.step_fps = step_fps;
-exports.style = style;
-exports.sub = sub;
 exports.tags = tags;
-exports.tan = tan;
-exports.tanh = tanh;
-exports.text = text;
 exports.throttle = throttle;
 exports.tick = tick;
-exports.timeTaken = timeTaken;
-exports.time_memory_Taken = time_memory_Taken;
 exports.timeout = timeout;
-exports.trimmed_mean = trimmed_mean;
-exports.trunc = trunc;
 exports.useDerived = useDerived;
 exports.useEffect = useEffect;
 exports.useEventEmitter = useEventEmitter;
 exports.useReactive = useReactive;
 exports.useState = useState;
-exports.variance = variance;
-exports.wait = wait;
-exports.waitElm = waitElm;
-exports.waitForUIElm = waitForUIElm;
-exports.waitForUIElmSync = waitForUIElmSync;
-exports.weighted_mean = weighted_mean;
-exports.weighted_std = weighted_std;
-exports.weighted_variance = weighted_variance;
-exports.winsorized_mean = winsorized_mean;
-exports.wma = wma;