nv-buf-storage 1.3.2

package/mthds/cmmn.js

@@ -0,0 +1,576 @@
+const _TD      = new TextDecoder();
+const _TE      = new TextEncoder();
+const {tacls_or_abcls_to_mthd_hint,taclsnm_to_tbrief} = require("nv-facutil-slct-ta"); 
+const _v8serde                        = require("nv-buf-serde"); 
+const { creat_sz_buf_for_dump,_COND_IS_NODE_ENV } = require("../util");
+
+
+function _calc_datasz_for_dump(compress=true) {
+    var datasz;
+    if(compress !== true)   {
+        datasz =  this._data.byteLength;
+    } else                  {
+        var [si,ei] = this._fl.lst_free_rng;
+        if(ei === this._fl.max_alocable_unit_cnt_v) {
+            datasz = si;
+        } else  {
+            datasz= this._data.byteLength;
+        }
+    }
+    return  datasz;
+}
+
+async function seperated_dump (dst_fn,compress=true) {
+    var [cond,fl_u8avw]  = await this._fl.dump(undefined,compress);
+    if(cond) {
+        var datasz     = this._calc_datasz_for_dump(compress);
+        var data_u8avw = this._data.subarray(0,datasz);
+        if(_COND_IS_NODE_ENV && typeof(dst_fn)=== "string") {
+            const _path = require("path");const _fs   = require("fs");dst_fn      = _path.resolve(dst_fn);const _wfile = require("nv-file-write2").simple;
+            var fl_dst_fn    = dst_fn+".fl";
+            var data_dst_fn  = dst_fn+".data";
+            var p0 = _wfile(fl_dst_fn,fl_u8avw,Infinity,0,{_fs,_path});
+            var p1 = _wfile(data_dst_fn,data_u8avw,Infinity,0,{_fs,_path});
+            await Promise.all([p0,p1]);
+            var pair0 = await p0;
+            var pair1 = await p1;
+            if(pair0[0] && pair1[0]) {
+                return [true,{fl:pair0[1],data:pair1[1]}];
+            } else {
+                return [false,{fl:pair0[1],data:pair1[1]}];
+            }
+        } else {
+            return [true,{fl:fl_u8avw,data:data_u8avw}];
+        }
+    } else {
+        return [false,fl_u8avw]
+    }
+}
+
+
+async function dump (dst_fn,compress=true) {
+    var [cond,fl_u8avw]   = await this._fl.dump(undefined,compress);
+    if(cond) {
+        var flsz      = fl_u8avw.byteLength;
+        var datasz     = this._calc_datasz_for_dump(compress);
+        var data_u8avw = this._data.subarray(0,datasz);
+        if(_COND_IS_NODE_ENV && typeof(dst_fn)=== "string") {
+            const _path = require("path");const _fs   = require("fs");dst_fn      = _path.resolve(dst_fn);const _wfile = require("nv-file-write2").simple_many;
+            var flszu8a   = creat_sz_buf_for_dump(flsz);
+            var dataszu8a = creat_sz_buf_for_dump(datasz);
+            return await _wfile(dst_fn,[flszu8a,fl_u8avw,dataszu8a,data_u8avw],65536,0,{_fs,_path});
+        } else {
+            var sz  = 8 + flsz + 8 + datasz;
+            var u8a = new Uint8Array(sz);
+            var dv  = new DataView(u8a.buffer);
+            dv.setFloat64(0,flsz,true);
+            u8a.set(fl_u8avw,8);
+            dv.setFloat64(8 + flsz,datasz,true);
+            u8a.set(data_u8avw , 8+ flsz+8);
+            return [true,u8a];
+        }
+    } else {
+        return [false,fl_u8avw]
+    }
+}
+dump.HELP = ["flsz(f64le)","fl(u8a)","datasz(f64le)","data(u8a)"];
+
+function dloc([si,ei]) {
+    return this._fl.dloc(si,ei);
+}
+function rstr([si,ei]) {return _TD.decode(this._data.subarray(si,ei))}
+function wstr(s)       {
+    var mx_sz     = s.length*3;
+    var [si,ei]   = this.aloc(mx_sz);
+    if(ei!== 0) {
+        var {__,written} = _TE.encodeInto(s,this._data.subarray(si,ei));
+        this._fl.dloc(si+written,ei);
+        return [si,si+written]
+    } else {
+        return [0,0]
+    }
+}
+function rjson([si,ei]) {return JSON.parse(this.rstr([si,ei]));}
+function wjson(j)       {return this.wstr(JSON.stringify(j)  );}
+
+
+function wta(ta,include_ab=true) {
+    var hint = tacls_or_abcls_to_mthd_hint(ta.constructor);
+    if(hint["?"]) {
+        return this?.[hint.w]?.(ta);
+    } else        {
+        return this[hint.w](ta);
+    }
+}
+
+function rta(Cls,rng) {
+    var hint = tacls_or_abcls_to_mthd_hint(Cls);
+    if(hint["?"]) {
+        return this?.[hint.r]?.(rng);
+    } else        {
+        var ta= this[hint.r](rng);
+        if(Cls === globalThis.Buffer){
+            return globalThis.Buffer.from(ta);
+        } else {
+            return ta;
+        }
+    }
+}
+
+
+function wo(o) {
+    var ab        = _v8serde.ser(o);
+    var u8a       = new Uint8Array(ab);
+    var sz        = u8a.byteLength;
+    var [si,ei]   = this.aloc(sz);
+    if(ei!== 0) {
+        this._data.set(u8a,si);
+        return [si,ei]
+    } else {
+        return [0,0]
+    }
+}
+function ro([si,ei]) {
+    var u8a = this._data.subarray(si,ei);
+    return _v8serde.der(u8a);
+}
+
+// undefined null true false 在type 里 可以表示 不需要内存
+
+
+//number-like
+function ru8([si,ei])  {return this._dv.getUint8(si,true);}
+function ru16([si,ei]) {return this._dv.getUint16(si,true);}
+function ru32([si,ei]) {return this._dv.getUint32(si,true);}
+function ru64([si,ei]) {return this._dv.getBigUint64(si,true);}
+function ri8([si,ei])  {return this._dv.getInt8(si,true);}
+function ri16([si,ei]) {return this._dv.getInt16(si,true);}
+function ri32([si,ei]) {return this._dv.getInt32(si,true);}
+function ri64([si,ei]) {return this._dv.getBigInt64(si,true) ;}
+function rf32([si,ei]) {return this._dv.getFloat32(si,true);}
+function rf64([si,ei]) {return this._dv.getFloat64(si,true);}
+
+function wu8(num) {
+    var [si,ei]= this.aloc(1);
+    if(ei!== 0) {
+        this._dv.setUint8(si,num,true);
+        return [si,ei];
+    } else {
+        return [0,0]
+    }
+}
+
+
+function wu16(num,algn=false) {
+    var si=0;ei=0;
+    if(algn) {
+        [si,ei]= this.algn_aloc(2,2);
+    } else {
+        [si,ei]= this.aloc(2);
+    }
+    if(ei!== 0) {
+        this._dv.setUint16(si,num,true);
+        return [si,ei];
+    } else {
+        return [0,0]
+    }
+
+}
+function wu32(num,algn=false) {
+    var si=0;ei=0;
+    if(algn) {
+        [si,ei]= this.algn_aloc(4,4);
+    } else {
+        [si,ei]= this.aloc(4);
+    }
+    if(ei!== 0) {
+        this._dv.setUint32(si,num,true);
+        return [si,ei];
+    } else {
+        return [0,0]
+    }
+}
+function wu64(bi,algn=false) {
+    var si=0;ei=0;   
+    if(algn) {
+        [si,ei]= this.algn_aloc(8,8);
+    } else {
+        [si,ei]= this.aloc(8);
+    }
+    if(ei!== 0) {
+        this._dv.setBigUint64(si,BigInt(bi),true);
+        return [si,ei];
+    } else {
+        return [0,0]
+    }
+
+}
+function wi8(num) {
+    var [si,ei] = this.aloc(1);
+    if(ei !== 0) {
+        this._dv.setInt8(si,num,true);
+        return [si,ei];
+    } else {
+        return [0,0];
+    }
+}
+
+function wi16(num,algn=false) {
+    var si=0,ei=0;
+    if(algn) {
+        [si,ei] = this.algn_aloc(2,2);
+    } else {
+        [si,ei] = this.aloc(2);
+    }
+    if(ei !== 0) {
+        this._dv.setInt16(si,num,true);
+        return [si,ei];
+    } else {
+        return [0,0];
+    }
+}
+
+function wi32(num,algn=false) {
+    var si=0,ei=0;
+    if(algn) {
+        [si,ei] = this.algn_aloc(4,4);
+    } else {
+        [si,ei] = this.aloc(4);
+    }
+    if(ei !== 0) {
+        this._dv.setInt32(si,num,true);
+        return [si,ei];
+    } else {
+        return [0,0];
+    }
+}
+
+function wi64(bi,algn=false) {
+    var si=0;ei=0;
+    if(algn) {
+        [si,ei]= this.algn_aloc(8,8);
+    } else {
+        [si,ei]= this.aloc(8);
+    }
+    if(ei!== 0) {
+        this._dv.setBigInt64(si,BigInt(bi),true);
+        return [si,ei];
+    } else {
+        return [0,0]
+    }
+
+}
+function wf32(num,algn=false) {
+    var si=0;ei=0;
+    if(algn) {
+        [si,ei]= this.algn_aloc(4,4);
+    } else {
+        [si,ei]= this.aloc(4);
+    }
+    if(ei!== 0) {
+        this._dv.setFloat32(si,num,true);
+        return [si,ei];
+    } else {
+        return [0,0]
+    }
+}
+
+function wf64(num,algn=false) {
+    var si=0;ei=0;
+    if(algn) {
+        [si,ei]= this.algn_aloc(8,8);
+    } else {
+        [si,ei]= this.aloc(8);
+    }
+    if(ei!== 0) {
+        this._dv.setFloat64(si,num,true);
+        return [si,ei];
+    } else {
+        return [0,0]
+    }
+
+}
+
+////typed-array
+function ru8a([si,ei])  {return new Uint8Array             (this._data.buffer,this._data.byteOffset+si, ei-si)   ;}
+function ru8ca([si,ei]) {return new Uint8ClampedArray      (this._data.buffer,this._data.byteOffset+si, ei-si)   ;}
+function ru16a([si,ei]) {return new Uint16Array            (this._data.buffer,this._data.byteOffset+si,(ei-si)/2);}
+function ru32a([si,ei]) {return new Uint32Array            (this._data.buffer,this._data.byteOffset+si,(ei-si)/4);}
+function ru64a([si,ei]) {return new BigUint64Array         (this._data.buffer,this._data.byteOffset+si,(ei-si)/8);}
+function ri8a([si,ei])  {return new Int8Array              (this._data.buffer,this._data.byteOffset+si, ei-si)   ;}
+function ri16a([si,ei]) {return new Int16Array             (this._data.buffer,this._data.byteOffset+si,(ei-si)/2);}
+function ri32a([si,ei]) {return new Int32Array             (this._data.buffer,this._data.byteOffset+si,(ei-si)/4);}
+function ri64a([si,ei]) {return new BigInt64Array          (this._data.buffer,this._data.byteOffset+si,(ei-si)/8);}
+function rf32a([si,ei]) {return new globalThis.Float32Array(this._data.buffer,this._data.byteOffset+si,(ei-si)/4);}
+function rf64a([si,ei]) {return new globalThis.Float64Array(this._data.buffer,this._data.byteOffset+si,(ei-si)/8);}
+function rdv([si,ei])   {return new DataView               (this._data.buffer,this._data.byteOffset+si, ei-si)   ;}
+function _write_no_need_algn_typed_array(ta1b) {
+    var [si,ei] = this.aloc(ta1b.byteLength);
+    if(ei !== 0) {
+        var src_u8a = new Uint8Array(ta1b.buffer,ta1b.byteOffset,ta1b.byteLength)
+        this._data.set(src_u8a,si);
+        return [si,ei];
+    } else {
+        return [0,0];
+    }
+}
+function _write_need_algn_typed_array(ta) {
+    var [si,ei]= this.algn_aloc(ta.byteLength,ta.constructor.BYTES_PER_ELEMENT);
+    if(ei!== 0) {
+        var src_u8a = new Uint8Array(ta.buffer,ta.byteOffset,ta.byteLength);
+        this._data.set(src_u8a,si);
+        return [si,ei];
+    } else {
+        return [0,0]
+    }
+}
+
+//----仅测试,此接口速度很慢,应该显式调用 this.rxxx([si,ei])
+
+const DEBUG_TBRIEF_TO_MTHD_HINT = {
+    "s":  { r: "rstr",  w: "wstr",  "?": false },
+    "json": { r: "rjson", w: "wjson", "?": false },
+    "f16": { r: "rf16", w: "wf16", "?": true },
+    "f32": { r: "rf32", w: "wf32", "?": false },
+    "f64": { r: "rf64", w: "wf64", "?": false },
+    "u8":  { r: "ru8",  w: "wu8",  "?": false },
+    "u16": { r: "ru16", w: "wu16", "?": false },
+    "u32": { r: "ru32", w: "wu32", "?": false },
+    "u64": { r: "ru64", w: "wu64", "?": false },
+    "i8":  { r: "ri8",  w: "wi8",  "?": false },
+    "i16": { r: "ri16", w: "wi16", "?": false },
+    "i32": { r: "ri32", w: "wi32", "?": false },
+    "i64": { r: "ri64", w: "wi64", "?": false },
+    "u8a":  { r: "ru8a",  w: "wu8a",  "?": false },
+    "u8ca": { r: "ru8ca", w: "wu8ca", "?": false },
+    "u16a": { r: "ru16a", w: "wu16a", "?": false },
+    "u32a": { r: "ru32a", w: "wu32a", "?": false },
+    "u64a": { r: "ru64a", w: "wu64a", "?": false },
+    "i8a":  { r: "ri8a",  w: "wi8a",  "?": false },
+    "i16a": { r: "ri16a", w: "wi16a", "?": false },
+    "i32a": { r: "ri32a", w: "wi32a", "?": false },
+    "i64a": { r: "ri64a", w: "wi64a", "?": false },
+    "f16a": { r: "rf16a", w: "wf16a", "?": true },
+    "f32a": { r: "rf32a", w: "wf32a", "?": false },
+    "f64a": { r: "rf64a", w: "wf64a", "?": false },
+    "dv":   { r: "rdv", w: "wdv", "?": false }   , 
+    ////
+    "u": {v:undefined},
+    "n": {v:null},
+    "t": {v:true},
+    "f": {v:false},
+    "ly_undef" : {v:Symbol()},
+    ////
+    "gy":{f:(self,si,ei)=>Symbol.for(self.rstr([si,ei]))},
+    "ly":{f:(self,si,ei)=>Symbol(self.rstr([si,ei]))},
+    ////
+    "flike":{unsupported:true},
+    "wkst":{unsupported:true},
+    "wkmp":{unsupported:true},
+    "wkref":{unsupported:true},
+    "prms":{unsupported:true},
+    "iter":{unsupported:true},
+    "sg":{unsupported:true},
+    "ag":{unsupported:true},
+    "unsupported":{unsupported:true},
+     ////
+};
+
+function debug_read(T,[si,ei]) {
+    var instruction = DEBUG_TBRIEF_TO_MTHD_HINT[T];
+    if(instruction?.r!== undefined) {
+        if(instruction["?"]) {
+            return this?.[instruction.r]?.([si,ei]);
+        } else {
+            return this[instruction.r]([si,ei]);
+        }
+    } else if(instruction?.hasOwnProperty?.("v")) {
+        return instruction.v;
+    } else if(instruction?.hasOwnProperty?.("f")) {
+        return instruction.f(this,si,ei);
+    } else if(instruction?.hasOwnProperty?.unsupported) {
+        throw("unsupported");
+    } else if(ei === 0) {
+        throw("not_exists");
+    } else {
+        return this.ro([si,ei]);
+    }
+}
+
+
+
+////----仅测试,此接口速度很慢,应该显式调用 this.wxxx(o);
+function debug_wnum(o) {
+    if(Number.isInteger(o)) {
+        if(Object.is(o,-0))    { return ["i8",  this.wi8(o)];}
+        if(o>=0) {
+            if(o<256)          { return ["u8", this.wu8(o)];
+            } else if(o<65536) { return ["u16",this.wu16(o)];
+            } else if(o<2**32) { return ["u32",this.wu32(o)];
+            } else {
+                return ["f64",this.wf64(o)];
+            }
+        } else   {
+            if(o>=-128)            { return ["i8",  this.wi8(o)];
+            } else if(o>=-32768)   { return ["i16", this.wi16(o)];
+            } else if(o>=-(2**31)) { return ["i16", this.wi32(o)];
+            } else {
+                return ["f64",this.wf64(o)];
+            }
+        }
+    } else                  {
+        return ["f64",this.wf64(o)];
+    }
+}
+
+function debug_wbi(o) {
+    if(o>=0n && o< 2n**64n) {
+        return ["u64",this.wu64(o)];
+    } else if(o>= -(2n**63n) && o<0n) {
+        return ["i64",this.wi64(o)];
+    } else {
+        return ["bi",this.wo(o)];
+    }
+}
+
+function debug_wsym(o) {
+    var key_for = Symbol.keyFor(o);
+    if(key_for !== undefined) {
+        return ["gy",this.wstr(o.description)];
+    } else {
+        if(o.description !== undefined) {
+            return ["ly",this.wstr(o.description)];
+        } else {
+            return ["ly_undef",[0,0]];
+        }
+    }
+}
+
+const V8SERIALABLE_NONTA_OBJ_CLSNMS = [
+    "ArrayBuffer"        ,
+    "SharedArrayBuffer"  ,
+    "Map"                ,
+    "Set"                ,
+    "Date"               ,
+    "RegExp"             ,
+    "String"             ,
+    "Number"             ,
+    "Boolean"            ,
+    "Error"              ,
+    "AggregateError"     ,
+    "EvalError"          ,
+    "RangeError"         ,
+    "ReferenceError"     ,
+    "URIError"           ,
+    "TypeError"          ,
+    "SyntaxError"        ,
+];
+
+function debug_write(o) {
+    if(o === undefined) {
+        return ['u',[0,0]];
+    } else if(o === null) {
+        return ['n',[0,0]];
+    } else if(o === true) {
+        return ['t',[0,0]];
+    } else if(o === false) {
+        return ['f',[0,0]];
+    } else {
+        var tnm = typeof(o);
+        if(tnm === "string") {
+            return ["s",this.wstr(o)];
+        } else if(tnm === "number") {
+            return this.debug_wnum(o);
+        } else if(tnm === "bigint") {
+            return this.debug_wbi(o);
+        } else if(tnm === "symbol") {
+            return this.debug_wsym(o);
+        } else if(tnm === "function") { //unsupported
+            return ["flike",[0,0]];
+        } else if(tnm === "object")   {
+            var clsnm = o.constructor.name;
+	    var tbrief = taclsnm_to_tbrief(clsnm);
+	    if(tbrief !== undefined) {
+                var hint = DEBUG_TBRIEF_TO_MTHD_HINT[tbrief];
+		if(hint["?"]) {
+		    return [tbrief,this?.[hint.w]?.(o)];
+		} else {
+		    return [tbrief,this[hint.w](o)];
+		}
+            } else if(V8SERIALABLE_NONTA_OBJ_CLSNMS.includes(clsnm)) {
+                return ["other",this.wo(o)]
+            } else if(
+                clsnm === "WeakSet"        ||
+                clsnm === "WeakMap"        ||
+                clsnm === "Promise"        ||
+                clsnm === "Iterator"       ||
+                clsnm === "WeakRef"        ||
+                o[Symbol.toStringTag] === "Generator" ||
+                o[Symbol.toStringTag] === "AyncGenerator"
+            ) { 
+                return ["unsupported",[0,0]]
+            } else {
+                return ["other",this.wo(o)]
+            }
+        } else {
+            return ["other",this.wo(o)]
+        }
+    }    
+}
+
+module.exports = {
+    _calc_datasz_for_dump,
+    seperated_dump, dump,
+    dloc,
+    ////	
+    rstr,wstr,rjson,wjson,rta,wta,ro,wo,
+    ////
+    ru8,ru16,ru32,ru64,
+    ri8,ri16,ri32,ri64,
+    wu8,wu16,wu32,wu64,
+    wi8,wi16,wi32,wi64,
+    rf32,rf64,
+    wf32,wf64,
+    ////
+    ru8a,ru8ca,ru16a,ru32a,ru64a,
+    ri8a,      ri16a,ri32a,ri64a,
+    rf32a,rf64a,
+    rdv,
+    wu8a:_write_no_need_algn_typed_array,
+    wu8ca:_write_no_need_algn_typed_array,
+    wi8a:_write_no_need_algn_typed_array,
+    wdv:_write_no_need_algn_typed_array,
+    wu16a:_write_need_algn_typed_array,
+    wu32a:_write_need_algn_typed_array,
+    wu64a:_write_need_algn_typed_array,
+    wi16a:_write_need_algn_typed_array,
+    wi32a:_write_need_algn_typed_array,
+    wi64a:_write_need_algn_typed_array,
+    wf32a:_write_need_algn_typed_array,
+    wf64a:_write_need_algn_typed_array,   
+    ////
+    debug_read,
+    debug_wnum,debug_wbi,debug_wsym,
+    debug_write,
+}
+
+if(DataView.prototype.getFloat16 !== undefined) {
+    module.exports.rf16 = function([si,ei]) {return this._dv.getFloat16(si,true);}
+    module.exports.wf16 = function(num,algn=false) {
+        var si=0;ei=0;
+        if(algn) {
+            [si,ei]= this.algn_aloc(2,2);
+        } else {
+            [si,ei]= this.aloc(2);
+        }
+        if(ei!== 0) {
+            this._dv.setFloat16(si,num,true);
+            return [si,ei];
+        } else {
+            return [0,0]
+        }
+    }
+    module.exports.rf16a = function([si,ei]) {return new globalThis.Float16Array(this._data.buffer,this._data.byteOffset+si,(ei-si)/2);}
+    module.exports.wf16a =  _write_need_algn_typed_array;   
+}
+

package/mthds/non-scalable.js

@@ -0,0 +1,9 @@
+
+function aloc(sz) { return this._fl.aloc(sz);}
+
+function algn_aloc(sz,algn) { return this._fl.algn_aloc(sz,algn);}
+
+module.exports = {
+    aloc,
+    algn_aloc
+}

package/mthds/scalable.js

@@ -0,0 +1,36 @@
+const _resize_data = require("nv-buf-resize-util");
+
+function aloc(sz) {
+    var [si,ei]   = this._fl.aloc(sz);
+    if(ei!==0) { } else {
+        var [cond,incr_unit_cnt] = this._fl.expand(this._fl.max_alocable_unit_cnt_v + sz);
+        if(cond) {
+            this._data    = _resize_data.expand(this._data,incr_unit_cnt);
+            this._dv    = new DataView(this._data.buffer,this._data.byteOffset,this._data.byteLength);
+            [si,ei]       = this._fl.aloc(sz);
+        } else {
+            return [0,0]
+        }
+    }
+    return [si,ei]
+}
+
+function algn_aloc(sz,algn) {
+    var [si,ei]   = this._fl.algn_aloc(sz,algn);
+    if(ei!==0) { } else {
+        var [cond,incr_unit_cnt] = this._fl.expand(this._fl.max_alocable_unit_cnt_v + sz+algn);
+        if(cond) {
+            this._data    = _resize_data.expand(this._data,incr_unit_cnt);
+            this._dv    = new DataView(this._data.buffer,this._data.byteOffset,this._data.byteLength);
+            [si,ei]       = this._fl.algn_aloc(sz,algn);
+        } else {
+            return [0,0]
+        }
+    }
+    return [si,ei]
+}
+
+module.exports = {
+    aloc,
+    algn_aloc
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "nv-buf-storage",
+  "version": "1.3.2",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "nv-buf-free-list2": "^1.2.1",
+    "nv-buf-resize-util": "^1.0.0",
+    "nv-buf-serde": "^1.0.0",
+    "nv-facutil-slct-ta": "^1.0.10",
+    "nv-file-read2": "^1.0.2",
+    "nv-file-write2": "^1.0.11"
+  },
+  "devDependencies": {
+    "nv-random-bufvw": "^1.0.4",
+    "nv-random-date": "^1.0.1",
+    "nv-random-rgx": "^1.0.0",
+    "nv-random-sml-json": "^1.0.2"
+  }
+}

package/util.js

@@ -0,0 +1,63 @@
+const {get_cls_from_dump_fst_byte} = require("nv-facutil-slct-ta");
+
+const creat_sz_buf_for_dump = (sz)=>{
+    var f64a = new Float64Array(1);
+    f64a[0] = sz;
+    return  new Uint8Array(f64a.buffer);
+}
+const read_sz_from_sz_buf = (szbuf) => {
+    var f64a = new Float64Array(szbuf.buffer);
+    return f64a[0];
+}
+
+//从文件si 开始读取 sz 内容
+const sync_read_segment_from_file = (src,si,sz,_fs)=>{
+    var buf   = new Uint8Array(sz);
+    const fd = _fs.openSync(src, 'r');
+    _fs.readSync(fd, buf, 0, sz, si); // fs.readSync(fd, buffer, 0, 32, 0); // fd, buffer, bufferOffset, length, position
+    _fs.closeSync(fd);
+    return buf;
+}
+
+const PRE_LOAD_BYTSZ = 8 + 8*9 +8;
+const read_preload_info = (src,_fs)=>{
+    var buf;
+    if(typeof(src)==="string") {
+        buf   = sync_read_segment_from_file(src,0,PRE_LOAD_BYTSZ,_fs);
+    } else {
+        buf = src;
+    }
+    var dv    = new DataView(buf.buffer);
+    var flsz = dv.getFloat64(0,true);
+    ////
+    buf         = buf.subarray(8);
+    var TaCls   = get_cls_from_dump_fst_byte(buf[0]);
+    var preload = new TaCls(buf.buffer,8,9);
+    return {
+        flsz,
+        max_alocable_unit_cnt_v: preload[5],
+    }
+}
+
+const read_brief_info_from_dump = (src,_fs)=>{
+    var {flsz,max_alocable_unit_cnt_v} = read_preload_info(src,_fs);
+    var dataszu8a =  sync_read_segment_from_file(src,8+flsz,8,_fs);
+    var datasz = (new Float64Array(dataszu8a.buffer))[0];
+    return {
+        flsz,
+        max_alocable_unit_cnt_v,
+        datasz,
+        is_data_compressed: (datasz < max_alocable_unit_cnt_v),
+    }
+}
+const _COND_IS_NODE_ENV = typeof globalThis.process === "object" && typeof require === "function";
+
+module.exports = {
+    PRE_LOAD_BYTSZ,
+    creat_sz_buf_for_dump,
+    read_sz_from_sz_buf,
+    sync_read_segment_from_file,
+    read_preload_info,
+    read_brief_info_from_dump,
+    _COND_IS_NODE_ENV,
+}