ziko 1.1.0 → 1.2.0

package/dist/ziko.cjs

@@ -2,7 +2,7 @@
 /*
   Project: ziko.js
   Author: Zakaria Elalaoui
-  Date : Thu Jun 04 2026 14:34:29 GMT+0100 (UTC+01:00)
+  Date : Thu Jul 30 2026 14:31:45 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
@@ -15,18 +15,18 @@ const EPSILON=Number.EPSILON;
 
 const is_primitive = value => typeof value !== 'object' && typeof value !== 'function' || value === null;
 
-const mapfun=(fun,...X)=>{
+const mapfun$1=(fun,...X)=>{
     const Y=X.map(x=>{
         if(is_primitive(x) || x?.__mapfun__) return fun(x)
-        if(x instanceof Array) return x.map(n=>mapfun(fun,n));
+        if(x instanceof Array) return x.map(n=>mapfun$1(fun,n));
         if(ArrayBuffer.isView(x)) return x.map(n=>fun(n));
-        if(x instanceof Set) return new Set(mapfun(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 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)))
         else if(x instanceof Object){
             return Object.fromEntries(
                 Object.entries(x).map(
-                    n=>n=[n[0],mapfun(fun,n[1])]
+                    n=>n=[n[0],mapfun$1(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(fn, ...x);
+    if (x instanceof Array) mapfun$1(fn, ...x);
     return fn(x)
 };
 
@@ -527,7 +527,7 @@ const complex=(a,b)=>{
 
 const PRECESION = 8;
 
-const abs = (...x) => mapfun(
+const abs = (...x) => mapfun$1(
     x =>{
         if(x.isComplex?.()) return x.z;
         return Math.abs(x)
@@ -537,7 +537,7 @@ const abs = (...x) => mapfun(
 
 const pow$1 = (...x) => {
     const n = x.pop();
-    return mapfun(
+    return mapfun$1(
         x => {
             if(x.isComplex?.()) {
                 if(n.isComplex?.()) return new x.constructor({
@@ -556,7 +556,7 @@ const pow$1 = (...x) => {
     )
 };
 
-const sqrt$2 = (...x) => mapfun(
+const sqrt$2 = (...x) => mapfun$1(
     x=>{
         if(x.isComplex?.()) 
             return new x.constructor({z: x.z**(1/2), phi: x.phi/2});
@@ -566,7 +566,7 @@ const sqrt$2 = (...x) => mapfun(
     ...x
 );
 
-const cbrt = (...x) => mapfun(
+const cbrt = (...x) => mapfun$1(
     x=>{
         if(x.isComplex?.()) 
             return new x.constructor({z: x.z**(1/3), phi: x.phi/3}).toFixed(PRECESION)
@@ -578,7 +578,7 @@ const cbrt = (...x) => mapfun(
 const nthr = (...x) => {
     const n = x.pop();
     if(typeof n !== 'number') throw Error('nthr expects a real number n');
-    return mapfun(
+    return mapfun$1(
         x => {
             if(x.isComplex?.()) return new x.constructor({z: x.z ** (1/n), phi: x.phi / n});
             if(x<0) return n %2 ===2 
@@ -593,7 +593,7 @@ const nthr = (...x) => {
 const croot = (...x) =>{
     const c = x.pop();
     if(!c.isComplex?.()) throw Error('croot expect Complex number as root')
-    return mapfun(
+    return mapfun$1(
         x => {
             if(typeof x === 'number') x = new c.constructor(x, 0);
             const {a : c_a, b : c_b} = c;
@@ -610,7 +610,7 @@ const croot = (...x) =>{
     )
 };
 
-const exp$1 = (...x) => mapfun(
+const exp$1 = (...x) => mapfun$1(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.exp(x.a) * Math.cos(x.b),
@@ -621,7 +621,7 @@ const exp$1 = (...x) => mapfun(
     ,...x
 );
 
-const ln = (...x) => mapfun(
+const ln = (...x) => mapfun$1(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.log(x.z),
@@ -632,7 +632,7 @@ const ln = (...x) => mapfun(
     ,...x
 );
 
-const sign = (...x) => mapfun(
+const sign = (...x) => mapfun$1(
     x => {
         if(x.isComplex?.()){
             const {z, phi} = x;
@@ -644,7 +644,7 @@ const sign = (...x) => mapfun(
     ,...x
 );
 
-const floor = (...x) => mapfun(
+const floor = (...x) => mapfun$1(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.floor(x.a),
@@ -654,7 +654,7 @@ const floor = (...x) => mapfun(
     },
     ...x
 );
-const ceil = (...x) => mapfun(
+const ceil = (...x) => mapfun$1(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.ceil(x.a),
@@ -664,7 +664,7 @@ const ceil = (...x) => mapfun(
     },
     ...x
 );
-const round = (...x) => mapfun(
+const round = (...x) => mapfun$1(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.round(x.a),
@@ -675,7 +675,7 @@ const round = (...x) => mapfun(
     ...x
 );
 
-const trunc = (...x) => mapfun(
+const trunc = (...x) => mapfun$1(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.trunc(x.a),
@@ -686,7 +686,7 @@ const trunc = (...x) => mapfun(
     ...x
 );
 
-const fract = (...x) => mapfun(
+const fract = (...x) => mapfun$1(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             x.a - Math.trunc(x.a),
@@ -697,7 +697,7 @@ const fract = (...x) => mapfun(
     ...x
 );
 
-const cos$3 = (...x) => mapfun(
+const cos$3 = (...x) => mapfun$1(
     x => {
         if(x.isComplex?.()) return new x.constructor(
             Math.cos(x.a) * Math.cosh(x.b),
@@ -708,7 +708,7 @@ const cos$3 = (...x) => mapfun(
     ,...x
 );
 
-const sin$3 = (...x) => mapfun(
+const sin$3 = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex) return new x.constructor(
             Math.sin(x.a) * Math.cosh(x.b),
@@ -719,7 +719,7 @@ const sin$3 = (...x) => mapfun(
     , ...x
 );
 
-const tan = (...x) => mapfun(
+const tan = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex){
             const D = Math.cos(2*x.a) + Math.cosh(2*x.b);
@@ -733,7 +733,7 @@ const tan = (...x) => mapfun(
     ...x
 );
 
-const sec = (...x) => mapfun(
+const sec = (...x) => mapfun$1(
     x => {
         if(x.isComplex?.()) ;
         return + (1 / Math.cos(x)).toFixed(PRECESION)
@@ -741,7 +741,7 @@ const sec = (...x) => mapfun(
     ,...x
 );
 
-const acos$1 = (...x) => mapfun(
+const acos$1 = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex){
             const { a, b } = x;
@@ -759,7 +759,7 @@ const acos$1 = (...x) => mapfun(
     ...x
 );
 
-const asin = (...x) => mapfun(
+const asin = (...x) => mapfun$1(
     x => {
         if(x?.isComplex){
             const { a, b } = x;
@@ -775,7 +775,7 @@ const asin = (...x) => mapfun(
     ...x
 );
 
-const atan = (...x) => mapfun(
+const atan = (...x) => mapfun$1(
     x => {
         if(x?.isComplex){
             const { a, b } = x;
@@ -789,7 +789,7 @@ const atan = (...x) => mapfun(
     ...x
 );
 
-const acot = (...x) => mapfun(
+const acot = (...x) => mapfun$1(
     x => {
         if(x?.isComplex){
             const { a, b } = x;
@@ -804,7 +804,7 @@ const acot = (...x) => mapfun(
 );
 
 
-const cosh$2 = (...x) => mapfun(
+const cosh$2 = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex) return new x.constructor(
             Math.cosh(x.a) * Math.cos(x.b),
@@ -814,7 +814,7 @@ const cosh$2 = (...x) => mapfun(
     },
     ...x
 );
-const sinh$1 = (...x) => mapfun(
+const sinh$1 = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex) return new x.constructor(
             Math.sinh(x.a) * Math.cos(x.b),
@@ -824,7 +824,7 @@ const sinh$1 = (...x) => mapfun(
     },
     ...x
 );
-const tanh = (...x) => mapfun(
+const tanh = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex){
             const D = Math.cosh(2*a) + Math.cos(2*b);
@@ -838,7 +838,7 @@ const tanh = (...x) => mapfun(
     ...x
 );
 
-const coth = (...x) => mapfun(
+const coth = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex){
             const {a, b} = x;
@@ -853,7 +853,7 @@ const coth = (...x) => mapfun(
     ...x
 );
 
-const acosh = (...x) => mapfun(
+const acosh = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex){
             return ln(x.clone().add(sqrt$2(x.clone().mul(x.clone()).sub(1))))
@@ -863,7 +863,7 @@ const acosh = (...x) => mapfun(
     ...x
 );
 
-const asinh = (...x) => mapfun(
+const asinh = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex){
             return ln(x.clone().add(sqrt$2(x.clone().mul(x.clone()).add(1))))
@@ -873,7 +873,7 @@ const asinh = (...x) => mapfun(
     ...x
 );
 
-const atanh = (...x) => mapfun(
+const atanh = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex); 
         return + Math.atanh(x).toFixed(PRECESION)
@@ -881,7 +881,7 @@ const atanh = (...x) => mapfun(
     ...x
 );
 
-const sig = (...x) => mapfun(
+const sig = (...x) => mapfun$1(
     x =>{
         if(x?.isComplex); 
         return 1/(1 + Math.exp(-x)).toFixed(PRECESION)
@@ -889,8 +889,8 @@ const sig = (...x) => mapfun(
     ...x
 );
 
-const deg2rad = (...deg) => mapfun(x => x * Math.PI / 180, ...deg);
-const rad2deg = (...rad) => mapfun(x => x / Math.PI * 180, ...rad);
+const deg2rad = (...deg) => mapfun$1(x => x * Math.PI / 180, ...deg);
+const rad2deg = (...rad) => mapfun$1(x => x / Math.PI * 180, ...rad);
 
 const norm = (x, min, max) => apply_fun(
     x, 
@@ -921,10 +921,10 @@ const hypot = (...x) => {
 
 const atan2 = (y, x, rad = true) => {
     if (y instanceof Array && !(x instanceof Array))
-        return mapfun(n => atan2(n, x, rad), ...y);
+        return mapfun$1(n => atan2(n, x, rad), ...y);
 
     if (x instanceof Array && !(y instanceof Array))
-        return mapfun(n => atan2(y, n, rad), ...x);
+        return mapfun$1(n => atan2(y, n, rad), ...x);
 
     if (y instanceof Array && x instanceof Array)
         return y.map((v, i) => atan2(v, x[i], rad));
@@ -1161,7 +1161,7 @@ class Matrix{
         return new Matrix(this.rows, this.cols, this.arr.flat(1));
     }
     toComplex(){
-        this.arr = mapfun(
+        this.arr = mapfun$1(
             x => x?.isComplex?.() ? x : new Complex(x, 0),
             ...this.arr
         );
@@ -1625,7 +1625,7 @@ class Matrix{
         return new Matrix(v.length, 1, v);
     }
     serialize() {
-        const arr = mapfun(x => x.serialize?.() || x, ...this.arr);
+        const arr = mapfun$1(x => x.serialize?.() || x, ...this.arr);
         return JSON.stringify({
             type : 'matrix',
             data : {
@@ -1640,7 +1640,7 @@ class Matrix{
         const {type, data} = json;
         if(type !== 'matrix') return TypeError('Not a valid Matrix')
         let {arr} = data;
-        arr = mapfun(x => {
+        arr = mapfun$1(x => {
             if(typeof x === 'string') {
                 const x_obj = JSON.parse(x);
                 const {type} = x_obj;
@@ -1671,186 +1671,6 @@ const matrix2=(...element)=>new Matrix(2, 2, element);
 const matrix3=(...element)=>new Matrix(3, 3, element);
 const matrix4=(...element)=>new Matrix(4, 4, element);
 
-const zeros=(n)=>new Array(n).fill(0);
-const ones=(n)=>new Array(n).fill(1);
-const nums=(num,n)=>new Array(n).fill(num);
-
-const arange=(a, b, step , include = false)=>{
-    let tab = [];
-    if(a<b){
-        for (let i = a; include?i<=b:i<b; i += step) tab.push((i * 10) / 10);
-    }
-    else {
-        for(let i = a; include?i>=b:i>b; i -= step) tab.push((i * 10) / 10);
-    }
-    return tab;
-};
-const linspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
-    if(Math.floor(n)!==n)return;
-    if([a,b].every(n=>typeof n==="number")){
-        const [max,min]=[a,b].sort((a,b)=>b-a);
-        var Y = [];
-        let step ;
-        endpoint ? step = (max - min) / (n - 1) : step = (max - min) / n;
-        for (var i = 0; i < n; i++) {
-            a<b?Y.push(min+step*i):Y.push(max-step*i);
-        }
-        return Y
-    }
-
-    if([a,b].some(n=>n.isComplex?.())){
-        const z1 = new n.constructor(a);
-        const z2 = new n.constructor(b);
-        n=n||Math.abs(z1.a-z2.a)+1;
-        const X=linspace(z1.a,z2.a,n,endpoint);
-        const Y=linspace(z1.b,z2.b,n,endpoint);
-        let Z=new Array(n).fill(null);
-        Z=Z.map((n,i)=> new n.constructor(X[i],Y[i]));
-        return Z;
-    }
-};
-const logspace=(a,b,n=b-a+1,base=E,endpoint=true)=>{
-    return linspace(a,b,n,endpoint).map(n=>pow$1(base,n))
-};
-const geomspace=(a,b,n=abs(b-a)+1,endpoint=true)=>{
-    if(Math.floor(n)!==n)return;
-    if([a,b].every(n=>typeof n==="number")){
-        const [max,min]=[a,b].sort((a,b)=>b-a);
-        let base;
-        endpoint ? base = nthr(max/min,n-1) : base = nthr(max/min,n) ;
-        const Y = [min];
-        for (let i = 1; i < n; i++) {
-            Y.push(Y[i-1]*base);
-        }
-        return a<b?Y:Y.reverse()
-    }
-
-    if([a,b].some(n=>n.isComplex?.())){
-        const z1 = new n.constructor(a);
-        const z2 = new n.constructor(b);
-        n=n||Math.abs(z1.a-z2.a)+1;
-        let base;
-        endpoint ? base = nthr(z2.div(z1),n-1) : base = nthr(z2.div(z1),n) ;
-        const Y = [z1];
-        for (let i = 1; i < n; i++) {
-            Y.push(mul(Y[i-1],base));
-        } 
-        return Y;
-    }
-};
-
-/** @module Math */
-/**
- * Checks if a value is within the specified range.
- * @function
- * @param {number} x - The value to check.
- * @param {number} a - The start of the range.
- * @param {number} b - The end of the range.
- * @returns {boolean} Returns true if the value is within the range [a, b], otherwise false.
- */
-const inRange = (x, a, b) => {
-    const [min, max] = [Math.min(a, b), Math.max(a, b)];
-    return x >= min && x <= max;
-};
-
-/**
- * Checks if two numbers are approximately equal within a given error margin.
- * @param {number} a - The first number.
- * @param {number} b - The second number.
- * @param {number} [Err=0.0001] - The maximum acceptable difference between the two numbers.
- * @returns {boolean} Returns true if the two numbers are approximately equal within the specified error margin, otherwise false.
- */
-const isApproximatlyEqual = (a, b, Err = 0.0001) => {
-    return Math.abs(a - b) <= Err;
-};
-
-/** @module Math */
-
-/**
- * Computes the cartesian product of two arrays.
- * @param {Array} a - The first array.
- * @param {Array} b - The second array.
- * @returns {Array} Returns an array representing the cartesian product of the input arrays.
- */
-const cartesianProduct = (a, b) => a.reduce((p, x) => [...p, ...b.map((y) => [x, y])], []);
-
-/**
- * Computes the greatest common divisor (GCD) of two numbers.
- * @param {number} n1 - The first number.
- * @param {number} n2 - The second number.
- * @returns {number} Returns the greatest common divisor of the two input numbers.
- */
-const pgcd = (n1, n2) => {
-    let i,
-        pgcd = 1;
-    if (n1 == floor(n1) && n2 == floor(n2)) {
-        for (i = 2; i <= n1 && i <= n2; ++i) {
-            if (n1 % i == 0 && n2 % i == 0) pgcd = i;
-        }
-        return pgcd;
-    } else console.log("error");
-};
-
-/**
- * Computes the least common multiple (LCM) of two numbers.
- * @param {number} n1 - The first number.
- * @param {number} n2 - The second number.
- * @returns {number} Returns the least common multiple of the two input numbers.
- */
-const ppcm = (n1, n2) => {
-    let ppcm;
-    if (n1 == floor(n1) && n2 == floor(n2)) {
-        ppcm = n1 > n2 ? n1 : n2;
-        while (true) {
-            if (ppcm % n1 == 0 && ppcm % n2 == 0) break;
-            ++ppcm;
-        }
-        return ppcm;
-    } else console.log("error");
-};
-
-// import { mapfun } from "../mapfun/index.js";
-// import { 
-//     add,
-//     sub,
-//     mul,
-//     div,
-//     modulo
-//  } from "./arithmetic.js";
-const Utils={
-    // add,
-    // sub,
-    // mul,
-    // div,
-    // modulo,
-
-    zeros,
-    ones,
-    nums,
-    // norm,
-    // lerp,
-    // map,
-    // clamp,
-    arange,
-    linspace,
-    logspace,
-    geomspace,
-
-    // sum,
-    // prod,
-    // accum,
-
-    cartesianProduct,
-    ppcm,
-    pgcd,
-
-    // deg2rad,
-    // rad2deg,
-
-    inRange,
-    isApproximatlyEqual
-};
-
 class UINode {
     constructor(node){
         this.cache = {
@@ -2056,115 +1876,134 @@ class UseIPC {
 const useIPC = (name) => new UseIPC(name);
 
 class UseStorage {
-    constructor(storage, globalKey, initialValue, use_channel = true) {
-        this.cache = {
-            storage,
-            globalKey,
-            channel: use_channel ? useIPC(`Ziko:useStorage-${globalKey}`) : null,
-            oldItemKeys: new Set()
-        };
+  static RESERVED_KEYS = new Set([
+    "cache", "items", "set", "add", "remove", "get", "clear", "onStorageUpdated"
+  ]);
 
-        this.#init(initialValue, use_channel);
-    }
+  constructor(storage, globalKey, initialValue, use_channel = true) {
+    this.cache = {
+      storage,
+      globalKey,
+      channel: use_channel ? useIPC(`Ziko:useStorage-${globalKey}`) : null,
+      oldItemKeys: new Set()
+    };
 
-    get items() {
-        const raw = this.cache.storage.getItem(this.cache.globalKey);
-        if (!raw) return {};
-        try {
-            return JSON.parse(raw);
-        } catch {
-            return {};
-        }
-    }
+    this.#init(initialValue, use_channel);
+  }
 
-    #maintain() {
-        const items = this.items;
-        this.cache.oldItemKeys.forEach(k => delete this[k]);
-        for (const key in items) {
-            this[key] = items[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());
-        if (!initialValue) {
-            this.#maintain();
-            return;
-        }
-        if (this.cache.storage.getItem(this.cache.globalKey)) {
-            const existing = this.items;
-            Object.keys(existing).forEach(k => this.cache.oldItemKeys.add(k));
-            this.#maintain();
-        } 
-        else this.set(initialValue);
+  get items() {
+    const raw = this.cache.storage.getItem(this.cache.globalKey);
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
     }
+  }
 
-    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;
-    }
+  #maintain() {
+    const currentItems = this.items;
+    const currentKeys = new Set(Object.keys(currentItems));
 
-    add(data) {
-        this.set({
-            ...this.items,
-            ...data
-        });
-        return this;
+    // 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);
+      }
     }
-    remove(...keys) {
-        const items = { ...this.items };
-        keys.forEach(key => {
-            delete items[key];
-            delete this[key];
-            this.cache.oldItemKeys.delete(key);
-        });
-        this.set(items);
-        return this;
+  }
+
+  #init(initialValue, use_channel) {
+    if (use_channel && this.cache.channel) {
+      this.cache.channel.on("Ziko-Storage-Updated", () => this.#maintain());
     }
-    get(key) {
-        return this.items[key];
+
+    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();
     }
-    clear() {
-        this.cache.storage.removeItem(this.cache.globalKey);
-        this.cache.oldItemKeys.forEach(k => delete this[k]);
-        this.cache.oldItemKeys.clear();
-        this.#maintain();
-        return this;
+  }
+
+  set(data) {
+    this.cache.storage.setItem(this.cache.globalKey, JSON.stringify(data));
+    if (this.cache.channel) {
+      this.cache.channel.emit("Ziko-Storage-Updated", data);
     }
-    onStorageUpdated(callback) {
-        if (this.cache.channel) {
-            this.cache.channel.on("Ziko-Storage-Updated", callback);
-        }
-        return this;
+    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;
+  }
 }
 
-// factory functions
-const useLocaleStorage = (key, initialValue, use_channel = true) =>
-    new UseStorage(localStorage, key, initialValue, use_channel);
+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);
+  new UseStorage(sessionStorage, key, initialValue, use_channel);
 
 var __State__ = {
     store : new Map(),
     index : 0,
     session_storage : null,
     register: function(state){
-        if(!undefined.SSR && undefined.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);
+        // 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(!undefined.SSR && undefined.DEV){
-            this.session_storage.add({[index] : value});
-        } 
+    //    if(!import.meta?.env?.SSR && import.meta?.env?.DEV){
+    //         this.session_storage.add({[index] : value})
+    //     } 
     },
 
 };
@@ -2341,57 +2180,61 @@ var LifecycleMethods = /*#__PURE__*/Object.freeze({
    unmount: unmount
 });
 
-if(!globalThis.__Ziko__) __init__global__();
+// import { __init__global__ } from "../__ziko__/index.js";
+
+// if (!globalThis.__Ziko__) __init__global__();
 
 function useState(initialValue) {
     
-    const {store, index} = __Ziko__.__State__;
-    __Ziko__.__State__.register({
-            value : initialValue,
-            subscribers : new Set(),
-            paused : false
-    });
-
-    let current = store.get(index);
+    const state = {
+        value: initialValue,
+        subscribers: new Set(),
+        paused: false,
+    };
 
     function getValue() {
         return {
-            value: current.value,
+            value: state.value,
             isStateGetter: () => true,
-            _subscribe: (fn) => current.subscribers.add(fn),
+            _subscribe: (fn) => {
+                state.subscribers.add(fn);
+                return () => state.subscribers.delete(fn);
+            },
         };
     }
 
     function setValue(newValue) {
-        if (current.paused) return;
+        if (state.paused) return;
+
         if (typeof newValue === "function") {
-            newValue = newValue(current.value);
+            newValue = newValue(state.value);
         }
-        if (newValue !== current.value) {
-            current.value = newValue;
-            current.subscribers.forEach(fn => fn(current.value));
-            __Ziko__.__State__.update(index, newValue);
+
+        if (!Object.is(newValue, state.value)) {
+            state.value = newValue;
+            state.subscribers.forEach((fn) => fn(state.value));
         }
     }
 
     const controller = {
-        pause: () => { current.paused = true; },
-        resume: () => { current.paused = false; },
-        clear: () => { current.subscribers.clear(); },
+        pause: () => { state.paused = true; },
+        resume: () => { state.paused = false; },
+        clear: () => { state.subscribers.clear(); },
         force: (newValue) => {
-            if (typeof newValue === "function") newValue = newValue(current.value);
-            current.value = newValue;
-            current.subscribers.forEach(fn => fn(current.value));
+            if (typeof newValue === "function") {
+                newValue = newValue(state.value);
+            }
+            state.value = newValue;
+            state.subscribers.forEach((fn) => fn(state.value));
         },
-        getSubscribers: () => new Set(current.subscribers),
+        getSubscribers: () => new Set(state.subscribers),
     };
 
     return [getValue, setValue, controller];
 }
 
-
 const isStateGetter = (arg) => {
-    return typeof arg === 'function' && arg?.()?.isStateGetter?.();
+    return typeof arg === "function" && arg?.()?.isStateGetter?.() === true;
 };
 
 const camel2hyphencase = (text = '') => text.replace(/[A-Z]/g, match => '-' + match.toLowerCase());
@@ -4318,110 +4161,6 @@ 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 obj2str=(object)=>{
-//     const recursiveToString = (obj) => {
-//       if (Array.isArray(obj)) return arr2str(obj);
-//       if (typeof obj === 'object' && obj !== null) {
-//         return `{ ${Object.entries(obj)
-//           .map(([key, value]) => `${key}:${recursiveToString(value)}`)
-//           .join(" , ")} }`;
-//       }
-//       return String(obj); 
-//     };
-//     return recursiveToString(object);
-//   };
-//   const obj2str = (object) => {
-//     const recursiveToString = (obj, indentLevel = 0) => {
-//       const indent = '  '.repeat(indentLevel);
-//       const nextIndent = '  '.repeat(indentLevel + 1);
-//       if(Array.isArray(obj)) return arr2str(obj, indentLevel);
-//       if(obj instanceof Complex || obj instanceof Matrix) return obj.toString();
-//       if (typeof obj === 'object' && obj !== null) {
-//         const entries = Object.entries(obj)
-//           .map(([key, value]) => `${nextIndent}${key}: ${recursiveToString(value, indentLevel + 1)}`)
-//           .join(",\n");
-  
-//         return `{\n${entries}\n${indent}}`;
-//       }
-  
-//       return String(obj);
-//     };
-  
-//     return recursiveToString(object);
-//   };
-// const obj2str = (object, useIndentation = true, indentLevel = 0) => {
-//     const recursiveToString = (obj, level = 0) => {
-//       const indent = useIndentation ? '  '.repeat(level) : '';
-//       const nextIndent = useIndentation ? '  '.repeat(level + 1) : '';
-//     if (Array.isArray(obj)) return arr2str(obj, false, level);
-//     if(obj instanceof Complex || obj instanceof Matrix) return obj.toString();
-//     if (typeof obj === 'object' && obj !== null) {
-//         const entries = Object.entries(obj)
-//           .map(([key, value]) => useIndentation 
-//             ? `${nextIndent}${key}: ${recursiveToString(value, level + 1)}` 
-//             : `${key}: ${recursiveToString(value, level + 1)}`
-//           ).join(useIndentation ? ",\n" : ", ");
-  
-//         return useIndentation 
-//           ? `{\n${entries}\n${indent}}` 
-//           : `{${entries}}`;
-//       }
-  
-//       return String(obj);
-//     };
-  
-//     return recursiveToString(object, indentLevel);
-//   };
-
-const obj2str=(obj)=>JSON.stringify(
-  mapfun(n=>{
-    if(["number","string","boolean","bigint"].includes(typeof n)) return String(n);
-    if(n instanceof Complex || n instanceof Matrix) return n.toString();
-    if(n instanceof Array) return arr2str(n)
-  },
-  obj), null, "  ")
-  .replace(/"([^"]+)":/g, '$1:') // Remove Quotes from Keys 
-  .replace(/: "([^"]+)"/g, ': $1'); // Remove Quotes from str values
-
-const getMaxDepth = arr=> {
-  if (!Array.isArray(arr)) return 0;
-  let maxDepth = 1;
-  for (const element of arr) {
-    if (Array.isArray(element)) {
-      const depth = getMaxDepth(element);
-      if (depth + 1 > maxDepth) {
-        maxDepth = depth + 1;
-      }
-    }
-  }
-  return maxDepth;
-};
-const arr2str = (arr) => {
-  let level = 0;
-  function arrStringify(arr) {
-    let max = getMaxDepth(arr);
-    let useIdentation = 0;
-    if (arr.some((n) => Array.isArray(n))) {
-      level++;
-      useIdentation = 1;   
-    }
-    return (
-      "[" +
-      arr.map((n, i) => {
-        if (["number", "string", "boolean", "bigint"].includes(typeof n))
-          return String(n);
-        if (n instanceof Complex) return n.toString();
-        if (n instanceof Array) {
-          return `\n${"  ".repeat(level)}${arrStringify(n)}${i === arr.length - 1 ? "\n" : ""}`;
-        }
-        if( n instanceof Object) return obj2str(n);
-      }) 
-      + `${"  ".repeat((max+level+1) * useIdentation)}]` 
-    );
-  }
-  return arrStringify(arr);
-};
-
 const json2css=(json, indentLevel = 0)=>{
     json = trimKeys(json);
     let cssText = '';
@@ -4694,6 +4433,49 @@ function useDerived(deriveFn, sources) {
     })
 }
 
+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);
@@ -5163,7 +4945,6 @@ exports.UISwitch = UISwitch;
 exports.UIView = UIView;
 exports.UseRoot = UseRoot;
 exports.UseThread = UseThread;
-exports.Utils = Utils;
 exports.View = View;
 exports.ViewEvent = ViewEvent;
 exports.ViewListeners = ViewListeners;
@@ -5183,9 +4964,7 @@ exports.add_vendor_prefix = add_vendor_prefix;
 exports.and = and;
 exports.animation = animation;
 exports.apply_fun = apply_fun;
-exports.arange = arange;
 exports.arc = arc;
-exports.arr2str = arr2str;
 exports.asin = asin;
 exports.asinh = asinh;
 exports.atan = atan;
@@ -5194,7 +4973,6 @@ exports.atanh = atanh;
 exports.back = back;
 exports.binomial = binomial;
 exports.call_with_optional_props = call_with_optional_props;
-exports.cartesianProduct = cartesianProduct;
 exports.cbrt = cbrt;
 exports.ceil = ceil;
 exports.clamp = clamp;
@@ -5220,9 +4998,7 @@ exports.elastic = elastic;
 exports.exp = exp$1;
 exports.floor = floor;
 exports.fract = fract;
-exports.geomspace = geomspace;
 exports.hypot = hypot;
-exports.inRange = inRange;
 exports.in_back = in_back;
 exports.in_bounce = in_bounce;
 exports.in_circ = in_circ;
@@ -5243,7 +5019,6 @@ exports.in_quad = in_quad;
 exports.in_quart = in_quart;
 exports.in_quint = in_quint;
 exports.in_sin = in_sin;
-exports.isApproximatlyEqual = isApproximatlyEqual;
 exports.isPrimitive = isPrimitive;
 exports.isStateGetter = isStateGetter;
 exports.json2arr = json2arr;
@@ -5257,12 +5032,10 @@ exports.json2ymlFile = json2ymlFile;
 exports.lerp = lerp;
 exports.linear = linear;
 exports.linkStyle = linkStyle;
-exports.linspace = linspace;
 exports.ln = ln;
-exports.logspace = logspace;
 exports.loop = loop;
 exports.map = map$1;
-exports.mapfun = mapfun;
+exports.mapfun = mapfun$1;
 exports.matrix = matrix;
 exports.matrix2 = matrix2;
 exports.matrix3 = matrix3;
@@ -5278,9 +5051,6 @@ exports.nor = nor;
 exports.norm = norm;
 exports.normalize_css_value = normalize_css_value;
 exports.nthr = nthr;
-exports.nums = nums;
-exports.obj2str = obj2str;
-exports.ones = ones;
 exports.or = or;
 exports.out_back = out_back;
 exports.out_bounce = out_bounce;
@@ -5293,9 +5063,7 @@ exports.out_quart = out_quart;
 exports.out_quint = out_quint;
 exports.out_sin = out_sin;
 exports.percentile = percentile;
-exports.pgcd = pgcd;
 exports.pow = pow$1;
-exports.ppcm = ppcm;
 exports.rad2deg = rad2deg;
 exports.register_click_away_event = register_click_away_event;
 exports.register_swipe_event = register_swipe_event;
@@ -5332,7 +5100,7 @@ exports.trunc = trunc;
 exports.useDerived = useDerived;
 exports.useEventEmitter = useEventEmitter;
 exports.useIPC = useIPC;
-exports.useLocaleStorage = useLocaleStorage;
+exports.useLocalStorage = useLocalStorage;
 exports.useMediaQuery = useMediaQuery;
 exports.useQueryParams = useQueryParams;
 exports.useReactive = useReactive;
@@ -5349,4 +5117,3 @@ exports.waitForUIElmSync = waitForUIElmSync;
 exports.watchQueryParams = watchQueryParams;
 exports.xnor = xnor;
 exports.xor = xor;
-exports.zeros = zeros;