ziko 1.1.0 → 1.2.0

package/dist/ziko.js

@@ -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
@@ -19,18 +19,18 @@
 
    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])]
                    )
                )
            }
@@ -48,7 +48,7 @@
            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)
    };
 
@@ -531,7 +531,7 @@
 
    const PRECESION = 8;
 
-   const abs = (...x) => mapfun(
+   const abs = (...x) => mapfun$1(
        x =>{
            if(x.isComplex?.()) return x.z;
            return Math.abs(x)
@@ -541,7 +541,7 @@
 
    const pow$1 = (...x) => {
        const n = x.pop();
-       return mapfun(
+       return mapfun$1(
            x => {
                if(x.isComplex?.()) {
                    if(n.isComplex?.()) return new x.constructor({
@@ -560,7 +560,7 @@
        )
    };
 
-   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});
@@ -570,7 +570,7 @@
        ...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)
@@ -582,7 +582,7 @@
    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 
@@ -597,7 +597,7 @@
    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;
@@ -614,7 +614,7 @@
        )
    };
 
-   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),
@@ -625,7 +625,7 @@
        ,...x
    );
 
-   const ln = (...x) => mapfun(
+   const ln = (...x) => mapfun$1(
        x => {
            if(x.isComplex?.()) return new x.constructor(
                Math.log(x.z),
@@ -636,7 +636,7 @@
        ,...x
    );
 
-   const sign = (...x) => mapfun(
+   const sign = (...x) => mapfun$1(
        x => {
            if(x.isComplex?.()){
                const {z, phi} = x;
@@ -648,7 +648,7 @@
        ,...x
    );
 
-   const floor = (...x) => mapfun(
+   const floor = (...x) => mapfun$1(
        x => {
            if(x.isComplex?.()) return new x.constructor(
                Math.floor(x.a),
@@ -658,7 +658,7 @@
        },
        ...x
    );
-   const ceil = (...x) => mapfun(
+   const ceil = (...x) => mapfun$1(
        x => {
            if(x.isComplex?.()) return new x.constructor(
                Math.ceil(x.a),
@@ -668,7 +668,7 @@
        },
        ...x
    );
-   const round = (...x) => mapfun(
+   const round = (...x) => mapfun$1(
        x => {
            if(x.isComplex?.()) return new x.constructor(
                Math.round(x.a),
@@ -679,7 +679,7 @@
        ...x
    );
 
-   const trunc = (...x) => mapfun(
+   const trunc = (...x) => mapfun$1(
        x => {
            if(x.isComplex?.()) return new x.constructor(
                Math.trunc(x.a),
@@ -690,7 +690,7 @@
        ...x
    );
 
-   const fract = (...x) => mapfun(
+   const fract = (...x) => mapfun$1(
        x => {
            if(x.isComplex?.()) return new x.constructor(
                x.a - Math.trunc(x.a),
@@ -701,7 +701,7 @@
        ...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),
@@ -712,7 +712,7 @@
        ,...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),
@@ -723,7 +723,7 @@
        , ...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);
@@ -737,7 +737,7 @@
        ...x
    );
 
-   const sec = (...x) => mapfun(
+   const sec = (...x) => mapfun$1(
        x => {
            if(x.isComplex?.()) ;
            return + (1 / Math.cos(x)).toFixed(PRECESION)
@@ -745,7 +745,7 @@
        ,...x
    );
 
-   const acos$1 = (...x) => mapfun(
+   const acos$1 = (...x) => mapfun$1(
        x =>{
            if(x?.isComplex){
                const { a, b } = x;
@@ -763,7 +763,7 @@
        ...x
    );
 
-   const asin = (...x) => mapfun(
+   const asin = (...x) => mapfun$1(
        x => {
            if(x?.isComplex){
                const { a, b } = x;
@@ -779,7 +779,7 @@
        ...x
    );
 
-   const atan = (...x) => mapfun(
+   const atan = (...x) => mapfun$1(
        x => {
            if(x?.isComplex){
                const { a, b } = x;
@@ -793,7 +793,7 @@
        ...x
    );
 
-   const acot = (...x) => mapfun(
+   const acot = (...x) => mapfun$1(
        x => {
            if(x?.isComplex){
                const { a, b } = x;
@@ -808,7 +808,7 @@
    );
 
 
-   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),
@@ -818,7 +818,7 @@
        },
        ...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),
@@ -828,7 +828,7 @@
        },
        ...x
    );
-   const tanh = (...x) => mapfun(
+   const tanh = (...x) => mapfun$1(
        x =>{
            if(x?.isComplex){
                const D = Math.cosh(2*a) + Math.cos(2*b);
@@ -842,7 +842,7 @@
        ...x
    );
 
-   const coth = (...x) => mapfun(
+   const coth = (...x) => mapfun$1(
        x =>{
            if(x?.isComplex){
                const {a, b} = x;
@@ -857,7 +857,7 @@
        ...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))))
@@ -867,7 +867,7 @@
        ...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))))
@@ -877,7 +877,7 @@
        ...x
    );
 
-   const atanh = (...x) => mapfun(
+   const atanh = (...x) => mapfun$1(
        x =>{
            if(x?.isComplex); 
            return + Math.atanh(x).toFixed(PRECESION)
@@ -885,7 +885,7 @@
        ...x
    );
 
-   const sig = (...x) => mapfun(
+   const sig = (...x) => mapfun$1(
        x =>{
            if(x?.isComplex); 
            return 1/(1 + Math.exp(-x)).toFixed(PRECESION)
@@ -893,8 +893,8 @@
        ...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, 
@@ -925,10 +925,10 @@
 
    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));
@@ -1165,7 +1165,7 @@
            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
            );
@@ -1629,7 +1629,7 @@
            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 : {
@@ -1644,7 +1644,7 @@
            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;
@@ -1675,186 +1675,6 @@
    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 = {
@@ -2060,115 +1880,134 @@
    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})
+       //     } 
        },
 
    };
@@ -2345,57 +2184,61 @@
       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());
@@ -4322,110 +4165,6 @@
    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 = '';
@@ -4698,6 +4437,49 @@
        })
    }
 
+   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);
@@ -5167,7 +4949,6 @@
    exports.UIView = UIView;
    exports.UseRoot = UseRoot;
    exports.UseThread = UseThread;
-   exports.Utils = Utils;
    exports.View = View;
    exports.ViewEvent = ViewEvent;
    exports.ViewListeners = ViewListeners;
@@ -5187,9 +4968,7 @@
    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;
@@ -5198,7 +4977,6 @@
    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;
@@ -5224,9 +5002,7 @@
    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;
@@ -5247,7 +5023,6 @@
    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;
@@ -5261,12 +5036,10 @@
    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;
@@ -5282,9 +5055,6 @@
    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;
@@ -5297,9 +5067,7 @@
    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;
@@ -5336,7 +5104,7 @@
    exports.useDerived = useDerived;
    exports.useEventEmitter = useEventEmitter;
    exports.useIPC = useIPC;
-   exports.useLocaleStorage = useLocaleStorage;
+   exports.useLocalStorage = useLocalStorage;
    exports.useMediaQuery = useMediaQuery;
    exports.useQueryParams = useQueryParams;
    exports.useReactive = useReactive;
@@ -5353,6 +5121,5 @@
    exports.watchQueryParams = watchQueryParams;
    exports.xnor = xnor;
    exports.xor = xor;
-   exports.zeros = zeros;
 
 }));