@alexgyver/bson 2.2.1 → 3.0.0

package/bson.js

@@ -1,237 +1,283 @@
-const BS_STRING = (0 << 5);
-const BS_BOOLEAN = (1 << 5);
-const BS_INTEGER = (2 << 5);
-const BS_FLOAT = (3 << 5);
-const BS_CODE = (4 << 5);
-const BS_BINARY = (5 << 5);
-const BS_CONTAINER = (6 << 5);
-const BS_NULL = (7 << 5);
+//#region Const
+// type
+const BS_TYPE_MASK = 0b11000000;
+const BS_SUBT = 0 << 6;
+const BS_INT = 1 << 6;
+const BS_STR = 2 << 6;
+const BS_CODE = 3 << 6;
+
+// subtype
+const BS_SUBT_MASK = 0b00111000;
+const BS_NULL = 0 << 3;
+const BS_BOOL = 1 << 3;
+const BS_CONT = 2 << 3;
+const BS_FLOAT = 3 << 3;
+const BS_BIN = 4 << 3;
+
+// type int
+const BS_INT_SMALL = 1 << 5;
+const BS_INT_NEG = 1 << 4;
+const BS_GET_SMALLV = x => x & 0b11111;
+const BS_GET_INT_LEN = x => x & 0b1111;
+
+// type string
+// type code
+const BS_EXT_BITS = 5;
+const BS_EXT_FLAG = 1 << BS_EXT_BITS;
+const BS_EXT_MASK = BS_EXT_FLAG - 1;
+const BS_MAX_EXT_LEN = (1 << (BS_EXT_BITS + 8)) - 1;
+const BS_GET_LSB = x => x & BS_EXT_MASK;
+const BS_GET_MSB = x => x >> BS_EXT_BITS;
+const BS_CODE_PREFIX = "__BS#";
 
-const BS_CONT_OBJ = (1 << 4);
-const BS_CONT_OPEN = (1 << 3);
-const BS_CONT_ARR = (1 << 2);
-const BS_CONT_CLOSE = (1 << 1);
+// subtype cont
+const BS_CONT_ARR = 0 << 0;
+const BS_CONT_OBJ = 1 << 0;
+const BS_CONT_CLOSE = 0 << 1;
+const BS_CONT_OPEN = 1 << 1;
 
-const BS_MAX_LEN = 0b0001111111111111;
+// subtype float
+const BS_GET_FLOAT_LEN = x => 1 << ((x) & 0b111);
+const BS_FLOAT_F32 = 2;
 
-const BS_TYPE_MASK = 0b11100000;
-const BS_TYPE = x => x & BS_TYPE_MASK;
-const BS_DATA_MASK = 0b00011111;
-const BS_DATA = x => x & BS_DATA_MASK;
+// subtype bin
+const BS_GET_BIN_LEN = x => x & 0b111;
 
-const BS_BOOLV_MASK = 0b1;
-const BS_BOOLV = x => x & BS_BOOLV_MASK;
+//#region BSDecoder
+export class BSDecoder {
+    offset = 0;
+    cont = 'root';
+    tdec = new TextDecoder();
 
-const BS_NEG_MASK = 0b10000;
-const BS_NEGATIVE = x => x & BS_NEG_MASK;
-const BS_SIZE_MASK = 0b01111;
-const BS_SIZE = x => x & BS_SIZE_MASK;
+    constructor(buf, codes) {
+        this.buf = buf;
+        this.codes = codes;
+    }
 
-const BS_FLOAT_SIZE = 4;
+    decode() {
+        if (!(this.buf instanceof Uint8Array) || !this.buf.length) return undefined;
 
-const BS_D16_MSB = x => (x >> 8) & BS_DATA_MASK;
-const BS_D16_LSB = x => x & 0xff;
-const BS_D16_MERGE = (msb5, lsb) => ((msb5 << 8) | lsb) >>> 0;
+        let res = this._decode();
+        if (this.offset != this.buf.length) throw this._err("Broken packet");
+        return res;
+    }
+    read(len) {
+        if (this.offset + len > this.buf.length) {
+            throw this._err("Overflow");
+        }
+        let res = this.buf.subarray(this.offset, this.offset + len);
+        this.offset += len;
+        return res;
+    }
+    readB() {
+        return this.read(1)[0];
+    }
+    readInt(len) {
+        let val = 0;
+        let bytes = this.read(len);
+        while (len--) val = (val << 8) | bytes[len];
+        return val;
+    }
+    _ext(hdr) {
+        return BS_GET_LSB(hdr) | ((hdr & BS_EXT_FLAG) ? (this.readB() << BS_EXT_BITS) : 0);
+    }
+    _close(res, isObj) {
+        if (res && res.__close !== undefined) {
+            if (isObj === res.__close) return true;
+            throw this._err("Wrong close");
+        }
+        return false;
+    }
+    _err(e) {
+        return new Error(e + ' in ' + JSON.stringify(this.cont));
+    }
+    _decode() {
+        const header = this.readB();
 
-const BS_CODE_PREFIX = "__BS#";
+        let type = header & BS_TYPE_MASK;
+        if (type == BS_SUBT) type = header & BS_SUBT_MASK;
 
-/**
- * @param {Uint8Array} b
- * @param {Array} codes
- * @returns {Object|Array|*}
- */
-export function decodeBson(buf, codes = []) {
-    if (!(buf instanceof Uint8Array) || !buf.length) return undefined;
-
-    const reader = {
-        buf,
-        offset: 0,
-        cont: 'root',
-        decoder: new TextDecoder(),
-        error(e) {
-            return new Error(e + ' in ' + JSON.stringify(this.cont));
-        },
-        read(len) {
-            if (this.offset + len > buf.length) {
-                throw this.error("Overflow");
-            }
-            const res = this.buf.subarray(this.offset, this.offset + len);
-            this.offset += len;
-            return res;
-        },
-        readB() {
-            return this.read(1)[0];
-        }
-    };
+        switch (type) {
+            case BS_CONT:
+                if (header & BS_CONT_OPEN) {
+                    let isObj = !!(header & BS_CONT_OBJ);
+                    let cont = isObj ? {} : [];
 
-    let res = _decode(reader, codes);
-    if (reader.offset != reader.buf.length) throw reader.error("Broken packet");
-    return res;
-}
+                    while (true) {
+                        this.cont = cont;
+
+                        let res = this._decode();
+                        if (this._close(res, isObj)) return cont;
+
+                        if (isObj) {
+                            let val = this._decode();
+                            if (this._close(val, isObj)) throw this._err("Missed value");
 
-function _decode(r, codes) {
-    const header = r.readB();
-    const data = BS_DATA(header);
-
-    switch (BS_TYPE(header)) {
-        case BS_CONTAINER:
-            if (data & BS_CONT_OPEN) {
-                let isArr = !!(data & BS_CONT_ARR);
-                let cont = isArr ? [] : {};
-                let expect = false;
-                let key;
-
-                while (true) {
-                    r.cont = cont;
-                    let res = _decode(r, codes);
-
-                    if (res && res.__close !== undefined) {
-                        if (isArr === res.__close) {
-                            if (!isArr && expect) throw r.error("Missed value");
-                            return cont;
+                            cont[String(res)] = val;
                         } else {
-                            throw r.error("Wrong close");
+                            cont.push(res);
                         }
                     }
+                }
+                return { __close: !!(header & BS_CONT_OBJ) };
 
-                    if (isArr) {
-                        cont.push(res);
-                    } else {
-                        if (expect) cont[key] = res;
-                        else key = res;
-                        expect = !expect;
-                    }
+            case BS_INT:
+                if (header & BS_INT_SMALL) {
+                    return BS_GET_SMALLV(header);
+                } else {
+                    let val = this.readInt(BS_GET_INT_LEN(header));
+                    return (header & BS_INT_NEG) ? -val : val;
                 }
-            } else if (data & BS_CONT_CLOSE) {
-                return { __close: !!(data & BS_CONT_ARR) };
-            } else {
-                throw r.error("Unknown cont");
-            }
-        // break;
 
-        case BS_CODE:
-            return codes[BS_D16_MERGE(data, r.readB())];
+            case BS_STR:
+                return this.tdec.decode(this.read(this._ext(header)));
 
-        case BS_STRING: {
-            let len = BS_D16_MERGE(data, r.readB());
-            return r.decoder.decode(r.read(len));
-        }
+            case BS_CODE:
+                return this.codes[this._ext(header)];
 
-        case BS_INTEGER: {
-            let size = BS_SIZE(data);
-            if (!size) return 0;
+            case BS_NULL:
+                return null;
 
-            let value = 0n;
-            const bytes = r.read(size);
-            while (size--) value = (value << 8n) | BigInt(bytes[size]);
+            case BS_BOOL:
+                return !!(header & 1);
 
-            if (BS_NEGATIVE(data)) value = -value;
-            return (value >= Number.MIN_SAFE_INTEGER && value <= Number.MAX_SAFE_INTEGER) ? Number(value) : value;
+            case BS_FLOAT: {
+                let len = BS_GET_FLOAT_LEN(header);
+                const b = this.read(len);
+                let view = new DataView(b.buffer, b.byteOffset, len);
+                return (len == 4) ? view.getFloat32(0, true) : ((len == 8) ? view.getFloat64(0, true) : 0);
+            }
+
+            case BS_BIN:
+                return this.read(this.readInt(BS_GET_BIN_LEN(header))).slice();
         }
+    }
+}
+
+//#region BSEncoder
+export class BSEncoder {
+    arr = [];
+    tenc = new TextEncoder();
+
+    constructor(codes = []) {
+        this.codes = codes;
+    }
+
+    getArray() {
+        return Uint8Array.from(this.arr);
+    }
+
+    encode(val) {
+        let a = this.arr;
+
+        if (Array.isArray(val)) {
+            a.push(BS_SUBT | BS_CONT | BS_CONT_ARR | BS_CONT_OPEN);
+            val.forEach(v => this.encode(v));
+            a.push(BS_SUBT | BS_CONT | BS_CONT_ARR | BS_CONT_CLOSE);
+        } else {
+            switch (typeof val) {
+                case 'object':
+                    if (val === null) {
+                        a.push(BS_SUBT | BS_NULL);
+                    } else if (val instanceof Uint8Array) {
+                        let lenb = this._int(val.length);
+                        a.push(BS_SUBT | BS_BIN | lenb.length);
+                        a.push(...lenb);
+                        a.push(...val);
+                    } else {
+                        a.push(BS_SUBT | BS_CONT | BS_CONT_OBJ | BS_CONT_OPEN);
+                        for (const [key, value] of Object.entries(val)) {
+                            this.encode(key);
+                            this.encode(value);
+                        }
+                        a.push(BS_SUBT | BS_CONT | BS_CONT_OBJ | BS_CONT_CLOSE);
+                    }
+                    break;
 
-        case BS_BOOLEAN:
-            return !!BS_BOOLV(data);
+                case 'number':
+                    if (Number.isInteger(val)) {
+                        if (val >= 0 && val < BS_INT_SMALL) {
+                            a.push(BS_INT | BS_INT_SMALL | val);
+                        } else {
+                            let neg = val < 0;
+                            if (neg) val = -val;
+                            let bytes = this._int(val);
+                            a.push(BS_INT | (neg ? BS_INT_NEG : 0) | bytes.length);
+                            a.push(...bytes);
+                        }
+                    } else {
+                        const buffer = new ArrayBuffer(4);
+                        new DataView(buffer).setFloat32(0, val, true);
+                        a.push(BS_SUBT | BS_FLOAT | BS_FLOAT_F32);
+                        a.push(...new Uint8Array(buffer));
+                    }
+                    break;
+
+                case 'string':
+                    if (val.startsWith(BS_CODE_PREFIX)) {
+                        val = val.slice(BS_CODE_PREFIX.length);
+                        let code = this.codes.indexOf(val);
+                        if (code >= 0) this._ext(BS_CODE, code);
+                        else this.encode(val);
+                    } else {
+                        const bytes = this.tenc.encode(val);
+                        const len = Math.min(bytes.length, BS_MAX_EXT_LEN);
+                        this._ext(BS_STR, len);
+                        a.push(...bytes.slice(0, len));
+                    }
+                    break;
 
-        case BS_NULL:
-            return null;
+                case 'boolean':
+                    a.push(BS_SUBT | BS_BOOL | !!val);
+                    break;
 
-        case BS_FLOAT: {
-            const b = r.read(4);
-            return new DataView(b.buffer, b.byteOffset, 4).getFloat32(0, true);
+                default:
+                    a.push(BS_SUBT | BS_NULL);
+                    break;
+            }
         }
 
-        case BS_BINARY: {
-            let len = BS_D16_MERGE(data, r.readB());
-            return r.read(len).slice();
+        return this;
+    }
+
+    _int(v) {
+        let t = [];
+        while (v) {
+            t.push(v & 0xFF);
+            v >>= 8;
+        }
+        return t;
+    }
+
+    _ext(t, v) {
+        let a = this.arr;
+        if (v < BS_EXT_FLAG) {
+            a.push(t | v);
+        } else {
+            a.push(t | BS_EXT_FLAG | BS_GET_LSB(v));
+            a.push(BS_GET_MSB(v));
         }
     }
 }
 
+//#region helper
+
+/**
+ * @param {Uint8Array} buf
+ * @param {Array} codes
+ * @returns {Object|Array|*}
+ */
+export function decodeBson(buf, codes = []) {
+    return new BSDecoder(buf, codes).decode();
+}
+
 /**
  * @param {*} val
+ * @param {Array} codes
  * @returns {Uint8Array}
  */
 export function encodeBson(val, codes = []) {
-    let arr = [];
-    _encode(val, arr, codes);
-    return Uint8Array.from(arr);
-}
-
-function _encode(val, arr, codes) {
-    if (Array.isArray(val)) {
-        arr.push(BS_CONTAINER | BS_CONT_ARR | BS_CONT_OPEN);
-        val.forEach(v => _encode(v, arr, codes));
-        arr.push(BS_CONTAINER | BS_CONT_ARR | BS_CONT_CLOSE);
-        return;
-    }
-
-    switch (typeof val) {
-        case 'object':
-            if (val === null) {
-                arr.push(BS_NULL);
-            } else if (val instanceof Uint8Array) {
-                const len = Math.min(val.length, BS_MAX_LEN);
-                arr.push(BS_BINARY | BS_D16_MSB(len));
-                arr.push(BS_D16_LSB(len));
-                arr.push(...val.slice(0, len));
-            } else {
-                arr.push(BS_CONTAINER | BS_CONT_OBJ | BS_CONT_OPEN);
-                for (const [key, value] of Object.entries(val)) {
-                    _encode(key, arr, codes);
-                    _encode(value, arr, codes);
-                }
-                arr.push(BS_CONTAINER | BS_CONT_OBJ | BS_CONT_CLOSE);
-            }
-            break;
-
-        case 'bigint':
-        case 'number':
-            if (Number.isInteger(val)) {
-                val = BigInt(val);
-                const neg = val < 0;
-                if (neg) val = -val;
-                let bytes = [];
-                while (val) {
-                    bytes.push(Number(val & 0xFFn));
-                    val >>= 8n;
-                }
-                arr.push(BS_INTEGER | (neg ? BS_NEG_MASK : 0) | bytes.length);
-                arr.push(...bytes);
-            } else {
-                const buffer = new ArrayBuffer(BS_FLOAT_SIZE);
-                new DataView(buffer).setFloat32(0, val, true);
-                arr.push(BS_FLOAT);
-                arr.push(...new Uint8Array(buffer));
-            }
-            break;
-
-        case 'string':
-            if (val.startsWith(BS_CODE_PREFIX)) {
-                val = val.slice(BS_CODE_PREFIX.length);
-                let code = codes.indexOf(val);
-                if (code >= 0) {
-                    arr.push(BS_CODE | BS_D16_MSB(code));
-                    arr.push(BS_D16_LSB(code));
-                } else {
-                    _encode(val, arr, codes);
-                }
-            } else {
-                const bytes = new TextEncoder().encode(val);
-                const len = Math.min(bytes.length, BS_MAX_LEN);
-                arr.push(BS_STRING | BS_D16_MSB(len));
-                arr.push(BS_D16_LSB(len));
-                arr.push(...bytes.slice(0, len));
-            }
-            break;
-
-        case 'boolean':
-            arr.push(BS_BOOLEAN | !!val);
-            break;
-
-        default:
-            arr.push(BS_NULL);
-            break;
-    }
+    return new BSEncoder(codes).encode(val).getArray();
 }
 
 export function getCode(name) {

package/bson.min.js

@@ -1 +1 @@
-var e={d:(r,t)=>{for(var n in t)e.o(t,n)&&!e.o(r,n)&&Object.defineProperty(r,n,{enumerable:!0,get:t[n]})},o:(e,r)=>Object.prototype.hasOwnProperty.call(e,r)},r={};e.d(r,{$R:()=>I,QC:()=>k,lo:()=>v});const t=0,n=32,s=64,o=96,i=128,a=160,u=192,c=224,f=16,h=8,l=4,d=2,p=8191,b=e=>224&e,w=e=>31&e,g=e=>1&e,y=16,E=e=>e&y,_=e=>15&e,B=4,N=e=>e>>8&31,m=e=>255&e,A=(e,r)=>(e<<8|r)>>>0,O="__BS#";function v(e,r=[]){if(e instanceof Uint8Array)return F({buf:e,offset:0,decoder:new TextDecoder,read(r){if(this.offset+r>e.length)throw new Error("Overflow");const t=this.buf.subarray(this.offset,this.offset+r);return this.offset+=r,t},readB(){return this.read(1)[0]}},r)}function F(e,r){const f=e.readB(),p=w(f);switch(b(f)){case u:if(!(p&h)){if(p&d)return{__close:!!(p&l)};throw new Error("Unknown cont: "+JSON.stringify(cont))}{let t,n=!!(p&l),s=n?[]:{},o=!1;for(;;){let i=F(e,r);if(i&&void 0!==i.__close){if(n===i.__close){if(!n&&o)throw new Error("Missed value: "+JSON.stringify(s));return s}throw new Error("Wrong close: "+JSON.stringify(s))}n?s.push(i):(o?s[t]=i:t=i,o=!o)}}case i:return r[A(p,e.readB())];case t:{let r=A(p,e.readB());return e.decoder.decode(e.read(r))}case s:{let r=_(p);if(!r)return 0;let t=0n;const n=e.read(r);for(;r--;)t=t<<8n|BigInt(n[r]);return E(p)&&(t=-t),t>=Number.MIN_SAFE_INTEGER&&t<=Number.MAX_SAFE_INTEGER?Number(t):t}case n:return!!g(p);case c:return null;case o:{const r=e.read(4);return new DataView(r.buffer,r.byteOffset,4).getFloat32(0,!0)}case a:{let r=A(p,e.readB());return e.read(r).slice()}}}function I(e,r=[]){let t=[];return S(e,t,r),Uint8Array.from(t)}function S(e,r,b){if(Array.isArray(e))return r.push(u|l|h),e.forEach(e=>S(e,r,b)),void r.push(u|l|d);switch(typeof e){case"object":if(null===e)r.push(c);else if(e instanceof Uint8Array){const t=Math.min(e.length,p);r.push(a|N(t)),r.push(m(t)),r.push(...e.slice(0,t))}else{r.push(u|f|h);for(const[t,n]of Object.entries(e))S(t,r,b),S(n,r,b);r.push(u|f|d)}break;case"bigint":case"number":if(Number.isInteger(e)){const t=(e=BigInt(e))<0;t&&(e=-e);let n=[];for(;e;)n.push(Number(0xFFn&e)),e>>=8n;r.push(s|(t?y:0)|n.length),r.push(...n)}else{const t=new ArrayBuffer(B);new DataView(t).setFloat32(0,e,!0),r.push(o),r.push(...new Uint8Array(t))}break;case"string":if(e.startsWith(O)){e=e.slice(O.length);let t=b.indexOf(e);t>=0?(r.push(i|N(t)),r.push(m(t))):S(e,r,b)}else{const n=(new TextEncoder).encode(e),s=Math.min(n.length,p);r.push(t|N(s)),r.push(m(s)),r.push(...n.slice(0,s))}break;case"boolean":r.push(n|!!e);break;default:r.push(c)}}function k(e){return O+e}const x=r.lo,M=r.$R,U=r.QC;export{x as decodeBson,M as encodeBson,U as getCode};
+var e={d:(t,r)=>{for(var s in r)e.o(r,s)&&!e.o(t,s)&&Object.defineProperty(t,s,{enumerable:!0,get:r[s]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t)},t={};e.d(t,{$R:()=>h,GF:()=>i,QC:()=>c,lo:()=>o,mp:()=>n});const r=e=>31&e,s="__BS#";class n{offset=0;cont="root";tdec=new TextDecoder;constructor(e,t){this.buf=e,this.codes=t}decode(){if(!(this.buf instanceof Uint8Array&&this.buf.length))return;let e=this._decode();if(this.offset!=this.buf.length)throw this._err("Broken packet");return e}read(e){if(this.offset+e>this.buf.length)throw this._err("Overflow");let t=this.buf.subarray(this.offset,this.offset+e);return this.offset+=e,t}readB(){return this.read(1)[0]}readInt(e){let t=0,r=this.read(e);for(;e--;)t=t<<8|r[e];return t}_ext(e){return r(e)|(32&e?this.readB()<<5:0)}_close(e,t){if(e&&void 0!==e.__close){if(t===e.__close)return!0;throw this._err("Wrong close")}return!1}_err(e){return new Error(e+" in "+JSON.stringify(this.cont))}_decode(){const e=this.readB();let t=192&e;switch(0==t&&(t=56&e),t){case 16:if(2&e){let t=!!(1&e),r=t?{}:[];for(;;){this.cont=r;let e=this._decode();if(this._close(e,t))return r;if(t){let s=this._decode();if(this._close(s,t))throw this._err("Missed value");r[String(e)]=s}else r.push(e)}}return{__close:!!(1&e)};case 64:if(32&e)return 31&e;{let t=this.readInt(15&e);return 16&e?-t:t}case 128:return this.tdec.decode(this.read(this._ext(e)));case 192:return this.codes[this._ext(e)];case 0:return null;case 8:return!!(1&e);case 24:{let t=(e=>1<<(7&e))(e);const r=this.read(t);let s=new DataView(r.buffer,r.byteOffset,t);return 4==t?s.getFloat32(0,!0):8==t?s.getFloat64(0,!0):0}case 32:return this.read(this.readInt((e=>7&e)(e))).slice()}}}class i{arr=[];tenc=new TextEncoder;constructor(e=[]){this.codes=e}getArray(){return Uint8Array.from(this.arr)}encode(e){let t=this.arr;if(Array.isArray(e))t.push(18),e.forEach(e=>this.encode(e)),t.push(16);else switch(typeof e){case"object":if(null===e)t.push(0);else if(e instanceof Uint8Array){let r=this._int(e.length);t.push(32|r.length),t.push(...r),t.push(...e)}else{t.push(19);for(const[t,r]of Object.entries(e))this.encode(t),this.encode(r);t.push(17)}break;case"number":if(Number.isInteger(e))if(e>=0&&e<32)t.push(96|e);else{let r=e<0;r&&(e=-e);let s=this._int(e);t.push(64|(r?16:0)|s.length),t.push(...s)}else{const r=new ArrayBuffer(4);new DataView(r).setFloat32(0,e,!0),t.push(26),t.push(...new Uint8Array(r))}break;case"string":if(e.startsWith(s)){e=e.slice(s.length);let t=this.codes.indexOf(e);t>=0?this._ext(192,t):this.encode(e)}else{const r=this.tenc.encode(e),s=Math.min(r.length,8191);this._ext(128,s),t.push(...r.slice(0,s))}break;case"boolean":t.push(8|!!e);break;default:t.push(0)}return this}_int(e){let t=[];for(;e;)t.push(255&e),e>>=8;return t}_ext(e,t){let s=this.arr;t<32?s.push(e|t):(s.push(32|e|r(t)),s.push(t>>5))}}function o(e,t=[]){return new n(e,t).decode()}function h(e,t=[]){return new i(t).encode(e).getArray()}function c(e){return s+e}const a=t.mp,u=t.GF,l=t.lo,f=t.$R,d=t.QC;export{a as BSDecoder,u as BSEncoder,l as decodeBson,f as encodeBson,d as getCode};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexgyver/bson",
-  "version": "2.2.1",
+  "version": "3.0.0",
   "description": "Decode BSON from BSON Arduino library",
   "main": "./bson.js",
   "module": "./bson.js",
@@ -15,7 +15,7 @@
   },
   "devDependencies": {
     "webpack": "^5.105.4",
-    "webpack-cli": "^6.0.1",
+    "webpack-cli": "^7.0.0",
     "webpack-dev-server": "^5.2.3",
     "style-loader": "^4.0.0",
     "css-loader": "^7.1.4"

package/test/index.html

@@ -5,8 +5,8 @@
     <p id="out" style="white-space: break-spaces;"></p>
 
     <script type="module">
-        import { decodeBson, encodeBson, getCode } from 'https://gyverlibs.github.io/bson.js/dist/bson.js';
-        // import { decodeBson, encodeBson, getCode } from '/bson.js';
+        // import { decodeBson, encodeBson, getCode } from 'https://gyverlibs.github.io/bson.js/dist/bson.js';
+        import { decodeBson, encodeBson, getCode } from '/bson.js';
 
         const url = 'http://192.168.1.54';
 
@@ -18,13 +18,17 @@
 
         // =========== encode ===========
         let test = {
+            sint: 20,
             int: 123,
+            nint: -123,
             float: 3.14,
             arr: [
                 "str",
+                "0123456789012345678901234567890123456789",
                 true,
                 1234,
                 new Uint8Array([1, 2, 3]),
+                new Uint8Array([]),
             ],
             obj: {
                 str2: "str2",