nv-buf-serde 0.0.2

package/TEST/w-ab-and-abvw.js

@@ -0,0 +1,60 @@
+
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            //console.log(b0.slice(i));
+            //console.log(Buffer.from(b1.slice(i)));
+            throw(i);
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+var u8a            =  new Uint8Array([200,201,202])
+var u8ca           =  new Uint8ClampedArray([1,2,3,4,5,6,7,8]);
+var i8a            =  new Int8Array([100,-50,255]);
+var u16a           =  new Uint16Array([65533,65534,65535])
+var i16a           =  new Int16Array([100,200,300])
+var u32a           =  new Uint32Array([2**31,2**32-1])
+var i32a           =  new Int32Array([2**29,2**30])
+var f32a           =  new Float32Array([1.1,2.2,3.3])
+var f64a           =  new Float32Array([-(2**52),2**53-1.1])
+var bu64a          =  new BigUint64Array([2n**63n,2n**64n-1n])
+var bi64a          =  new BigInt64Array([2n**63n,2n**62n])
+
+var ab = new ArrayBuffer(4)
+var dv = new DataView(ab)
+dv.setUint8(0,1)
+dv.setUint8(0,2)
+dv.setUint8(0,3)
+dv.setUint8(0,4)
+
+/*var sab = new SharedArrayBuffer(4); nodejs-not-support-sab*/
+
+var arr = [u8a,u8ca,i8a,u16a,i16a,u32a,i32a,f32a,f64a,dv,ab,bi64a,bu64a,/*sab*/]
+
+for(let i=0;i<arr.length;++i) {
+    eq(f0(arr[i]),f1(arr[i]));
+}
+
+
+arr  = Array.from({length:50000}).map(r=>arr.slice(0));
+arr  = arr.flat();
+
+
+var ff0 = ()=>arr.forEach(e=>f0(e));
+var ff1 = ()=>arr.forEach(e=>f1(e));
+console.log(sync(1,ff0));
+console.log(sync(1,ff1));

package/TEST/w-bi.js

@@ -0,0 +1,33 @@
+
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+var bis     = [12345678901234567890234567890n,-0n,0n,2n**64n];
+
+for(let dbl of bis) {
+    eq(f0(dbl),f1(dbl))
+}
+
+
+console.log(sync(1000000,f0,12345678901234567890234567890n));
+console.log(sync(1000000,f1,12345678901234567890234567890n));
+

package/TEST/w-date.js

@@ -0,0 +1,33 @@
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+
+var dt             = new Date();
+
+
+eq(f0(dt),f1(dt));
+
+
+console.log(sync(100000,f0,dt));
+console.log(sync(100000,f1,dt));
+

package/TEST/w-double.js

@@ -0,0 +1,35 @@
+
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+var doubles              = [-1.1,-0,1.1]
+
+eq(f0(doubles),f1(doubles))
+
+for(let i = -500000;i<0;++i) {doubles.push(Math.random()+i)}
+for(let i = 1;i<500000;++i)  {doubles.push(Math.random()+i)}
+
+
+var ff0 = ()=>doubles.forEach(doubles=>f0(doubles));
+var ff1 = ()=>doubles.forEach(doubles=>f1(doubles));
+console.log(sync(1,ff0));
+console.log(sync(1,ff1));

package/TEST/w-int-not-smi.js

@@ -0,0 +1,37 @@
+
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+var i32s              = [-(2**31)-1,2**31]
+
+for(let i32 of i32s) {
+    eq(f0(i32),f1(i32))
+}
+
+for(let i = -500000;i<0;++i) {i32s.push(-(2**31)-1+i)}
+for(let i = 1;i<500000;++i) {i32s.push(2**31+i)}
+
+
+var ff0 = ()=>i32s.forEach(i32=>f0(i32));
+var ff1 = ()=>i32s.forEach(i32=>f1(i32));
+console.log(sync(1,ff0));
+console.log(sync(1,ff1));

package/TEST/w-mp-st-circular.js

@@ -0,0 +1,60 @@
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+	    console.log(b0.slice(i))	
+	    console.log(Buffer.from(b1.slice(i)))	
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+var st = new Set([])
+for(let e of [1,1.1,undefined,null,true,false,"abcd","aÿ我𝑒",12345678901234567890n,[],{}]) {st.add(e)}
+eq(f0(st),f1(st))
+
+var mp = new Map()
+eq(f0(mp),f1(mp))
+
+for(let e of [[]]) {mp.set(e,e)}
+eq(f0(mp),f1(mp))
+
+
+
+
+for(let e of [1,1.1,undefined,null,true,false,"abcd","aÿ我𝑒",12345678901234567890n]) {mp.set(e,e)}
+eq(f0(mp),f1(mp))
+
+
+for(let e of [1,1.1,undefined,null,true,false,"abcd","aÿ我𝑒",12345678901234567890n,[],{}]) {mp.set(e,e)}
+eq(f0(mp),f1(mp))
+
+var circular = [];
+circular[0]  = circular
+circular[1] = {pr:circular[0]}
+circular[2]  = mp
+mp.set("st",st);
+st.add(mp);
+
+st["top"] = circular;
+mp["top"] = circular;
+
+
+console.dir(circular,{depth:null})
+
+eq(f0(circular),f1(circular))
+
+console.log(sync(1000000,f0,circular));
+console.log(sync(1000000,f1,circular));

package/TEST/w-odd-ball.js

@@ -0,0 +1,43 @@
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+var un              = undefined;             
+eq(f0(un),f1(un))
+console.log(sync(1000000,f0,un))     
+console.log(sync(1000000,f1,un))
+
+
+var nu              = null;
+eq(f0(nu),f1(nu))                            //0x30
+console.log(sync(1000000,f0,nu))
+console.log(sync(1000000,f1,nu))
+
+
+var t               = true;
+eq(f0(t),f1(t))                            //0x54
+console.log(sync(1000000,f0,t))
+console.log(sync(1000000,f1,t))
+
+var f               = false;
+eq(f0(f),f1(f))                            //0x46
+console.log(sync(1000000,f0,f))
+console.log(sync(1000000,f1,f))

package/TEST/w-packed-double.js

@@ -0,0 +1,40 @@
+
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+var packed_double        = [-1,-0,1];   // -0 is double
+
+console.log(f0(packed_double));
+console.log(Buffer.from(f1(packed_double)));
+eq(f0(packed_double),f1(packed_double))
+
+packed_double = packed_double.concat(-1.1,2.2);
+eq(f0(packed_double),f1(packed_double))
+
+
+for(let i = -500000;i<0;++i) {packed_double.push(Math.random()+i)}
+for(let i = 1;i<500000;++i)  {packed_double.push(Math.random()+i)}
+
+
+var ff0 = ()=>packed_double.forEach(e=>f0(e));
+var ff1 = ()=>packed_double.forEach(e=>f1(e));
+console.log(sync(1,ff0));
+console.log(sync(1,ff1));

package/TEST/w-packed-smi.js

@@ -0,0 +1,38 @@
+
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+var packed_smi        = [-1,0,1];
+
+console.log(f0(packed_smi));
+console.log(Buffer.from(f1(packed_smi)));
+
+eq(f0(packed_smi),f1(packed_smi))
+
+
+
+for(let i = -250000;i<-1;++i) {packed_smi.unshift(i)}
+for(let i = 1;i<250000;++i)   {packed_smi.push(i)}
+
+var ff0 = ()=>packed_smi.forEach(e=>f0(e));
+var ff1 = ()=>packed_smi.forEach(e=>f1(e));
+console.log(sync(1,ff0));
+console.log(sync(1,ff1));

package/TEST/w-packed-with-attr.js

@@ -0,0 +1,41 @@
+
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            console.log(b0.slice(i));
+            console.log(Buffer.from(b1.slice(i)));
+            throw(i);
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+var packed_with_attr = [1,1.1,undefined,null,true,false,"abcd","aÿ我𝑒",12345678901234567890n,[],{}]
+packed_with_attr.k0  = "v0"
+packed_with_attr.k1  = "v1"
+
+console.log(f0(packed_with_attr));
+console.log(Buffer.from(f1(packed_with_attr)));
+eq(f0(packed_with_attr),f1(packed_with_attr))
+
+
+packed_with_attr = Array.from({length:50000}).map(r=>packed_with_attr.slice(0));
+packed_with_attr = packed_with_attr.flat();
+
+
+var ff0 = ()=>packed_with_attr.forEach(e=>f0(e));
+var ff1 = ()=>packed_with_attr.forEach(e=>f1(e));
+console.log(sync(1,ff0));
+console.log(sync(1,ff1));

package/TEST/w-prim-wrap.js

@@ -0,0 +1,41 @@
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+var trwap            = new Boolean(true);
+var fwrap            = new Boolean(false);
+var num_wrap         = new Number(1.1);
+//var bi_wrap          = new BigInt(12345678901234567890234567890n);  in-js-layer this is invalid
+var _1bs_wrap        = new String("abcd");
+var _2bs_wrap        = new String("aÿ我𝑒");
+
+
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+var prim_wrap_ary = [trwap,fwrap,num_wrap,_1bs_wrap,_2bs_wrap]
+
+console.log(f0(_2bs_wrap),"",Buffer.from(f1(_2bs_wrap)))
+
+for(let dbl of prim_wrap_ary) {
+    eq(f0(dbl),f1(dbl))
+}
+
+var ff0 = ()=>prim_wrap_ary.forEach(e=>f0(e));
+var ff1 = ()=>prim_wrap_ary.forEach(e=>f1(e));
+console.log(sync(100000,ff0));
+console.log(sync(100000,ff1));
+

package/TEST/w-rgx.js

@@ -0,0 +1,33 @@
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+
+var rgx             = /[0-9a-z_]+/gi;
+
+
+eq(f0(rgx),f1(rgx));
+
+
+console.log(sync(100000,f0,rgx));
+console.log(sync(100000,f1,rgx));
+

package/TEST/w-smi.js

@@ -0,0 +1,36 @@
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+const eq = (b0,b1)=> {
+    var u8a = new Uint8Array(b1);
+    for(let i =0;i<b0.length;++i) {
+        if(b0[i] === u8a[i]) {
+
+        } else {
+            throw(i)
+        }
+    }
+}
+var fj = (o)=> JSON.stringify(o);
+const {encd}  = require("../w");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+var f0 = (o)=> v8.serialize(o);
+var f1 = (o)=> encd(o,15);             //version default is 15 , using 13 just for test
+
+
+var smis              = [-(2**31),-1,0,1,2**31-1]
+
+for(let smi of smis) {
+    eq(f0(smi),f1(smi))
+}
+
+for(let i = -500000;i<500000;++i) {
+    smis.push(i)
+}
+
+var ff0 = ()=>smis.forEach(smi=>f0(smi));
+var ff1 = ()=>smis.forEach(smi=>f1(smi));
+console.log(sync(1,ff0));
+console.log(sync(1,ff1));

package/build.sh

@@ -0,0 +1 @@
+nv_cli_build -m -g v8serde