nv-buf-serde 0.0.2

package/const.js

@@ -0,0 +1,181 @@
+const {_u,_n,_t,_f} = require("nv-facutil-untf");
+
+
+const SerializationTag = {
+  kVersion: 255,
+  kPadding: 0,
+  kVerifyObjectCount: 63,
+  kTheHole: 45,
+  kUndefined: 95,
+  kNull: 48,
+  kTrue: 84,
+  kFalse: 70,
+  kInt32: 73,
+  kUint32: 85,
+  kDouble: 78,
+  kBigInt: 90,
+  kUtf8String: 83,
+  kOneByteString: 34,
+  kTwoByteString: 99,
+  kObjectReference: 94,
+  kBeginJSObject: 111,
+  kEndJSObject: 123,
+  kBeginSparseJSArray: 97,
+  kEndSparseJSArray: 64,
+  kBeginDenseJSArray: 65,
+  kEndDenseJSArray: 36,
+  kDate: 68,
+  kTrueObject: 121,
+  kFalseObject: 120,
+  kNumberObject: 110,
+  kBigIntObject: 122,
+  kStringObject: 115,
+  kRegExp: 82,
+  kBeginJSMap: 59,
+  kEndJSMap: 58,
+  kBeginJSSet: 39,
+  kEndJSSet: 44,
+  kArrayBuffer: 66,                            //B 0x42
+  kResizableArrayBuffer: 126,
+  kArrayBufferTransfer: 116,                   // unsupport 
+  kArrayBufferView: 86,                        //V 0x56 --------------- did not use , use nodejs delegate  kHostObject + 
+  kSharedArrayBuffer: 117,                     // unsupport
+  kSharedObject: 112,                          // unsupport
+  kWasmModuleTransfer: 119,                    // unsupport
+  kHostObject: 92,
+  kWasmMemoryTransfer: 109,                   //unsupport 
+  kError: 114,
+  kLegacyReservedMessagePort: 77,
+  kLegacyReservedBlob: 98,
+  kLegacyReservedBlobIndex: 105,
+  kLegacyReservedFile: 102,
+  kLegacyReservedFileIndex: 101,
+  kLegacyReservedDOMFileSystem: 100,
+  kLegacyReservedFileList: 108,
+  kLegacyReservedFileListIndex: 76,
+  kLegacyReservedImageData: 35,
+  kLegacyReservedImageBitmap: 103,
+  kLegacyReservedImageBitmapTransfer: 71,
+  kLegacyReservedOffscreenCanvas: 72,
+  kLegacyReservedCryptoKey: 75,
+  kLegacyReservedRTCCertificate: 107
+}
+
+const V8_ArrayBufferViewTag = {
+  kInt8Array: 98,
+  kUint8Array: 66,
+  kUint8ClampedArray: 67,
+  kInt16Array: 119,
+  kUint16Array: 87,
+  kInt32Array: 100,
+  kUint32Array: 68,
+  kFloat32Array: 102,
+  kFloat64Array: 70,
+  kBigInt64Array: 113,
+  kBigUint64Array: 81,
+  kDataView: 63
+}
+Object.defineProperty(V8_ArrayBufferViewTag,"UNUSED_",{get:function(){return(_t)}})
+
+
+const kNodeFastBufferSym = Symbol("#kNodeFastBuffer");
+
+const ArrayBufferViewTag = {
+  kInt8Array          :  0,
+  kUint8Array         : 1,
+  kUint8ClampedArray  : 2,
+  kInt16Array         : 3,
+  kUint16Array    : 4,
+  kInt32Array     : 5,
+  kUint32Array    : 6,
+  kFloat32Array   : 7,
+  kFloat64Array   : 8,
+  kDataView       : 9,  
+  kNodeFastBuffer   : 10,      //for compatible with node-js-fast-buffer, treated-as kUint8Array just add a 
+  kBigInt64Array:  11,
+  kBigUint64Array: 12,
+}
+
+class NodeFastBuffer extends Uint8Array { 
+    [kNodeFastBufferSym] = _t;
+}
+
+const IsNodeFastBuffer = (o)=>o[kNodeFastBufferSym] === _t;
+
+const  ObjectPrototypeToString = (o) => Object.prototype.toString.call(o);
+
+
+//<copied FROM nodejs/lib> 
+const  arrayBufferViewTypeToIndex  = (abView) => {
+  const type = ObjectPrototypeToString(abView);
+  if (type === '[object Int8Array]') return 0;
+  if (type === '[object Uint8Array]') return 1;
+  if (type === '[object Uint8ClampedArray]') return 2;
+  if (type === '[object Int16Array]') return 3;
+  if (type === '[object Uint16Array]') return 4;
+  if (type === '[object Int32Array]') return 5;
+  if (type === '[object Uint32Array]') return 6;
+  if (type === '[object Float32Array]') return 7;
+  if (type === '[object Float64Array]') return 8;
+  if (type === '[object DataView]') return 9;
+  // Index 10 is FastBuffer.
+  if (type === '[object BigInt64Array]') return 11;
+  if (type === '[object BigUint64Array]') return 12;
+  return -1;
+}
+//</copied FROM nodejs/lib >
+
+const ArrayBufferViewIndexToCtor = [
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    DataView,
+    NodeFastBuffer,
+    BigInt64Array,
+    BigUint64Array
+];
+
+
+const ErrorTag  = {
+  kEvalErrorPrototype: 69,
+  kRangeErrorPrototype: 82,
+  kReferenceErrorPrototype: 70,
+  kSyntaxErrorPrototype: 83,
+  kTypeErrorPrototype: 84,
+  kUriErrorPrototype: 85,
+  kMessage: 109,
+  kCause: 99,
+  kStack: 115,
+  kEnd: 46
+} 
+
+const kCantBeSered           =  "#___kCantBeSered___";
+const CreatFakeCantBeSered   = (id,hint)=>({id,kCantBeSered:hint});
+
+const kUnknown               =  "#___kUnknown___";
+const CreatUnknown           = ()=>({kUnknown:_u});
+
+
+const CODEC_NAME = "v8ser";
+
+module.exports = {
+   CODEC_NAME, kNodeFastBufferSym,
+   IsNodeFastBuffer,
+   //// 
+   SerializationTag,
+   V8_ArrayBufferViewTag,  //unused
+   ArrayBufferViewTag, ArrayBufferViewIndexToCtor, arrayBufferViewTypeToIndex, 
+   ErrorTag, 
+   ////
+   kCantBeSered,
+   CreatFakeCantBeSered, 
+   ////
+   kUnknown,
+   CreatUnknown,	
+}

package/ctx.js

@@ -0,0 +1,89 @@
+const _A = Array;
+
+const {_u,_n,_t,_f} = require("nv-facutil-untf");
+
+const {creat_nid} = require("./zero-nid");
+
+class WIdMap extends WeakMap {
+    #id = creat_nid();
+    ////
+    FindOrInsert(o) {
+       let idx = this.get(o);
+       if(idx === _u) {
+           let nidx = this.#id.next();
+           this.set(o,nidx);
+           return([_f,nidx])       // not obj-ref
+       } else {
+           return([_t,idx])        // is-obj-ref
+       }
+    }
+}
+
+const creat_widmap = () => new WIdMap();
+
+class Wctx {
+   //zone                             = _u;                                 //not-support
+   idmap                           = new WIdMap();
+   //array_buffer_transfer_map        = _u;                                 //not-support
+   //delegate                         = _u;                                 //not-support 
+   //shared_object_conveyor           = _u;                                 //not-support
+}
+
+const creat_wctx = ()=> new Wctx();
+
+
+class RIdMap extends _A {
+     HasObjectWithID(id)   {return(this[id]!==_u)}
+     GetObjectWithID(id)   {return(this[id])     }
+     AddObjectWithID(o)    {this.push(o)}
+     get nid_()            {return(this.length)}
+}
+
+const creat_ridmap = ()=>new RIdMap();
+
+/* 
+// for feature using 
+
+const ENTRY_TYPED = {
+     unknown:0,
+     ae:1,
+     dpair:2,
+     dk:3,
+     dp:4,
+     ste:5,
+     mpair:6,
+     mpk:7,
+     mpv:8
+}
+
+class Entry {
+    ref   = _u;
+    type  = ENTRY_TYPED.unknown;
+    pr    = _u;
+    twin  = _u;
+    constructor(ref,type,pr,twin) {
+        this.ref  = ref;
+        this.type = type;
+        this.pr   = pr;
+        this.twin = twin;
+    }
+}
+class Rctx {
+     idmap = new RIdMap();
+     stack = []
+     push(o,pr,type,twin) {
+         let e = new Entry(o,pr,type,twin);
+         this.stack.push(e)
+     }
+     get top_() {return(this[this.stack.length-1])}
+}
+
+const creat_rctx = ()=>new Rctx();
+*/
+
+module.exports = {
+   creat_widmap, 
+   creat_wctx,
+   creat_ridmap, 
+   creat_rctx   : creat_ridmap,
+}

package/fixed-cfg.js

@@ -0,0 +1,6 @@
+const {_u,_n,_t,_f} = require("nv-facutil-untf");
+
+module.exports = {
+    treat_array_buffer_views_as_host_objects_ :_t,          // FIXED CANT CHANGE , for compatible with nodejs-impl
+    suppress_deserialization_errors_          :_t,          // FIXED CANT CHANGE , this pkg did NOT do any check/validate/verify
+}

package/index.js

@@ -0,0 +1,27 @@
+const _fixed_cfg   = require("./fixed-cfg");
+const _restrict    = require("./restrict");
+const _const       = require("./const");
+const _misc        = require("./misc");
+const _zero_nid    = require("./zero-nid");
+const _ctx         = require("./ctx");
+const _w           = require("./w");
+const _r           = require("./r");
+
+
+
+
+
+
+module.exports = {
+    fixed_cfg    :       _fixed_cfg,
+    restrict     :       _restrict,
+    const        :       _const, 
+    misc         :       _misc,
+    zero_nid     :       _zero_nid,  // v8 impl require ref-id from 0	
+    ctx          :       _ctx,
+    w            :       _w,
+    r            :       _r,
+    ////----
+    ser: _w.encd,        // (o:JSValue,kLatestVersion=15)-> ArrayBuffer
+    der: _r.decd,        // (ab:ArrayBuffer)->JSValue
+}

package/misc.js

@@ -0,0 +1,112 @@
+
+const _S = String;
+const _is           = Object.is;
+const {istof,is_num}       = require("nv-facutil-typis");
+const {_u,_n,_t,_f} = require("nv-facutil-untf");
+const _zigzag   = require("nv-number-zigzag");
+const _utf16    = require("nv-buf-jstr");
+
+const BytesNeededForVarint = (value) => {
+    let result = 0;
+    do {
+        result++;
+        value >>= 7;
+    } while(value);
+    return(result);
+}
+
+const IsOneByte = (s) => {
+   for(let i=0;i<s.length;++i) {
+       if(s[i].charCodeAt(0) <256) {
+       } else {
+           return(_f)
+       }
+   }
+   return(_t) 
+}
+
+const IsTwoByte = (s) => !IsOneByte(s);
+
+const IsNaNAt = (u8a,si) => {
+   let dv = new DataView(u8a.buffer);
+   let r  = dv.getFloat64(si,_t);
+   return(_is(r,NaN)) 
+}
+
+
+const kFastElementsKindSequence = {
+    PACKED_SMI_ELEMENTS:0,
+    HOLEY_SMI_ELEMENTS:1,
+    PACKED_DOUBLE_ELEMENTS:2,
+    HOLEY_DOUBLE_ELEMENTS:3,
+    PACKED_ELEMENTS:4,
+    HOLEY_ELEMENTS:5,
+}
+
+const GetArrayForEachLength = (arr) => {
+   let cnt = 0;
+   arr.forEach(r=> {++cnt;});
+   return(cnt)
+}
+const IsArrayHasHole = (arr)=> GetArrayForOfLength(arr)!== arr.length;
+
+const IsSmi = (n) => _zigzag.is_smi(n) && Number.isInteger(n) && (!Object.is(n,-0));
+
+const GetArrayPackedInfo = (arr)=> {
+     let is_packed_smi    = _t;
+     let is_packed_double = _t;
+     let i=0;
+     while(i<arr.length){
+         if(is_packed_smi && IsSmi(arr[i])) {
+
+         } else if(is_num(arr[i])) {
+             is_packed_smi = _f;
+         } else {
+             is_packed_smi       = _f;
+             is_packed_double    = _f;
+             break;
+         }
+         ++i;
+     }
+     return({
+         is_packed_smi,
+         is_packed_double
+     })
+}
+
+const UTF8_DECODER = new TextDecoder();
+
+const Utf8U8aToStr = (u8a,si,sz,decd) => {
+    let nu8a = new Uint8Array(u8a.buffer,si,sz);
+    if(decd) {
+        return(decd(nu8a))
+    } else {
+        return(UTF8_DECODER.decode(nu8a))
+    }
+}
+
+const LATIN1_DECODER = new TextDecoder("latin1");
+const Latin1U8aToStr = (u8a,si,sz) => LATIN1_DECODER.decode(u8a.subarray(si,si+sz)); 
+
+
+const UTF16_DECODER=new TextDecoder("utf-16");
+const JstrU8aToStr = (u8a,si,sz) => UTF16_DECODER.decode(u8a.subarray(si,si+sz)); 
+
+
+
+module.exports = {
+    BytesNeededForVarint,
+    IsOneByte,
+    IsTwoByte,
+    IsNaNAt,
+    IsSmi,
+    ////
+    kFastElementsKindSequence,
+    GetArrayForEachLength,
+    IsArrayHasHole,
+    GetArrayPackedInfo,
+    ////
+    Utf8U8aToStr,
+    Latin1U8aToStr,
+    JstrU8aToStr
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "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"
+  },
+  "version": "0.0.2",
+  "name": "nv-buf-serde",
+  "description": "nv-buf-serde ======================= - rewrite  v8/src/objects/value-serializer.cc to JS  - to let you use  nodejs'v8.serialize AND nodejs'v8.deserialize  in browser, - similiar to structuredClone AND MessageChannel-transfer, but can be used to send/recv data to server-side",
+  "main": "index.js",
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC"
+}