@wener/utils 1.1.50 → 1.1.53

package/lib/io/ByteBuffer.js

@@ -1,6 +1,95 @@
-import { ArrayBuffers } from './ArrayBuffers.js';
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    }
+    else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor)
+            descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps)
+        _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps)
+        _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    }
+    else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    }
+    else {
+        return left instanceof right;
+    }
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { ArrayBuffers } from "./ArrayBuffers.js";
 function asBuffer(o) {
-    if (o instanceof ArrayBuffer) {
+    if (_instanceof(o, ArrayBuffer)) {
         return o;
     }
     if (ArrayBuffer.isView(o)) {
@@ -16,6 +105,8 @@ function asBuffer(o) {
     }
     return o;
 }
+var _buffer = /*#__PURE__*/ new WeakMap(), _view = /*#__PURE__*/ new WeakMap(), _bytes = /*#__PURE__*/ new WeakMap(), // #endian: 'big' | 'little' = 'big';
+_bigEndian = /*#__PURE__*/ new WeakMap();
 // function asView(o: AnyBuffer) {
 //   if (o instanceof DataView) {
 //     return o;
@@ -32,446 +123,665 @@ function asBuffer(o) {
  * @see {@link https://netty.io/4.1/api/io/netty/buffer/ByteBuf.html io.netty.buffer.ByteBuf}
  * @see {@link https://nodejs.org/api/buffer.html node:buffer}
  * @see {@link https://www.postgresql.org/docs/current/datatype.html PostgreSQL Data Types}
- */ export class ByteBuffer {
-    position = 0;
-    #buffer;
-    #view;
-    #bytes;
-    // #endian: 'big' | 'little' = 'big';
-    #bigEndian = true;
-    constructor(buffer = new ArrayBuffer(0, {
-        maxByteLength: 1024
-    })){
-        this.#buffer = asBuffer(buffer);
+ */ export var ByteBuffer = /*#__PURE__*/ function () {
+    "use strict";
+    function ByteBuffer() {
+        var buffer = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : new ArrayBuffer(0, {
+            maxByteLength: 1024
+        });
+        _class_call_check(this, ByteBuffer);
+        _define_property(this, "position", 0);
+        _class_private_field_init(this, _buffer, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _view, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _bytes, {
+            writable: true,
+            value: void 0
+        });
+        _class_private_field_init(this, _bigEndian, {
+            writable: true,
+            value: true
+        });
+        _class_private_field_set(this, _buffer, asBuffer(buffer));
         // NOTE prefer view over buffer, avoid the slice overhead ?
-        this.#view = new DataView(this.#buffer);
-        this.#bytes = new Uint8Array(this.#buffer);
-    }
-    get littleEndian() {
-        return !this.#bigEndian;
-    }
-    set littleEndian(v) {
-        this.#bigEndian = !v;
-    }
-    get bigEndian() {
-        return this.#bigEndian;
-    }
-    set bigEndian(v) {
-        this.#bigEndian = v;
-    }
-    get view() {
-        return this.#view;
-    }
-    get buffer() {
-        return this.#buffer;
-    }
-    set buffer(buffer) {
-        this.#buffer = asBuffer(buffer);
-        this.#view = new DataView(this.#buffer);
-        this.#bytes = new Uint8Array(this.#buffer);
-    }
-    get bytes() {
-        return this.#bytes;
-    }
-    get length() {
-        return this.view.byteLength;
-    }
-    set length(length) {
-        this.resize(length);
-    }
-    resize(newLength) {
-        // 1.2 for buffer growth
-        this.buffer = ArrayBuffers.resize(this.buffer, newLength, Math.ceil(newLength * 1.2));
-    }
-    writeByte(value) {
-        this.willWrite(1);
-        this.view.setUint8(this.position++, value);
-    }
-    writeBytes(bytes, len = bytes.byteLength) {
-        this.willWrite(len);
-        // ensure len first
-        this.bytes.set(new Uint8Array(bytes).subarray(0, len), this.position);
-        if (len > bytes.byteLength) {
-            // fill zero
-            this.bytes.fill(0, this.position + bytes.byteLength, this.position + len);
-        }
-        this.position += len;
-    }
-    writeInt8(value) {
-        this.willWrite(1);
-        this.view.setInt8(this.position, value);
-        this.position += 1;
-    }
-    writeUint8(value) {
-        this.willWrite(1);
-        this.view.setUint8(this.position, value);
-        this.position += 1;
-    }
-    writeInt16(value) {
-        this.willWrite(2);
-        this.view.setInt16(this.position, value, this.littleEndian);
-        this.position += 2;
-    }
-    writeUint16(value) {
-        this.willWrite(2);
-        this.view.setUint16(this.position, value, this.littleEndian);
-        this.position += 2;
-    }
-    writeUint24(value) {
-        this.willWrite(3);
-        this.view.setUint8(this.position, value & 0xff);
-        this.view.setUint16(this.position + 1, value >> 8, this.littleEndian);
-        this.position += 3;
-    }
-    writeInt32(value) {
-        this.willWrite(4);
-        this.view.setInt32(this.position, value, this.littleEndian);
-        this.position += 4;
-    }
-    writeUint32(value) {
-        this.willWrite(4);
-        this.view.setUint32(this.position, value, this.littleEndian);
-        this.position += 4;
-    }
-    writeInt64(value) {
-        this.willWrite(8);
-        this.view.setBigInt64(this.position, bigintOf(value), this.littleEndian);
-        this.position += 8;
-    }
-    writeUint64(value) {
-        this.willWrite(8);
-        this.view.setBigUint64(this.position, bigintOf(value), this.littleEndian);
-        this.position += 8;
-    }
-    writeFloat32(value) {
-        this.willWrite(4);
-        this.view.setFloat32(this.position, value, this.littleEndian);
-        this.position += 4;
-    }
-    writeFloat64(value) {
-        this.willWrite(8);
-        this.view.setFloat64(this.position, value, this.littleEndian);
-        this.position += 8;
-    }
-    writeBoolean(value) {
-        this.writeByte(value ? 1 : 0);
-    }
-    writeString(value, len) {
-        let bytes = this.encodeText(value);
-        this.writeBytes(bytes, len);
-    }
-    readSizeString(n) {
-        return this.readString(requireNumber(this.readUint(n)));
-    }
-    writeSizeString(value, n) {
-        let out = this.encodeText(value);
-        this.writeUint(out.length, n);
-        this.writeBytes(out);
-    }
-    encodeText(value) {
-        return new TextEncoder().encode(value);
-    }
-    decodeText(bytes) {
-        return new TextDecoder().decode(bytes);
-    }
-    readByte() {
-        return this.view.getUint8(this.position++);
-    }
-    readBytes(length) {
-        let bytes = this.buffer.slice(this.position, this.position + length);
-        this.position += length;
-        return bytes;
-    }
-    readInt8() {
-        let value = this.view.getInt8(this.position);
-        this.position += 1;
-        return value;
-    }
-    readUint8() {
-        let value = this.view.getUint8(this.position);
-        this.position += 1;
-        return value;
-    }
-    readUnsignedByte() {
-        return this.readUint8();
-    }
-    readThrough(end) {
-        // readUntil 不包含 end
-        let idx = this.bytes.indexOf(end, this.position);
-        if (idx === -1) {
-            throw new Error(`Byte ${end} not found starting from position ${this.position}`);
-        }
-        let bytes = this.buffer.slice(this.position, idx + 1);
-        this.position = idx + 1;
-        return bytes;
-    }
-    readInt16() {
-        let value = this.view.getInt16(this.position, this.littleEndian);
-        this.position += 2;
-        return value;
-    }
-    readUint16() {
-        let value = this.view.getUint16(this.position, this.littleEndian);
-        this.position += 2;
-        return value;
-    }
-    readInt32() {
-        let value = this.view.getInt32(this.position, this.littleEndian);
-        this.position += 4;
-        return value;
-    }
-    readUint32() {
-        let value = this.view.getUint32(this.position, this.littleEndian);
-        this.position += 4;
-        return value;
-    }
-    readInt64() {
-        let value = this.view.getBigInt64(this.position, this.littleEndian);
-        this.position += 8;
-        return safeNumber(value);
-    }
-    readUint64() {
-        let value = this.view.getBigUint64(this.position, this.littleEndian);
-        this.position += 8;
-        return safeNumber(value);
-    }
-    readFloat32() {
-        let value = this.view.getFloat32(this.position, this.littleEndian);
-        this.position += 4;
-        return value;
-    }
-    readFloat64() {
-        let value = this.view.getFloat64(this.position, this.littleEndian);
-        this.position += 8;
-        return value;
-    }
-    readBoolean() {
-        // or !== 0?
-        return this.readByte() === 1;
-    }
-    readString(length) {
-        let bytes = this.readBytes(length);
-        let a = new Uint8Array(bytes);
-        let idx = a.indexOf(0);
-        if (idx !== -1) {
-            bytes = bytes.slice(0, idx);
-        }
-        return this.decodeText(bytes);
-    }
-    readHexString(length) {
-        let bytes = this.readBytes(length);
-        return ArrayBuffers.toHex(bytes);
-    }
-    writeHexString(value, len) {
-        this.writeBytes(ArrayBuffers.fromHex(value), len);
-    }
-    writeInt24(value) {
-        // fixme byte order
-        this.writeUint8(value & 0xff);
-        this.writeUint16(value >> 8);
-    }
-    readInt24() {
-        // fixme recheck
-        let value = this.readUint24();
-        if (value & 0x800000) {
-            // If the sign bit is set, extend the sign
-            value |= 0xff000000;
-        }
-        return value;
-    }
-    readUint24() {
-        // fixme recheck
-        return this.readUint8() | this.readUint8() << 8 | this.readUint8() << 16;
-    }
-    writeZero(length) {
-        this.willWrite(length);
-        this.bytes.fill(0, this.position, this.position + length);
-        this.position += length;
-    }
-    writeValue(a, b) {
-        const tv = typeof a === 'string' ? {
-            type: a,
-            value: b
-        } : a;
-        const { type, value, length } = tv;
-        switch(type){
-            case 'uint8':
-                this.writeUint8(value);
-                break;
-            case 'byte':
-            case 'int8':
-                this.writeInt8(value);
-                break;
-            case 'uint16':
-                this.writeUint16(value);
-                break;
-            case 'int16':
-                this.writeInt16(value);
-                break;
-            case 'uint24':
-                this.writeUint24(value);
-                break;
-            case 'int24':
-                this.writeInt24(value);
-                break;
-            case 'uint32':
-            case 'uint':
-                this.writeUint32(value);
-                break;
-            case 'int32':
-            case 'int':
-                this.writeInt32(value);
-                break;
-            case 'float32':
-            case 'float':
-                this.writeFloat32(value);
-                break;
-            case 'float64':
-            case 'double':
-                this.writeFloat64(value);
-                break;
-            case 'string':
-                this.writeString(value, length);
-                break;
-            case 'boolean':
-                this.writeBoolean(value);
-                break;
-            case 'bytes':
-                this.writeBytes(value);
-                break;
-            default:
-                throw new Error(`Unknown type ${type}`);
-        }
-    }
-    readUnsignedShort() {
-        return this.readUint16();
-    }
-    readShort() {
-        return this.readInt16();
-    }
-    readInt(bytesOrBits = 32) {
-        switch(bytesOrBits){
-            case 1:
-            case 8:
-                return this.readInt8();
-            case 2:
-            case 16:
-                return this.readInt16();
-            case 3:
-            case 24:
-                return this.readInt24();
-            case 4:
-            case 32:
-                return this.readInt32();
-            // skip 8 byte for bits
-            case 64:
-                return this.readInt64();
-            default:
-                throw new Error(`Unknown int${bytesOrBits}`);
-        }
-    }
-    readUint(bytesOrBits = 32) {
-        switch(bytesOrBits){
-            case 1:
-            case 8:
+        _class_private_field_set(this, _view, new DataView(_class_private_field_get(this, _buffer)));
+        _class_private_field_set(this, _bytes, new Uint8Array(_class_private_field_get(this, _buffer)));
+    }
+    _create_class(ByteBuffer, [
+        {
+            key: "littleEndian",
+            get: function get() {
+                return !_class_private_field_get(this, _bigEndian);
+            },
+            set: function set(v) {
+                _class_private_field_set(this, _bigEndian, !v);
+            }
+        },
+        {
+            key: "bigEndian",
+            get: function get() {
+                return _class_private_field_get(this, _bigEndian);
+            },
+            set: function set(v) {
+                _class_private_field_set(this, _bigEndian, v);
+            }
+        },
+        {
+            key: "view",
+            get: function get() {
+                return _class_private_field_get(this, _view);
+            }
+        },
+        {
+            key: "buffer",
+            get: function get() {
+                return _class_private_field_get(this, _buffer);
+            },
+            set: function set(buffer) {
+                _class_private_field_set(this, _buffer, asBuffer(buffer));
+                _class_private_field_set(this, _view, new DataView(_class_private_field_get(this, _buffer)));
+                _class_private_field_set(this, _bytes, new Uint8Array(_class_private_field_get(this, _buffer)));
+            }
+        },
+        {
+            key: "bytes",
+            get: function get() {
+                return _class_private_field_get(this, _bytes);
+            }
+        },
+        {
+            key: "length",
+            get: function get() {
+                return this.view.byteLength;
+            },
+            set: function set(length) {
+                this.resize(length);
+            }
+        },
+        {
+            key: "resize",
+            value: function resize(newLength) {
+                // 1.2 for buffer growth
+                this.buffer = ArrayBuffers.resize(this.buffer, newLength, Math.ceil(newLength * 1.2));
+            }
+        },
+        {
+            key: "writeByte",
+            value: function writeByte(value) {
+                this.willWrite(1);
+                this.view.setUint8(this.position++, value);
+            }
+        },
+        {
+            key: "writeBytes",
+            value: function writeBytes(bytes, len) {
+                var byteLength = getByteLength(bytes);
+                len !== null && len !== void 0 ? len : len = byteLength;
+                this.willWrite(len);
+                // ensure len first
+                this.bytes.set(ArrayBuffers.toUint8Array(bytes).subarray(0, len), this.position);
+                if (len > byteLength) {
+                    // fill zero
+                    this.bytes.fill(0, this.position + byteLength, this.position + len);
+                }
+                this.position += len;
+            }
+        },
+        {
+            key: "writeInt8",
+            value: function writeInt8(value) {
+                this.willWrite(1);
+                this.view.setInt8(this.position, value);
+                this.position += 1;
+            }
+        },
+        {
+            key: "writeUint8",
+            value: function writeUint8(value) {
+                this.willWrite(1);
+                this.view.setUint8(this.position, value);
+                this.position += 1;
+            }
+        },
+        {
+            key: "writeInt16",
+            value: function writeInt16(value) {
+                this.willWrite(2);
+                this.view.setInt16(this.position, value, this.littleEndian);
+                this.position += 2;
+            }
+        },
+        {
+            key: "writeUint16",
+            value: function writeUint16(value) {
+                this.willWrite(2);
+                this.view.setUint16(this.position, value, this.littleEndian);
+                this.position += 2;
+            }
+        },
+        {
+            key: "writeUint24",
+            value: function writeUint24(value) {
+                this.willWrite(3);
+                this.view.setUint8(this.position, value & 255);
+                this.view.setUint16(this.position + 1, value >> 8, this.littleEndian);
+                this.position += 3;
+            }
+        },
+        {
+            key: "writeInt32",
+            value: function writeInt32(value) {
+                this.willWrite(4);
+                this.view.setInt32(this.position, value, this.littleEndian);
+                this.position += 4;
+            }
+        },
+        {
+            key: "writeUint32",
+            value: function writeUint32(value) {
+                this.willWrite(4);
+                this.view.setUint32(this.position, value, this.littleEndian);
+                this.position += 4;
+            }
+        },
+        {
+            key: "writeInt64",
+            value: function writeInt64(value) {
+                this.willWrite(8);
+                this.view.setBigInt64(this.position, bigintOf(value), this.littleEndian);
+                this.position += 8;
+            }
+        },
+        {
+            key: "writeUint64",
+            value: function writeUint64(value) {
+                this.willWrite(8);
+                this.view.setBigUint64(this.position, bigintOf(value), this.littleEndian);
+                this.position += 8;
+            }
+        },
+        {
+            key: "writeFloat32",
+            value: function writeFloat32(value) {
+                this.willWrite(4);
+                this.view.setFloat32(this.position, value, this.littleEndian);
+                this.position += 4;
+            }
+        },
+        {
+            key: "writeFloat64",
+            value: function writeFloat64(value) {
+                this.willWrite(8);
+                this.view.setFloat64(this.position, value, this.littleEndian);
+                this.position += 8;
+            }
+        },
+        {
+            key: "writeBoolean",
+            value: function writeBoolean(value) {
+                this.writeByte(value ? 1 : 0);
+            }
+        },
+        {
+            key: "writeString",
+            value: function writeString(value, len) {
+                var bytes = this.encodeText(value);
+                this.writeBytes(bytes, len);
+            }
+        },
+        {
+            key: "readSizeString",
+            value: function readSizeString(n) {
+                return this.readString(requireNumber(this.readUint(n)));
+            }
+        },
+        {
+            key: "writeSizeString",
+            value: function writeSizeString(value, n) {
+                var out = this.encodeText(value);
+                this.writeUint(out.length, n);
+                this.writeBytes(out);
+            }
+        },
+        {
+            key: "encodeText",
+            value: function encodeText(value) {
+                return new TextEncoder().encode(value);
+            }
+        },
+        {
+            key: "decodeText",
+            value: function decodeText(bytes) {
+                return new TextDecoder().decode(bytes);
+            }
+        },
+        {
+            key: "readByte",
+            value: function readByte() {
+                return this.view.getUint8(this.position++);
+            }
+        },
+        {
+            key: "readBytes",
+            value: function readBytes(length) {
+                var bytes = this.buffer.slice(this.position, this.position + length);
+                this.position += length;
+                return bytes;
+            }
+        },
+        {
+            key: "readInt8",
+            value: function readInt8() {
+                var value = this.view.getInt8(this.position);
+                this.position += 1;
+                return value;
+            }
+        },
+        {
+            key: "readUint8",
+            value: function readUint8() {
+                var value = this.view.getUint8(this.position);
+                this.position += 1;
+                return value;
+            }
+        },
+        {
+            key: "readUnsignedByte",
+            value: function readUnsignedByte() {
                 return this.readUint8();
-            case 2:
-            case 16:
+            }
+        },
+        {
+            key: "readThrough",
+            value: function readThrough(end) {
+                // readUntil 不包含 end
+                var idx = this.bytes.indexOf(end, this.position);
+                if (idx === -1) {
+                    throw new Error("Byte ".concat(end, " not found starting from position ").concat(this.position));
+                }
+                var bytes = this.buffer.slice(this.position, idx + 1);
+                this.position = idx + 1;
+                return bytes;
+            }
+        },
+        {
+            key: "readInt16",
+            value: function readInt16() {
+                var value = this.view.getInt16(this.position, this.littleEndian);
+                this.position += 2;
+                return value;
+            }
+        },
+        {
+            key: "readUint16",
+            value: function readUint16() {
+                var value = this.view.getUint16(this.position, this.littleEndian);
+                this.position += 2;
+                return value;
+            }
+        },
+        {
+            key: "readInt32",
+            value: function readInt32() {
+                var value = this.view.getInt32(this.position, this.littleEndian);
+                this.position += 4;
+                return value;
+            }
+        },
+        {
+            key: "readUint32",
+            value: function readUint32() {
+                var value = this.view.getUint32(this.position, this.littleEndian);
+                this.position += 4;
+                return value;
+            }
+        },
+        {
+            key: "readInt64",
+            value: function readInt64() {
+                var value = this.view.getBigInt64(this.position, this.littleEndian);
+                this.position += 8;
+                return safeNumber(value);
+            }
+        },
+        {
+            key: "readUint64",
+            value: function readUint64() {
+                var value = this.view.getBigUint64(this.position, this.littleEndian);
+                this.position += 8;
+                return safeNumber(value);
+            }
+        },
+        {
+            key: "readFloat32",
+            value: function readFloat32() {
+                var value = this.view.getFloat32(this.position, this.littleEndian);
+                this.position += 4;
+                return value;
+            }
+        },
+        {
+            key: "readFloat64",
+            value: function readFloat64() {
+                var value = this.view.getFloat64(this.position, this.littleEndian);
+                this.position += 8;
+                return value;
+            }
+        },
+        {
+            key: "readBoolean",
+            value: function readBoolean() {
+                // or !== 0?
+                return this.readByte() === 1;
+            }
+        },
+        {
+            key: "readString",
+            value: function readString(length) {
+                var bytes = this.readBytes(length);
+                var a = new Uint8Array(bytes);
+                var idx = a.indexOf(0);
+                if (idx !== -1) {
+                    bytes = bytes.slice(0, idx);
+                }
+                return this.decodeText(bytes);
+            }
+        },
+        {
+            key: "readHexString",
+            value: function readHexString(length) {
+                var bytes = this.readBytes(length);
+                return ArrayBuffers.toHex(bytes);
+            }
+        },
+        {
+            key: "writeHexString",
+            value: function writeHexString(value, len) {
+                this.writeBytes(ArrayBuffers.fromHex(value), len);
+            }
+        },
+        {
+            key: "writeInt24",
+            value: function writeInt24(value) {
+                // fixme byte order
+                this.writeUint8(value & 255);
+                this.writeUint16(value >> 8);
+            }
+        },
+        {
+            key: "readInt24",
+            value: function readInt24() {
+                // fixme recheck
+                var value = this.readUint24();
+                if (value & 8388608) {
+                    // If the sign bit is set, extend the sign
+                    value |= 4278190080;
+                }
+                return value;
+            }
+        },
+        {
+            key: "readUint24",
+            value: function readUint24() {
+                // fixme recheck
+                return this.readUint8() | this.readUint8() << 8 | this.readUint8() << 16;
+            }
+        },
+        {
+            key: "writeZero",
+            value: function writeZero(length) {
+                this.willWrite(length);
+                this.bytes.fill(0, this.position, this.position + length);
+                this.position += length;
+            }
+        },
+        {
+            key: "writeValue",
+            value: function writeValue(a, b) {
+                var tv = typeof a === "string" ? {
+                    type: a,
+                    value: b
+                } : a;
+                var type = tv.type, value = tv.value, length = tv.length;
+                switch (type) {
+                    case "uint8":
+                        this.writeUint8(value);
+                        break;
+                    case "byte":
+                    case "int8":
+                        this.writeInt8(value);
+                        break;
+                    case "uint16":
+                        this.writeUint16(value);
+                        break;
+                    case "int16":
+                        this.writeInt16(value);
+                        break;
+                    case "uint24":
+                        this.writeUint24(value);
+                        break;
+                    case "int24":
+                        this.writeInt24(value);
+                        break;
+                    case "uint32":
+                    case "uint":
+                        this.writeUint32(value);
+                        break;
+                    case "int32":
+                    case "int":
+                        this.writeInt32(value);
+                        break;
+                    case "float32":
+                    case "float":
+                        this.writeFloat32(value);
+                        break;
+                    case "float64":
+                    case "double":
+                        this.writeFloat64(value);
+                        break;
+                    case "string":
+                        this.writeString(value, length);
+                        break;
+                    case "boolean":
+                        this.writeBoolean(value);
+                        break;
+                    case "bytes":
+                        this.writeBytes(value);
+                        break;
+                    default:
+                        throw new Error("Unknown type ".concat(type));
+                }
+            }
+        },
+        {
+            key: "readUnsignedShort",
+            value: function readUnsignedShort() {
                 return this.readUint16();
-            case 3:
-            case 24:
-                return this.readUint24();
-            case 4:
-            case 32:
-                return this.readUint32();
-            // skip 8 byte for bits
-            case 64:
-                return this.readUint64();
-            default:
-                throw new Error(`Unexpected int size: ${bytesOrBits}`);
-        }
-    }
-    writeUint(value, bytesOrBits = 32) {
-        switch(bytesOrBits){
-            case 1:
-            case 8:
-                this.writeUint8(value);
-                break;
-            case 2:
-            case 16:
-                this.writeUint16(value);
-                break;
-            case 3:
-            case 24:
-                this.writeUint24(value);
-                break;
-            case 4:
-            case 32:
-                this.writeUint32(value);
-                break;
-            case 64:
-                this.writeUint64(value);
-                break;
-            default:
-                throw new Error(`Unexpected uint size: ${bytesOrBits}`);
-        }
-    }
-    readFloat(n = 32) {
-        switch(n){
-            case 4:
-            case 32:
-                return this.readFloat32();
-            case 8:
-            case 64:
+            }
+        },
+        {
+            key: "readShort",
+            value: function readShort() {
+                return this.readInt16();
+            }
+        },
+        {
+            key: "readInt",
+            value: function readInt() {
+                var bytesOrBits = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 32;
+                switch (bytesOrBits) {
+                    case 1:
+                    case 8:
+                        return this.readInt8();
+                    case 2:
+                    case 16:
+                        return this.readInt16();
+                    case 3:
+                    case 24:
+                        return this.readInt24();
+                    case 4:
+                    case 32:
+                        return this.readInt32();
+                    // skip 8 byte for bits
+                    case 64:
+                        return this.readInt64();
+                    default:
+                        throw new Error("Unknown int".concat(bytesOrBits));
+                }
+            }
+        },
+        {
+            key: "readUint",
+            value: function readUint() {
+                var bytesOrBits = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 32;
+                switch (bytesOrBits) {
+                    case 1:
+                    case 8:
+                        return this.readUint8();
+                    case 2:
+                    case 16:
+                        return this.readUint16();
+                    case 3:
+                    case 24:
+                        return this.readUint24();
+                    case 4:
+                    case 32:
+                        return this.readUint32();
+                    // skip 8 byte for bits
+                    case 64:
+                        return this.readUint64();
+                    default:
+                        throw new Error("Unexpected int size: ".concat(bytesOrBits));
+                }
+            }
+        },
+        {
+            key: "writeUint",
+            value: function writeUint(value) {
+                var bytesOrBits = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 32;
+                switch (bytesOrBits) {
+                    case 1:
+                    case 8:
+                        this.writeUint8(value);
+                        break;
+                    case 2:
+                    case 16:
+                        this.writeUint16(value);
+                        break;
+                    case 3:
+                    case 24:
+                        this.writeUint24(value);
+                        break;
+                    case 4:
+                    case 32:
+                        this.writeUint32(value);
+                        break;
+                    case 64:
+                        this.writeUint64(value);
+                        break;
+                    default:
+                        throw new Error("Unexpected uint size: ".concat(bytesOrBits));
+                }
+            }
+        },
+        {
+            key: "readFloat",
+            value: function readFloat() {
+                var n = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 32;
+                switch (n) {
+                    case 4:
+                    case 32:
+                        return this.readFloat32();
+                    case 8:
+                    case 64:
+                        return this.readFloat64();
+                    default:
+                        throw new Error("Unexpected float size: ".concat(n));
+                }
+            }
+        },
+        {
+            key: "writeFloat",
+            value: function writeFloat(value) {
+                var n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 32;
+                switch (n) {
+                    case 4:
+                    case 32:
+                        this.writeFloat32(value);
+                        break;
+                    case 8:
+                    case 64:
+                        this.writeFloat64(value);
+                        break;
+                    default:
+                        throw new Error("Unexpected float size: ".concat(n));
+                }
+            }
+        },
+        {
+            key: "readDouble",
+            value: function readDouble() {
                 return this.readFloat64();
-            default:
-                throw new Error(`Unexpected float size: ${n}`);
-        }
-    }
-    writeFloat(value, n = 32) {
-        switch(n){
-            case 4:
-            case 32:
-                this.writeFloat32(value);
-                break;
-            case 8:
-            case 64:
+            }
+        },
+        {
+            key: "writeDouble",
+            value: function writeDouble(value) {
                 this.writeFloat64(value);
-                break;
-            default:
-                throw new Error(`Unexpected float size: ${n}`);
+            }
+        },
+        {
+            key: "remaining",
+            value: function remaining() {
+                return this.length - this.position;
+            }
+        },
+        {
+            key: "hasRemaining",
+            value: function hasRemaining() {
+                return this.remaining() > 0;
+            }
+        },
+        {
+            key: "readRemaining",
+            value: function readRemaining() {
+                return this.readBytes(this.remaining());
+            }
+        },
+        {
+            key: "toUint8Array",
+            value: function toUint8Array() {
+                return new Uint8Array(this.buffer);
+            }
+        },
+        {
+            key: "toHex",
+            value: function toHex() {
+                return ArrayBuffers.toHex(this.buffer);
+            }
+        },
+        {
+            key: "toBase64",
+            value: function toBase64() {
+                return ArrayBuffers.toBase64(this.buffer);
+            }
+        },
+        {
+            key: "willWrite",
+            value: function willWrite(length) {
+                if (this.remaining() < length) {
+                    this.resize(this.position + length);
+                }
+            }
         }
-    }
-    readDouble() {
-        return this.readFloat64();
-    }
-    writeDouble(value) {
-        this.writeFloat64(value);
-    }
-    remaining() {
-        return this.length - this.position;
-    }
-    hasRemaining() {
-        return this.remaining() > 0;
-    }
-    readRemaining() {
-        return this.readBytes(this.remaining());
-    }
-    toUint8Array() {
-        return new Uint8Array(this.buffer);
-    }
-    toHex() {
-        return ArrayBuffers.toHex(this.buffer);
-    }
-    toBase64() {
-        return ArrayBuffers.toBase64(this.buffer);
-    }
-    willWrite(length) {
-        if (this.remaining() < length) {
-            this.resize(this.position + length);
-        }
-    }
-}
+    ]);
+    return ByteBuffer;
+}();
 function safeNumber(n) {
     if (n > Number.MAX_SAFE_INTEGER) {
         return n;
@@ -479,16 +789,17 @@ function safeNumber(n) {
     return Number(n);
 }
 function bigintOf(n) {
-    if (typeof n === 'bigint') {
+    if ((typeof n === "undefined" ? "undefined" : _type_of(n)) === "bigint") {
         return n;
     }
     return BigInt(n);
 }
 function requireNumber(n) {
-    if (typeof n !== 'number') {
-        throw new Error(`Expected number, got ${n}`);
+    if (typeof n !== "number") {
+        throw new Error("Expected number, got ".concat(n));
     }
     return n;
 }
-
-//# sourceMappingURL=ByteBuffer.js.map
+function getByteLength(i) {
+    return "byteLength" in i ? i.byteLength : i.length;
+}