@nuintun/buffer 0.1.0

package/cjs/index.cjs

@@ -0,0 +1,559 @@
+/**
+ * @package @nuintun/buffer
+ * @license MIT
+ * @version 0.1.0
+ * @author nuintun <nuintun@qq.com>
+ * @description A buffer tool for javascript.
+ * @see https://github.com/nuintun/Buffer#readme
+ */
+
+'use strict';
+
+const tslib = require('tslib');
+const utils = require('./utils.cjs');
+const Binary = require('./Binary.cjs');
+const errors = require('./errors.cjs');
+const index = require('./Encoding/index.cjs');
+
+/**
+ * @module Buffer
+ */
+var _Buffer_instances,
+  _Buffer_pageSize,
+  _Buffer_bytes,
+  _Buffer_dataView,
+  _Buffer_offset,
+  _Buffer_length,
+  _Buffer_grow,
+  _Buffer_seek,
+  _Buffer_assertRead,
+  _Buffer_alloc;
+// 字节序类型
+exports.Endian = void 0;
+(function (Endian) {
+  Endian[(Endian['Big'] = 0)] = 'Big';
+  Endian[(Endian['Little'] = 1)] = 'Little';
+})(exports.Endian || (exports.Endian = {}));
+/**
+ * @function endianness
+ * @description 获取系统默认字节序
+ * @returns {Endian}
+ */
+function endianness() {
+  switch (new Uint8Array(new Uint32Array([0x12345678]))[0]) {
+    case 0x12:
+      return exports.Endian.Big;
+    case 0x78:
+      return exports.Endian.Little;
+    default:
+      throw new TypeError(errors.unknownEndianness);
+  }
+}
+/**
+ * @class Buffer
+ * @classdesc Buffer 类提供用于优化读取，写入以及处理二进制数据的方法和属性
+ */
+class Buffer {
+  constructor(input = 0, pageSize = 4096) {
+    _Buffer_instances.add(this);
+    // 缓冲区页大小
+    // 容量不足时按页大小增长
+    _Buffer_pageSize.set(this, void 0);
+    // 缓冲区数据
+    _Buffer_bytes.set(this, void 0);
+    // 缓冲区视图
+    _Buffer_dataView.set(this, void 0);
+    // 读写指针位置
+    _Buffer_offset.set(this, 0);
+    // 已使用字节长度
+    _Buffer_length.set(this, 0);
+    tslib.__classPrivateFieldSet(this, _Buffer_pageSize, pageSize, 'f');
+    if (input instanceof Uint8Array) {
+      tslib.__classPrivateFieldSet(this, _Buffer_bytes, input, 'f');
+      tslib.__classPrivateFieldSet(this, _Buffer_length, input.length, 'f');
+      tslib.__classPrivateFieldSet(this, _Buffer_dataView, new DataView(input.buffer), 'f');
+    } else {
+      const bytes = new Uint8Array(utils.calcBufferLength(input, pageSize));
+      tslib.__classPrivateFieldSet(this, _Buffer_bytes, bytes, 'f');
+      tslib.__classPrivateFieldSet(this, _Buffer_length, input, 'f');
+      tslib.__classPrivateFieldSet(this, _Buffer_dataView, new DataView(bytes.buffer), 'f');
+    }
+  }
+  /**
+   * @public
+   * @property {number} offset
+   * @description 设置读写指针位置，以字节为单位
+   * @description 下一次调用读写方法时将在此位置开始读写
+   */
+  set offset(offset) {
+    if (offset < 0) {
+      throw new RangeError(errors.offsetInvalid);
+    }
+    if (offset > tslib.__classPrivateFieldGet(this, _Buffer_length, 'f')) {
+      throw new RangeError(errors.offsetOverflow);
+    }
+    tslib.__classPrivateFieldSet(this, _Buffer_offset, offset, 'f');
+  }
+  /**
+   * @public
+   * @property {number} offset
+   * @description 获取读写指针的位置
+   * @returns {number}
+   */
+  get offset() {
+    return tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f');
+  }
+  /**
+   * @public
+   * @property {number} length
+   * @description 设置 Buffer 长度
+   * @description 如果将长度设置为小于当前长度的值，将会截断该字节数组
+   * @description 如果将长度设置为大于当前长度的值，则用零填充字节数组的右侧
+   */
+  set length(length) {
+    if (length < 0) {
+      throw new RangeError(errors.lengthInvalid);
+    }
+    const currentLength = tslib.__classPrivateFieldGet(this, _Buffer_length, 'f');
+    if (length > currentLength) {
+      tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, length - currentLength);
+    } else {
+      tslib.__classPrivateFieldSet(this, _Buffer_length, length, 'f');
+      // 重置多余字节
+      tslib.__classPrivateFieldGet(this, _Buffer_bytes, 'f').fill(0, length);
+    }
+    if (tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f') > length) {
+      tslib.__classPrivateFieldSet(this, _Buffer_offset, length, 'f');
+    }
+  }
+  /**
+   * @public
+   * @property {number} length
+   * @description 获取 Buffer 长度
+   * @returns {number}
+   */
+  get length() {
+    return tslib.__classPrivateFieldGet(this, _Buffer_length, 'f');
+  }
+  /**
+   * @public
+   * @property {ArrayBuffer} buffer
+   * @description 获取 ArrayBuffer 缓冲区
+   * @returns {ArrayBuffer}
+   */
+  get buffer() {
+    return tslib
+      .__classPrivateFieldGet(this, _Buffer_bytes, 'f')
+      .buffer.slice(0, tslib.__classPrivateFieldGet(this, _Buffer_length, 'f'));
+  }
+  /**
+   * @public
+   * @property {Uint8Array} bytes
+   * @description 获取 Uint8Array 缓冲区
+   * @returns {Uint8Array}
+   */
+  get bytes() {
+    return tslib
+      .__classPrivateFieldGet(this, _Buffer_bytes, 'f')
+      .slice(0, tslib.__classPrivateFieldGet(this, _Buffer_length, 'f'));
+  }
+  /**
+   * @public
+   * @method writeInt8
+   * @description 在缓冲区中写入一个有符号整数
+   * @param {number} value 介于 -128 和 127 之间的整数
+   */
+  writeInt8(value) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, 1 /* SizeOf.INT8 */);
+    tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .setInt8(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), value);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, 1 /* SizeOf.INT8 */);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 1 /* SizeOf.INT8 */);
+  }
+  /**
+   * @public
+   * @method writeUint8
+   * @description 在缓冲区中写入一个无符号整数
+   * @param {number} value 介于 0 和 255 之间的整数
+   */
+  writeUint8(value) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, 1 /* SizeOf.UINT8 */);
+    tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .setUint8(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), value);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, 1 /* SizeOf.UINT8 */);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 1 /* SizeOf.UINT8 */);
+  }
+  /**
+   * @method writeBoolean
+   * @description 在缓冲区中写入布尔值，true 写 1，false写 0
+   * @param {boolean} value 布尔值
+   */
+  writeBoolean(value) {
+    this.writeUint8(value ? 1 : 0);
+  }
+  /**
+   * @method writeInt16
+   * @description 在缓冲区中写入一个 16 位有符号整数
+   * @param {number} value 要写入的 16 位有符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   */
+  writeInt16(value, littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, 2 /* SizeOf.INT16 */);
+    tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .setInt16(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), value, littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, 2 /* SizeOf.INT16 */);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 2 /* SizeOf.INT16 */);
+  }
+  /**
+   * @method writeUint16
+   * @description 在缓冲区中写入一个 16 位无符号整数
+   * @param {number} value 要写入的 16 位无符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   */
+  writeUint16(value, littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, 2 /* SizeOf.UINT16 */);
+    tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .setUint16(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), value, littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, 2 /* SizeOf.UINT16 */);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 2 /* SizeOf.UINT16 */);
+  }
+  /**
+   * @method writeInt32
+   * @description 在缓冲区中写入一个有符号的 32 位有符号整数
+   * @param {number} value 要写入的 32 位有符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   */
+  writeInt32(value, littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, 4 /* SizeOf.INT32 */);
+    tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .setInt32(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), value, littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, 4 /* SizeOf.INT32 */);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 4 /* SizeOf.INT32 */);
+  }
+  /**
+   * @method writeUint32
+   * @description 在缓冲区中写入一个无符号的 32 位无符号整数
+   * @param {number} value 要写入的 32 位无符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   */
+  writeUint32(value, littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, 4 /* SizeOf.UINT32 */);
+    tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .setUint32(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), value, littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, 4 /* SizeOf.UINT32 */);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 4 /* SizeOf.UINT32 */);
+  }
+  /**
+   * @method writeInt64
+   * @description 在缓冲区中写入一个无符号的 64 位有符号整数
+   * @param {bigint} value 要写入的 32 位有符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   */
+  writeInt64(value, littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, 8 /* SizeOf.INI64 */);
+    tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .setBigInt64(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), value, littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, 8 /* SizeOf.INI64 */);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 8 /* SizeOf.INI64 */);
+  }
+  /**
+   * @method writeUint64
+   * @description 在缓冲区中写入一个无符号的 64 位无符号整数
+   * @param {bigint} value 要写入的 64 位无符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   */
+  writeUint64(value, littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, 8 /* SizeOf.UINT64 */);
+    tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .setBigUint64(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), value, littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, 8 /* SizeOf.UINT64 */);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 8 /* SizeOf.UINT64 */);
+  }
+  /**
+   * @method writeFloat32
+   * @description 在缓冲区中写入一个 IEEE 754 单精度 32 位浮点数
+   * @param {number} value 单精度 32 位浮点数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   */
+  writeFloat32(value, littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, 4 /* SizeOf.FLOAT32 */);
+    tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .setFloat32(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), value, littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, 4 /* SizeOf.FLOAT32 */);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 4 /* SizeOf.FLOAT32 */);
+  }
+  /**
+   * @method writeFloat64
+   * @description 在缓冲区中写入一个 IEEE 754 双精度 64 位浮点数
+   * @param {number} value 双精度 64 位浮点数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   */
+  writeFloat64(value, littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, 8 /* SizeOf.FLOAT64 */);
+    tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .setFloat64(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), value, littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, 8 /* SizeOf.FLOAT64 */);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 8 /* SizeOf.FLOAT64 */);
+  }
+  write(input, start, end) {
+    let bytes;
+    if (input instanceof Uint8Array) {
+      bytes = input.subarray(start, end);
+    } else {
+      bytes = index.encode(input, start);
+    }
+    const { length } = bytes;
+    if (length > 0) {
+      tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_alloc).call(this, length);
+      tslib
+        .__classPrivateFieldGet(this, _Buffer_bytes, 'f')
+        .set(bytes, tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'));
+      tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_grow).call(this, length);
+      tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, length);
+    }
+  }
+  /**
+   * @method readInt8
+   * @description 从缓冲区中读取有符号的整数
+   * @returns {number} 介于 -128 和 127 之间的整数
+   */
+  readInt8() {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, 1 /* SizeOf.INT8 */);
+    const value = tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .getInt8(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'));
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 1 /* SizeOf.INT8 */);
+    return value;
+  }
+  /**
+   * @method readUint8
+   * @description 从缓冲区中读取无符号的整数
+   * @returns {number} 介于 0 和 255 之间的无符号整数
+   */
+  readUint8() {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, 1 /* SizeOf.UINT8 */);
+    const value = tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .getUint8(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'));
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 1 /* SizeOf.UINT8 */);
+    return value;
+  }
+  /**
+   * @method readBoolean
+   * @description 从缓冲区中读取布尔值
+   * @returns {boolean} 如果字节非零，则返回 true，否则返回 false
+   */
+  readBoolean() {
+    return Boolean(this.readUint8());
+  }
+  /**
+   * @method readInt16
+   * @description 从缓冲区中读取一个 16 位有符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   * @returns {number} 介于 -32768 和 32767 之间的 16 位有符号整数
+   */
+  readInt16(littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, 2 /* SizeOf.INT16 */);
+    const value = tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .getInt16(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 2 /* SizeOf.INT16 */);
+    return value;
+  }
+  /**
+   * @method readUint16
+   * @description 从缓冲区中读取一个 16 位无符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   * @returns {number} 介于 0 和 65535 之间的 16 位无符号整数
+   */
+  readUint16(littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, 2 /* SizeOf.UINT16 */);
+    const value = tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .getUint16(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 2 /* SizeOf.UINT16 */);
+    return value;
+  }
+  /**
+   * @method readInt32
+   * @description 从缓冲区中读取一个 32 位有符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   * @returns {number} 介于 -2147483648 和 2147483647 之间的 32 位有符号整数
+   */
+  readInt32(littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, 4 /* SizeOf.INT32 */);
+    const value = tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .getInt32(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 4 /* SizeOf.INT32 */);
+    return value;
+  }
+  /**
+   * @method readUint32
+   * @description 从缓冲区中读取一个 32 位无符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   * @returns {number} 介于 0 和 4294967295 之间的 32 位无符号整数
+   */
+  readUint32(littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, 4 /* SizeOf.UINT32 */);
+    const value = tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .getUint32(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 4 /* SizeOf.UINT32 */);
+    return value;
+  }
+  /**
+   * @method readInt64
+   * @description 从缓冲区中读取一个 64 位有符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   * @returns {bigint} 介于 -9223372036854775808 和 9223372036854775807 之间的 64 位有符号整数
+   */
+  readInt64(littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, 8 /* SizeOf.INI64 */);
+    const value = tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .getBigInt64(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 8 /* SizeOf.INI64 */);
+    return value;
+  }
+  /**
+   * @method readUint64
+   * @description 从缓冲区中读取一个 64 位无符号整数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   * @returns {bigint} 介于 0 和 18446744073709551615 之间的 64 位无符号整数
+   */
+  readUint64(littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, 8 /* SizeOf.UINT64 */);
+    const value = tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .getBigUint64(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 8 /* SizeOf.UINT64 */);
+    return value;
+  }
+  /**
+   * @method readFloat32
+   * @description 从缓冲区中读取一个 IEEE 754 单精度 32 位浮点数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   * @returns {number} 单精度 32 位浮点数
+   */
+  readFloat32(littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, 4 /* SizeOf.FLOAT32 */);
+    const value = tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .getFloat32(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 4 /* SizeOf.FLOAT32 */);
+    return value;
+  }
+  /**
+   * @method readFloat64
+   * @description 从缓冲区中读取一个 IEEE 754 双精度 64 位浮点数
+   * @param {boolean} [littleEndian] 是否为小端字节序
+   * @returns {number} 双精度 64 位浮点数
+   */
+  readFloat64(littleEndian) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, 8 /* SizeOf.FLOAT64 */);
+    const value = tslib
+      .__classPrivateFieldGet(this, _Buffer_dataView, 'f')
+      .getFloat64(tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f'), littleEndian);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, 8 /* SizeOf.FLOAT64 */);
+    return value;
+  }
+  read(length, encoding) {
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_assertRead).call(this, length);
+    const offset = tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f');
+    const bytes = tslib.__classPrivateFieldGet(this, _Buffer_bytes, 'f').slice(offset, offset + length);
+    tslib.__classPrivateFieldGet(this, _Buffer_instances, 'm', _Buffer_seek).call(this, length);
+    if (arguments.length >= 2) {
+      return index.decode(bytes, encoding);
+    }
+    return bytes;
+  }
+  /**
+   * @public
+   * @method slice
+   * @description 从指定开始和结束位置索引截取并返回新的 Buffer 对象
+   * @param {number} [start] 截取开始位置索引
+   * @param {number} [end] 截取结束位置索引
+   * @returns {Buffer}
+   */
+  slice(start, end) {
+    const bytes = tslib.__classPrivateFieldGet(this, _Buffer_bytes, 'f').slice(start, end);
+    return new Buffer(bytes, tslib.__classPrivateFieldGet(this, _Buffer_pageSize, 'f'));
+  }
+  /**
+   * @public
+   * @method copyWithin
+   * @description 从 Buffer 对象中将指定位置的数据复制到以 target 起始的位置
+   * @param {number} target 粘贴开始位置索引
+   * @param {number} start 复制开始位置索引
+   * @param {number} [end] 复制结束位置索引
+   * @returns {this}
+   */
+  copyWithin(target, start, end) {
+    tslib.__classPrivateFieldGet(this, _Buffer_bytes, 'f').copyWithin(target, start, end);
+    return this;
+  }
+  /**
+   * @override
+   * @method toString
+   * @description 获取 Buffer 对象二进制编码字符串
+   * @returns {string}
+   */
+  toString() {
+    // 二进制编码字符串
+    let binary = '';
+    // 提前获取 bytes，防止重复计算
+    const bytes = this.bytes;
+    // 获取二进制编码
+    for (const byte of bytes) {
+      binary += Binary.mapping[byte];
+    }
+    // 返回二进制编码
+    return binary;
+  }
+}
+(_Buffer_pageSize = new WeakMap()),
+  (_Buffer_bytes = new WeakMap()),
+  (_Buffer_dataView = new WeakMap()),
+  (_Buffer_offset = new WeakMap()),
+  (_Buffer_length = new WeakMap()),
+  (_Buffer_instances = new WeakSet()),
+  (_Buffer_grow = function _Buffer_grow(length) {
+    tslib.__classPrivateFieldSet(this, _Buffer_length, tslib.__classPrivateFieldGet(this, _Buffer_length, 'f') + length, 'f');
+  }),
+  (_Buffer_seek = function _Buffer_seek(offset) {
+    tslib.__classPrivateFieldSet(this, _Buffer_offset, tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f') + offset, 'f');
+  }),
+  (_Buffer_assertRead = function _Buffer_assertRead(length) {
+    if (
+      length < 0 ||
+      tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f') + length > tslib.__classPrivateFieldGet(this, _Buffer_length, 'f')
+    ) {
+      throw new RangeError(errors.readOverflow);
+    }
+  }),
+  (_Buffer_alloc = function _Buffer_alloc(length) {
+    length += tslib.__classPrivateFieldGet(this, _Buffer_offset, 'f');
+    const bytes = tslib.__classPrivateFieldGet(this, _Buffer_bytes, 'f');
+    if (length > bytes.length) {
+      const newBytes = new Uint8Array(
+        utils.calcBufferLength(length, tslib.__classPrivateFieldGet(this, _Buffer_pageSize, 'f'))
+      );
+      newBytes.set(bytes);
+      tslib.__classPrivateFieldSet(this, _Buffer_bytes, newBytes, 'f');
+      tslib.__classPrivateFieldSet(this, _Buffer_dataView, new DataView(newBytes.buffer), 'f');
+    }
+  });
+
+exports.Buffer = Buffer;
+exports.endianness = endianness;