nv-buf-serde 0.0.2

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

@@ -0,0 +1,28 @@
+const {deepStrictEqual} = require("assert");
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+
+const {decd}  = require("../r");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+const to_ab = (buf) => buf.buffer.slice(buf.byteOffset,buf.byteOffset+buf.byteLength); 
+
+
+var i32s              = [-(2**31)-1,2**31]
+var bufs              = i32s.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var f0 = (buf)=> v8.deserialize(buf);
+var f1 = (ab)=> decd(ab);  
+
+
+for(let i=0;i<i32s.length;++i) {deepStrictEqual(f1(abs[i]),i32s[i])}
+
+console.log("OK")
+
+var ff0 = ()=>bufs.forEach(buf=>f0(buf));
+var ff1 = ()=>abs.forEach(ab=>f1(ab));
+console.log(sync(1000000,ff0));
+console.log(sync(1000000,ff1));

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

@@ -0,0 +1,105 @@
+const {deepStrictEqual} = require("assert");
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+
+const {decd}  = require("../r");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+const to_ab = (buf) => buf.buffer.slice(buf.byteOffset,buf.byteOffset+buf.byteLength); 
+var f0 = (buf)=> v8.deserialize(buf);
+var f1 = (ab)=> decd(ab);
+
+
+var st = new Set([])
+for(let e of [1,1.1,undefined,null,true,false,"abcd","aÿ我𝑒",12345678901234567890n,[],{}]) {st.add(e)}
+
+
+var dbls              = [st]
+var bufs              = dbls.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+
+
+for(let i=0;i<dbls.length;++i) {deepStrictEqual(f1(abs[i]),f0(bufs[i]))}
+
+console.log("OK")
+
+
+
+var mp = new Map();
+
+var dbls              = [mp]
+var bufs              = dbls.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+
+
+for(let i=0;i<dbls.length;++i) {deepStrictEqual(f1(abs[i]),f0(bufs[i]))}
+
+console.log("OK")
+
+
+let dict = {a:100,b:-0}
+let ary  = [0,1,2,3]
+for(let e of [[{},[]],[true,false],[dict,dict],[ary,ary]]) {mp.set(e,e)}
+for(let e of [[]]) {mp.set(e,e)}
+for(let e of [1,1.1,undefined,null,true,false,"abcd","aÿ我𝑒",12345678901234567890n]) {mp.set(e,e)}
+
+var dbls              = [mp]
+var bufs              = dbls.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+
+
+for(let i=0;i<dbls.length;++i) {deepStrictEqual(f1(abs[i]),f0(bufs[i]))}
+
+console.log("OK")
+
+
+var circular = [];
+circular[0]  = circular
+circular[1] = {pr:circular[0]}
+circular[2]  = mp
+st.add(mp);
+mp.set("set",st);
+
+var dbls              = [circular]
+var bufs              = dbls.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+
+
+for(let i=0;i<dbls.length;++i) {deepStrictEqual(f1(abs[i]),f0(bufs[i]))}
+
+console.log("OK")
+
+
+
+
+st["top"] = circular;     // this will be drop, compatible with v8-impl
+mp["top"] = circular;    // this will be drop ,  compatible with v8-impl
+
+
+
+
+var dbls              = [circular]
+var bufs              = dbls.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+
+
+for(let i=0;i<dbls.length;++i) {deepStrictEqual(f1(abs[i]),f0(bufs[i]))}
+
+console.log("OK")
+circular = Array.from({length:500}).map(r=>circular.slice(0));
+circular = circular.flat();
+var dbls              = [circular]
+var bufs              = dbls.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var ff0 = ()=>bufs.forEach(buf=>f0(buf));
+var ff1 = ()=>abs.forEach(ab=>f1(ab));
+console.log(sync(2000,ff0));
+console.log(sync(2000,ff1));

package/TEST/r-odd-ball.js

@@ -0,0 +1,33 @@
+const {deepStrictEqual} = require("assert");
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+
+const {decd}  = require("../r");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+const to_ab = (buf) => buf.buffer.slice(buf.byteOffset,buf.byteOffset+buf.byteLength); 
+
+
+var bis              = [undefined,null,true,false]
+var bufs              = bis.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var f0 = (buf)=> v8.deserialize(buf);
+var f1 = (ab)=> decd(ab);  
+
+
+for(let i=0;i<bis.length;++i) {deepStrictEqual(f1(abs[i]),bis[i])}
+
+console.log("OK")
+for(let i = -125000n;i<0n;++i) {bis.push(undefined,null,true,false)}
+for(let i = 1n;i<125000n;++i)  {bis.push(undefined,null,true,false)}
+var bufs              = bis.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+
+var ff0 = ()=>bufs.forEach(buf=>f0(buf));
+var ff1 = ()=>abs.forEach(ab=>f1(ab));
+console.log(sync(1,ff0));
+console.log(sync(1,ff1));

package/TEST/r-packed-double.js

@@ -0,0 +1,38 @@
+const {deepStrictEqual} = require("assert");
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+
+const {decd}  = require("../r");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+const to_ab = (buf) => buf.buffer.slice(buf.byteOffset,buf.byteOffset+buf.byteLength); 
+
+var packed_double        = [-1,-0,1];
+
+
+
+var dbls              = [packed_double]
+var bufs              = dbls.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var f0 = (buf)=> v8.deserialize(buf);
+var f1 = (ab)=> decd(ab);  
+
+
+for(let i=0;i<dbls.length;++i) {deepStrictEqual(f1(abs[i]),dbls[i])}
+
+console.log("OK")
+
+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 bufs              = dbls.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var ff0 = ()=>bufs.forEach(buf=>f0(buf));
+var ff1 = ()=>abs.forEach(ab=>f1(ab));
+console.log(sync(20,ff0));
+console.log(sync(20,ff1));

package/TEST/r-packed-smi.js

@@ -0,0 +1,35 @@
+const {deepStrictEqual} = require("assert");
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+
+const {decd}  = require("../r");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+const to_ab = (buf) => buf.buffer.slice(buf.byteOffset,buf.byteOffset+buf.byteLength); 
+
+var packed_smi        = [-(2**31),-1,0,1,2,3,4,5,2**31-1];
+
+var smis              = [packed_smi]
+var bufs              = smis.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var f0 = (buf)=> v8.deserialize(buf);
+var f1 = (ab)=> decd(ab);  
+
+
+for(let i=0;i<smis.length;++i) {deepStrictEqual(f1(abs[i]),smis[i])}
+
+console.log("OK")
+
+//for(let i = -5;i<-1;++i) {packed_smi.unshift(i)}
+//for(let i = 1;i<5;++i)   {packed_smi.push(i)}
+
+var bufs              = smis.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var ff0 = ()=>bufs.forEach(buf=>f0(buf));
+var ff1 = ()=>abs.forEach(ab=>f1(ab));
+console.log(sync(1000000,ff0));
+console.log(sync(1000000,ff1));

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

@@ -0,0 +1,40 @@
+const {deepStrictEqual} = require("assert");
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+
+const {decd}  = require("../r");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+const to_ab = (buf) => buf.buffer.slice(buf.byteOffset,buf.byteOffset+buf.byteLength); 
+
+var packed_with_attr        = [-1,-0,1];
+var packed_with_attr = [1,1.1,undefined,null,true,false,"abcd","aÿ我𝑒",12345678901234567890n,[],{}]
+packed_with_attr.k0  = "v0"
+packed_with_attr.k1  = "v1"
+
+
+var dbls              = [packed_with_attr]
+var bufs              = dbls.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var f0 = (buf)=> v8.deserialize(buf);
+var f1 = (ab)=> decd(ab);  
+
+
+for(let i=0;i<dbls.length;++i) {deepStrictEqual(f1(abs[i]),dbls[i])}
+
+console.log("OK")
+
+packed_with_attr = Array.from({length:50000}).map(r=>packed_with_attr.slice(0));
+packed_with_attr = packed_with_attr.flat();
+
+var dbls              = [packed_with_attr]
+var bufs              = dbls.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var ff0 = ()=>bufs.forEach(buf=>f0(buf));
+var ff1 = ()=>abs.forEach(ab=>f1(ab));
+console.log(sync(20,ff0));
+console.log(sync(20,ff1));

package/TEST/r-prim-wrap.js

@@ -0,0 +1,35 @@
+const {deepStrictEqual} = require("assert");
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+
+const {decd}  = require("../r");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+const to_ab = (buf) => buf.buffer.slice(buf.byteOffset,buf.byteOffset+buf.byteLength); 
+
+
+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 wraps             = [trwap,fwrap,num_wrap,_1bs_wrap,_2bs_wrap/*bi_wrap*/] 
+var bufs              = wraps.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var f0 = (buf)=> v8.deserialize(buf);
+var f1 = (ab)=> decd(ab);  
+
+
+for(let i=0;i<wraps.length;++i) {deepStrictEqual(f1(abs[i]),wraps[i])}
+
+console.log("OK")
+
+var ff0 = ()=>bufs.forEach(buf=>f0(buf));
+var ff1 = ()=>abs.forEach(ab=>f1(ab));
+console.log(sync(1000000,ff0));
+console.log(sync(1000000,ff1));

package/TEST/r-rgx.js

@@ -0,0 +1,28 @@
+const {deepStrictEqual} = require("assert");
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+
+const {decd}  = require("../r");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+const to_ab = (buf) => buf.buffer.slice(buf.byteOffset,buf.byteOffset+buf.byteLength); 
+
+
+var rgxs              = [/[a-z0-9_]+/,/[a-z0-9_]+/gi];
+var bufs              = rgxs.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var f0 = (buf)=> v8.deserialize(buf);
+var f1 = (ab)=> decd(ab);  
+
+
+for(let i=0;i<rgxs.length;++i) {deepStrictEqual(f1(abs[i]),rgxs[i])}
+
+console.log("OK")
+
+var ff0 = ()=>bufs.forEach(buf=>f0(buf));
+var ff1 = ()=>abs.forEach(ab=>f1(ab));
+console.log(sync(1000000,ff0));
+console.log(sync(1000000,ff1));

package/TEST/r-smi.js

@@ -0,0 +1,28 @@
+const {deepStrictEqual} = require("assert");
+const {sync} = require("nv-facutil-simple-test");
+const v8 = require("v8");
+
+const {decd}  = require("../r");
+
+const ENCD_UN = 0X5F;
+const ENCD_NU = 0X30;
+
+const to_ab = (buf) => buf.buffer.slice(buf.byteOffset,buf.byteOffset+buf.byteLength); 
+
+
+var smis              = [-(2**31),-1,0,1,2**31-1]
+var bufs              = smis.map(r=>v8.serialize(r));
+var abs               = bufs.map(buf=>to_ab(buf));
+
+var f0 = (buf)=> v8.deserialize(buf);
+var f1 = (ab)=> decd(ab);  
+
+
+for(let i=0;i<smis.length;++i) {deepStrictEqual(f1(abs[i]),smis[i])}
+
+console.log("OK")
+
+var ff0 = ()=>bufs.forEach(buf=>f0(buf));
+var ff1 = ()=>abs.forEach(ab=>f1(ab));
+console.log(sync(1000000,ff0));
+console.log(sync(1000000,ff1));

package/TEST/read-bi-contents.js

@@ -0,0 +1,20 @@
+const assert = require("assert");
+
+const v8 = require("v8");
+const {ReadBigInt} = require("../r");
+
+console.log("10000n+2n**64n :" ,10000n+2n**64n)
+
+var buf = v8.serialize(-(10000n+2n**64n));
+
+console.log(buf);
+
+console.log(ReadBigInt(buf,3,{}));
+
+assert(v8.deserialize(buf)=== ReadBigInt(buf,3,{})[0])
+
+var buf = v8.serialize((10000n+2n**64n));
+console.log(ReadBigInt(buf,3,{}));
+
+
+assert(v8.deserialize(buf)=== ReadBigInt(buf,3,{})[0])

package/TEST/run.js

@@ -0,0 +1,43 @@
+const cmds = [
+  'node w-1bstr.js',
+  'node w-2bstr.js',
+  'node w-bi.js',
+  'node w-double.js',
+  'node w-int-not-smi.js',
+  'node w-odd-ball.js',
+  'node w-packed-double.js',
+  'node w-packed-smi.js',
+  'node w-prim-wrap.js',
+  'node w-smi.js',
+  'node w-packed-with-attr.js',
+  'node w-ab-and-abvw.js',
+  'node w-date.js',
+  'node w-rgx.js',
+    'node w-mp-st-circular.js',   	
+
+  'node r-1bstr.js',
+  'node r-2bstr.js',
+  'node r-bi.js',
+  'node r-double.js',
+  'node r-int-not-smi.js',
+  'node r-odd-ball.js',
+  'node r-packed-double.js',
+  'node r-packed-smi.js',
+  'node r-prim-wrap.js',
+  'node r-smi.js',
+  'node r-packed-with-attr.js',
+  'node r-ab-and-abvw.js',
+  'node r-date.js',
+  'node r-rgx.js',
+  'node r-mp-st-circular.js'	
+]
+
+const child_process = require("child_process");
+
+for(let cmd of cmds) {
+    console.log(cmd,":");
+	console.log(child_process.execSync(cmd));
+    console.log("=============================================================");
+}
+
+

package/TEST/run.sh

@@ -0,0 +1,29 @@
+echo "w-1bstr.js" && node w-1bstr.js
+echo "w-2bstr.js" && node w-2bstr.js
+echo "w-bi.js" && node w-bi.js
+echo "w-double.js" && node w-double.js
+echo "w-int-not-smi.js" && node w-int-not-smi.js
+echo "w-odd-ball.js" && node w-odd-ball.js
+echo "w-packed-double.js" && node w-packed-double.js
+echo "w-packed-smi.js" && node w-packed-smi.js
+echo "w-prim-wrap.js" && node w-prim-wrap.js
+echo "w-smi.js" && node w-smi.js
+echo "w-packed-with-attr.js" && node w-packed-with-attr.js
+echo "w-ab-and-abvw.js" && node w-ab-and-abvw.js
+echo "w-date.js" && node w-date.js
+echo "w-rgx.js" && node w-rgx.js
+echo "r-1bstr.js" && node r-1bstr.js
+echo "r-2bstr.js" && node r-2bstr.js
+echo "r-bi.js" && node r-bi.js
+echo "r-double.js" && node r-double.js
+echo "r-int-not-smi.js" && node r-int-not-smi.js
+echo "r-odd-ball.js" && node r-odd-ball.js
+echo "r-packed-double.js" && node r-packed-double.js
+echo "r-packed-smi.js" && node r-packed-smi.js
+echo "r-prim-wrap.js" && node r-prim-wrap.js
+echo "r-smi.js" && node r-smi.js
+echo "r-packed-with-attr.js" && node r-packed-with-attr.js
+echo "r-ab-and-abvw.js" && node r-ab-and-abvw.js
+echo "r-date.js" && node r-date.js
+echo "r-rgx.js" && node r-rgx.js
+echo "r-mp-st-circular.js" && node r-mp-st-circular.js

package/TEST/serde-benchmark.js

@@ -0,0 +1,17 @@
+const common = require('./common.js');
+const {encd} = require("../w.js")
+
+const bench = common.createBenchmark(main, {
+  len: [1,2,4,8],
+  n: [1000000],
+});
+
+function main({ n, len }) {
+  const typedArray = new BigUint64Array(len);
+  bench.start();
+  for (let i = 0; i < n; i++) encd({ a: 1, b: typedArray });
+  bench.end(n);
+}
+
+
+

package/TEST/tst.json

@@ -0,0 +1,114 @@
+{
+  "name": "nv-buf-serde",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "nv-buf-bi": "^1.0.5",
+        "nv-buf-jstr": "^1.0.8",
+        "nv-facutil-ab": "^1.0.0",
+        "nv-facutil-istis": "^1.0.6",
+        "nv-facutil-ppgflike-is": "^1.0.1",
+        "nv-facutil-thrw": "^1.0.2",
+        "nv-number-zigzag": "^1.0.1",
+        "nv-regexp-flags": "^1.0.1"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.6",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/nv-buf-bi": {
+      "version": "1.0.5",
+      "license": "ISC"
+    },
+    "node_modules/nv-buf-jstr": {
+      "version": "1.0.8",
+      "license": "ISC"
+    },
+    "node_modules/nv-error-simple-trace": {
+      "version": "1.0.2",
+      "license": "ISC"
+    },
+    "node_modules/nv-facutil-ab": {
+      "version": "1.0.0",
+      "license": "ISC"
+    },
+    "node_modules/nv-facutil-basic": {
+      "version": "1.3.20",
+      "resolved": "https://registry.npmjs.org/nv-facutil-basic/-/nv-facutil-basic-1.3.20.tgz",
+      "integrity": "sha512-eGkAie/avH6ApghzuVApbszkwD8OX9d4u3Vl0pZnm0sV9etwdHn1trAFVTeMzadP9KMANCDI+ICwVY/a/KBKvw==",
+      "deprecated": "all-test-builtin-features-has-been-implemented-in-nvlang_this-is-useless-now",
+      "dependencies": {
+        "nanoid": "^3.1.22",
+        "nv-facutil-notandor": "^1.0.5"
+      }
+    },
+    "node_modules/nv-facutil-istis": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/nv-facutil-istis/-/nv-facutil-istis-1.0.6.tgz",
+      "integrity": "sha512-k0Vfu6ZkZEOkT/zfJ443DrwAHrxqtjAmE9BDGLY6ujoRneAcZFasuAElhzeDAMyOZbDjD5jzqnYZia2ECbmugQ==",
+      "dependencies": {
+        "nv-facutil-simple-test": "^0.0.13",
+        "nv-facutil-typis": "^1.0.3"
+      }
+    },
+    "node_modules/nv-facutil-notandor": {
+      "version": "1.0.5",
+      "license": "ISC"
+    },
+    "node_modules/nv-facutil-ppgflike-is": {
+      "version": "1.0.1",
+      "license": "ISC",
+      "dependencies": {
+        "nv-facutil-typis": "^1.0.5",
+        "nv-facutil-untf": "^1.0.2"
+      }
+    },
+    "node_modules/nv-facutil-simple-test": {
+      "version": "0.0.13",
+      "license": "ISC",
+      "dependencies": {
+        "nv-error-simple-trace": "^1.0.2",
+        "nv-facutil-basic": "^1.3.20"
+      }
+    },
+    "node_modules/nv-facutil-thrw": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/nv-facutil-thrw/-/nv-facutil-thrw-1.0.2.tgz",
+      "integrity": "sha512-r6+40+SxZkgtKUh/DMF58q7LUlmy2D5Nmmy0dsGU34taAil9TzYQhXL5+aMAyxz/nni3P4rWfYmDlVMvlxI8tA==",
+      "dependencies": {
+        "nv-facutil-typis": "^1.0.3"
+      }
+    },
+    "node_modules/nv-facutil-typis": {
+      "version": "1.0.5",
+      "license": "ISC"
+    },
+    "node_modules/nv-facutil-untf": {
+      "version": "1.0.2",
+      "license": "ISC"
+    },
+    "node_modules/nv-number-zigzag": {
+      "version": "1.0.1",
+      "license": "ISC"
+    },
+    "node_modules/nv-regexp-flags": {
+      "version": "1.0.1",
+      "license": "ISC"
+    }
+  }
+}

package/TEST/w-1bstr.js

@@ -0,0 +1,34 @@
+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 _1bs             = "abcd";
+_1bs = _1bs.repeat(256);
+
+
+ eq(f0(_1bs),f1(_1bs));
+
+
+console.log(sync(100000,f0,_1bs));
+console.log(sync(100000,f1,_1bs));
+

package/TEST/w-2bstr.js

@@ -0,0 +1,34 @@
+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 _2bs             = "aÿ我𝑒";
+_2bs = _2bs.repeat(32);
+
+
+ eq(f0(_2bs),f1(_2bs));
+
+
+console.log(sync(100000,f0,_2bs));
+console.log(sync(100000,f1,_2bs));
+