tedious 20.1.0 → 20.2.1

package/lib/tracking-buffer/writable-tracking-buffer.js

@@ -6,92 +6,157 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 const SHIFT_LEFT_32 = (1 << 16) * (1 << 16);
 const SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
-const UNKNOWN_PLP_LEN = Buffer.from([0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);
-const ZERO_LENGTH_BUFFER = Buffer.alloc(0);
-/**
-  A Buffer-like class that tracks position.
 
-  As values are written, the position advances by the size of the written data.
-  When writing, automatically allocates new buffers if there's not enough space.
+// The first chunk starts small and doubles up to `CHUNK_SIZE`: most payloads
+// built through this class are a few dozen bytes.
+const MIN_CHUNK_SIZE = 64;
+/**
+ * A write-side buffer list.
+ *
+ * Bytes are appended through the `write*` methods, and taken out again
+ * either as a single buffer (`data`, `slice`) or as a list of chunks
+ * (`getBuffers`, `consume`). Small pieces are coalesced into chunks of at
+ * most `CHUNK_SIZE` bytes. Buffers of at least `CHUNK_SIZE` bytes written
+ * through `writeBuffer` are referenced rather than copied, so that large
+ * values cost no extra memory. (The caller must therefore not modify such
+ * buffers until they have been consumed.)
+ *
+ * The consumer side (`length`, `getBuffers`, `consume`, `slice`) mirrors
+ * that of `bl`'s `BufferList`.
  */
 class WritableTrackingBuffer {
-  constructor(initialSize, encoding, doubleSizeGrowth) {
-    this.initialSize = initialSize;
-    this.encoding = encoding || 'ucs2';
-    this.doubleSizeGrowth = doubleSizeGrowth || false;
-    this.buffer = Buffer.alloc(this.initialSize, 0);
-    this.compositeBuffer = ZERO_LENGTH_BUFFER;
-    this.position = 0;
+  /**
+   * The size of the chunks a `WritableTrackingBuffer` produces, and the size
+   * from which written buffers are referenced rather than copied.
+   */
+  static CHUNK_SIZE = 8 * 1024;
+
+  /**
+   * The number of bytes appended and not yet consumed.
+   */
+
+  constructor() {
+    this.length = 0;
+    this._bufs = [];
+    this._open = Buffer.allocUnsafe(MIN_CHUNK_SIZE);
+    this._pos = 0;
   }
+
+  /**
+   * All appended and not yet consumed bytes as a single buffer.
+   *
+   * When everything fits into a single chunk this is a view of that chunk
+   * rather than a copy. The returned buffer must not be modified.
+   */
   get data() {
-    this.newBuffer(0);
-    return this.compositeBuffer;
-  }
-  copyFrom(buffer) {
-    const length = buffer.length;
-    this.makeRoomFor(length);
-    buffer.copy(this.buffer, this.position);
-    this.position += length;
-  }
-  makeRoomFor(requiredLength) {
-    if (this.buffer.length - this.position < requiredLength) {
-      if (this.doubleSizeGrowth) {
-        let size = Math.max(128, this.buffer.length * 2);
-        while (size < requiredLength) {
-          size *= 2;
-        }
-        this.newBuffer(size);
-      } else {
-        this.newBuffer(requiredLength);
+    if (this._bufs.length === 0) {
+      return this._open.subarray(0, this._pos);
+    }
+    return this.slice();
+  }
+  _seal() {
+    if (this._pos > 0) {
+      this._bufs.push(this._open.subarray(0, this._pos));
+      this._open = Buffer.allocUnsafe(Math.min(this._open.length * 2, WritableTrackingBuffer.CHUNK_SIZE));
+      this._pos = 0;
+    }
+  }
+  _ensure(size) {
+    if (this._open.length - this._pos < size) {
+      this._seal();
+      if (this._open.length < size) {
+        this._open = Buffer.allocUnsafe(size);
       }
     }
   }
-  newBuffer(size) {
-    const buffer = this.buffer.slice(0, this.position);
-    this.compositeBuffer = Buffer.concat([this.compositeBuffer, buffer]);
-    this.buffer = size === 0 ? ZERO_LENGTH_BUFFER : Buffer.alloc(size, 0);
-    this.position = 0;
+
+  /**
+   * The chunks holding all appended and not yet consumed bytes.
+   *
+   * The returned array is the list's own: later appends can add chunks to
+   * it. `consume` does not modify it, so taking the chunks and consuming
+   * them right away yields a stable snapshot.
+   */
+  getBuffers() {
+    this._seal();
+    return this._bufs;
+  }
+
+  /**
+   * Discards the given number of bytes from the front of the list.
+   */
+  consume(bytes) {
+    this._seal();
+    const bufs = this._bufs;
+    let i = 0;
+    while (i < bufs.length && bytes >= bufs[i].length) {
+      bytes -= bufs[i].length;
+      this.length -= bufs[i].length;
+      i++;
+    }
+
+    // A fresh array, so that a previously returned `getBuffers()` result
+    // stays intact.
+    this._bufs = bufs.slice(i);
+    if (bytes > 0 && this._bufs.length) {
+      this._bufs[0] = this._bufs[0].subarray(bytes);
+      this.length -= bytes;
+    }
+    return this;
+  }
+
+  /**
+   * Copies all appended and not yet consumed bytes into a new buffer.
+   */
+  slice() {
+    this._seal();
+    const result = Buffer.allocUnsafe(this.length);
+    let position = 0;
+    for (const buffer of this._bufs) {
+      position += buffer.copy(result, position);
+    }
+    return result;
   }
   writeUInt8(value) {
-    const length = 1;
-    this.makeRoomFor(length);
-    this.buffer.writeUInt8(value, this.position);
-    this.position += length;
+    this._ensure(1);
+    this._open.writeUInt8(value, this._pos);
+    this._pos += 1;
+    this.length += 1;
   }
   writeUInt16LE(value) {
-    const length = 2;
-    this.makeRoomFor(length);
-    this.buffer.writeUInt16LE(value, this.position);
-    this.position += length;
+    this._ensure(2);
+    this._open.writeUInt16LE(value, this._pos);
+    this._pos += 2;
+    this.length += 2;
   }
   writeUShort(value) {
     this.writeUInt16LE(value);
   }
   writeUInt16BE(value) {
-    const length = 2;
-    this.makeRoomFor(length);
-    this.buffer.writeUInt16BE(value, this.position);
-    this.position += length;
+    this._ensure(2);
+    this._open.writeUInt16BE(value, this._pos);
+    this._pos += 2;
+    this.length += 2;
   }
   writeUInt24LE(value) {
-    const length = 3;
-    this.makeRoomFor(length);
-    this.buffer[this.position + 2] = value >>> 16 & 0xff;
-    this.buffer[this.position + 1] = value >>> 8 & 0xff;
-    this.buffer[this.position] = value & 0xff;
-    this.position += length;
+    this._ensure(3);
+    this._open[this._pos + 2] = value >>> 16 & 0xff;
+    this._open[this._pos + 1] = value >>> 8 & 0xff;
+    this._open[this._pos] = value & 0xff;
+    this._pos += 3;
+    this.length += 3;
   }
   writeUInt32LE(value) {
-    const length = 4;
-    this.makeRoomFor(length);
-    this.buffer.writeUInt32LE(value, this.position);
-    this.position += length;
+    this._ensure(4);
+    this._open.writeUInt32LE(value, this._pos);
+    this._pos += 4;
+    this.length += 4;
   }
   writeBigInt64LE(value) {
-    const length = 8;
-    this.makeRoomFor(length);
-    this.buffer.writeBigInt64LE(value, this.position);
-    this.position += length;
+    this._ensure(8);
+    this._open.writeBigInt64LE(value, this._pos);
+    this._pos += 8;
+    this.length += 8;
   }
   writeInt64LE(value) {
     this.writeBigInt64LE(BigInt(value));
@@ -100,16 +165,16 @@ class WritableTrackingBuffer {
     this.writeBigUInt64LE(BigInt(value));
   }
   writeBigUInt64LE(value) {
-    const length = 8;
-    this.makeRoomFor(length);
-    this.buffer.writeBigUInt64LE(value, this.position);
-    this.position += length;
+    this._ensure(8);
+    this._open.writeBigUInt64LE(value, this._pos);
+    this._pos += 8;
+    this.length += 8;
   }
   writeUInt32BE(value) {
-    const length = 4;
-    this.makeRoomFor(length);
-    this.buffer.writeUInt32BE(value, this.position);
-    this.position += length;
+    this._ensure(4);
+    this._open.writeUInt32BE(value, this._pos);
+    this._pos += 4;
+    this.length += 4;
   }
   writeUInt40LE(value) {
     // inspired by https://github.com/dpw/node-buffer-more-ints
@@ -117,57 +182,54 @@ class WritableTrackingBuffer {
     this.writeUInt8(Math.floor(value * SHIFT_RIGHT_32));
   }
   writeInt8(value) {
-    const length = 1;
-    this.makeRoomFor(length);
-    this.buffer.writeInt8(value, this.position);
-    this.position += length;
+    this._ensure(1);
+    this._open.writeInt8(value, this._pos);
+    this._pos += 1;
+    this.length += 1;
   }
   writeInt16LE(value) {
-    const length = 2;
-    this.makeRoomFor(length);
-    this.buffer.writeInt16LE(value, this.position);
-    this.position += length;
+    this._ensure(2);
+    this._open.writeInt16LE(value, this._pos);
+    this._pos += 2;
+    this.length += 2;
   }
   writeInt16BE(value) {
-    const length = 2;
-    this.makeRoomFor(length);
-    this.buffer.writeInt16BE(value, this.position);
-    this.position += length;
+    this._ensure(2);
+    this._open.writeInt16BE(value, this._pos);
+    this._pos += 2;
+    this.length += 2;
   }
   writeInt32LE(value) {
-    const length = 4;
-    this.makeRoomFor(length);
-    this.buffer.writeInt32LE(value, this.position);
-    this.position += length;
+    this._ensure(4);
+    this._open.writeInt32LE(value, this._pos);
+    this._pos += 4;
+    this.length += 4;
   }
   writeInt32BE(value) {
-    const length = 4;
-    this.makeRoomFor(length);
-    this.buffer.writeInt32BE(value, this.position);
-    this.position += length;
+    this._ensure(4);
+    this._open.writeInt32BE(value, this._pos);
+    this._pos += 4;
+    this.length += 4;
   }
   writeFloatLE(value) {
-    const length = 4;
-    this.makeRoomFor(length);
-    this.buffer.writeFloatLE(value, this.position);
-    this.position += length;
+    this._ensure(4);
+    this._open.writeFloatLE(value, this._pos);
+    this._pos += 4;
+    this.length += 4;
   }
   writeDoubleLE(value) {
-    const length = 8;
-    this.makeRoomFor(length);
-    this.buffer.writeDoubleLE(value, this.position);
-    this.position += length;
+    this._ensure(8);
+    this._open.writeDoubleLE(value, this._pos);
+    this._pos += 8;
+    this.length += 8;
   }
   writeString(value, encoding) {
-    if (encoding == null) {
-      encoding = this.encoding;
-    }
-    const length = Buffer.byteLength(value, encoding);
-    this.makeRoomFor(length);
-
-    // $FlowFixMe https://github.com/facebook/flow/pull/5398
-    this.buffer.write(value, this.position, encoding);
-    this.position += length;
+    // UCS-2 is two bytes per UTF-16 code unit.
+    const length = encoding === 'ucs2' ? value.length * 2 : Buffer.byteLength(value, encoding);
+    this._ensure(length);
+    this._open.write(value, this._pos, encoding);
+    this._pos += length;
+    this.length += length;
   }
   writeBVarchar(value, encoding) {
     this.writeUInt8(value.length);
@@ -177,73 +239,28 @@ class WritableTrackingBuffer {
     this.writeUInt16LE(value.length);
     this.writeString(value, encoding);
   }
-
-  // TODO: Figure out what types are passed in other than `Buffer`
-  writeUsVarbyte(value, encoding) {
-    if (encoding == null) {
-      encoding = this.encoding;
-    }
-    let length;
-    if (value instanceof Buffer) {
-      length = value.length;
-    } else {
-      value = value.toString();
-      length = Buffer.byteLength(value, encoding);
-    }
-    this.writeUInt16LE(length);
-    if (value instanceof Buffer) {
-      this.writeBuffer(value);
-    } else {
-      this.makeRoomFor(length);
-      // $FlowFixMe https://github.com/facebook/flow/pull/5398
-      this.buffer.write(value, this.position, encoding);
-      this.position += length;
-    }
+  writeUsVarbyte(value) {
+    this.writeUInt16LE(value.length);
+    this.writeBuffer(value);
   }
-  writePLPBody(value, encoding) {
-    if (encoding == null) {
-      encoding = this.encoding;
-    }
-    let length;
-    if (value instanceof Buffer) {
-      length = value.length;
-    } else {
-      value = value.toString();
-      length = Buffer.byteLength(value, encoding);
-    }
 
-    // Length of all chunks.
-    // this.writeUInt64LE(length);
-    // unknown seems to work better here - might revisit later.
-    this.writeBuffer(UNKNOWN_PLP_LEN);
-
-    // In the UNKNOWN_PLP_LEN case, the data is represented as a series of zero or more chunks.
-    if (length > 0) {
-      // One chunk.
-      this.writeUInt32LE(length);
-      if (value instanceof Buffer) {
-        this.writeBuffer(value);
-      } else {
-        this.makeRoomFor(length);
-        this.buffer.write(value, this.position, encoding);
-        this.position += length;
-      }
-    }
-
-    // PLP_TERMINATOR (no more chunks).
-    this.writeUInt32LE(0);
-  }
+  /**
+   * Appends a buffer. Buffers of at least `CHUNK_SIZE` bytes are referenced
+   * rather than copied, and must not be modified until consumed.
+   */
   writeBuffer(value) {
     const length = value.length;
-    this.makeRoomFor(length);
-    value.copy(this.buffer, this.position);
-    this.position += length;
-  }
-  writeMoney(value) {
-    this.writeInt32LE(Math.floor(value * SHIFT_RIGHT_32));
-    this.writeInt32LE(value & -1);
+    if (length >= WritableTrackingBuffer.CHUNK_SIZE) {
+      this._seal();
+      this._bufs.push(value);
+    } else {
+      this._ensure(length);
+      value.copy(this._open, this._pos);
+      this._pos += length;
+    }
+    this.length += length;
   }
 }
 var _default = exports.default = WritableTrackingBuffer;
 module.exports = WritableTrackingBuffer;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SHIFT_LEFT_32","SHIFT_RIGHT_32","UNKNOWN_PLP_LEN","Buffer","from","ZERO_LENGTH_BUFFER","alloc","WritableTrackingBuffer","constructor","initialSize","encoding","doubleSizeGrowth","buffer","compositeBuffer","position","data","newBuffer","copyFrom","length","makeRoomFor","copy","requiredLength","size","Math","max","slice","concat","writeUInt8","value","writeUInt16LE","writeUShort","writeUInt16BE","writeUInt24LE","writeUInt32LE","writeBigInt64LE","writeInt64LE","BigInt","writeUInt64LE","writeBigUInt64LE","writeUInt32BE","writeUInt40LE","writeInt32LE","floor","writeInt8","writeInt16LE","writeInt16BE","writeInt32BE","writeFloatLE","writeDoubleLE","writeString","byteLength","write","writeBVarchar","writeUsVarchar","writeUsVarbyte","toString","writeBuffer","writePLPBody","writeMoney","_default","exports","default","module"],"sources":["../../src/tracking-buffer/writable-tracking-buffer.ts"],"sourcesContent":["const SHIFT_LEFT_32 = (1 << 16) * (1 << 16);\nconst SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;\nconst UNKNOWN_PLP_LEN = Buffer.from([0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);\nconst ZERO_LENGTH_BUFFER = Buffer.alloc(0);\n\nexport type Encoding = 'utf8' | 'ucs2' | 'ascii';\n\n/**\n  A Buffer-like class that tracks position.\n\n  As values are written, the position advances by the size of the written data.\n  When writing, automatically allocates new buffers if there's not enough space.\n */\nclass WritableTrackingBuffer {\n  declare initialSize: number;\n  declare encoding: Encoding;\n  declare doubleSizeGrowth: boolean;\n\n  declare buffer: Buffer;\n  declare compositeBuffer: Buffer;\n\n  declare position: number;\n\n  constructor(initialSize: number, encoding?: Encoding | null, doubleSizeGrowth?: boolean) {\n    this.initialSize = initialSize;\n    this.encoding = encoding || 'ucs2';\n    this.doubleSizeGrowth = doubleSizeGrowth || false;\n    this.buffer = Buffer.alloc(this.initialSize, 0);\n    this.compositeBuffer = ZERO_LENGTH_BUFFER;\n    this.position = 0;\n  }\n\n  get data() {\n    this.newBuffer(0);\n    return this.compositeBuffer;\n  }\n\n  copyFrom(buffer: Buffer) {\n    const length = buffer.length;\n    this.makeRoomFor(length);\n    buffer.copy(this.buffer, this.position);\n    this.position += length;\n  }\n\n  makeRoomFor(requiredLength: number) {\n    if (this.buffer.length - this.position < requiredLength) {\n      if (this.doubleSizeGrowth) {\n        let size = Math.max(128, this.buffer.length * 2);\n        while (size < requiredLength) {\n          size *= 2;\n        }\n        this.newBuffer(size);\n      } else {\n        this.newBuffer(requiredLength);\n      }\n    }\n  }\n\n  newBuffer(size: number) {\n    const buffer = this.buffer.slice(0, this.position);\n    this.compositeBuffer = Buffer.concat([this.compositeBuffer, buffer]);\n    this.buffer = (size === 0) ? ZERO_LENGTH_BUFFER : Buffer.alloc(size, 0);\n    this.position = 0;\n  }\n\n  writeUInt8(value: number) {\n    const length = 1;\n    this.makeRoomFor(length);\n    this.buffer.writeUInt8(value, this.position);\n    this.position += length;\n  }\n\n  writeUInt16LE(value: number) {\n    const length = 2;\n    this.makeRoomFor(length);\n    this.buffer.writeUInt16LE(value, this.position);\n    this.position += length;\n  }\n\n  writeUShort(value: number) {\n    this.writeUInt16LE(value);\n  }\n\n  writeUInt16BE(value: number) {\n    const length = 2;\n    this.makeRoomFor(length);\n    this.buffer.writeUInt16BE(value, this.position);\n    this.position += length;\n  }\n\n  writeUInt24LE(value: number) {\n    const length = 3;\n    this.makeRoomFor(length);\n    this.buffer[this.position + 2] = (value >>> 16) & 0xff;\n    this.buffer[this.position + 1] = (value >>> 8) & 0xff;\n    this.buffer[this.position] = value & 0xff;\n    this.position += length;\n  }\n\n  writeUInt32LE(value: number) {\n    const length = 4;\n    this.makeRoomFor(length);\n    this.buffer.writeUInt32LE(value, this.position);\n    this.position += length;\n  }\n\n  writeBigInt64LE(value: bigint) {\n    const length = 8;\n    this.makeRoomFor(length);\n    this.buffer.writeBigInt64LE(value, this.position);\n    this.position += length;\n  }\n\n  writeInt64LE(value: number) {\n    this.writeBigInt64LE(BigInt(value));\n  }\n\n  writeUInt64LE(value: number) {\n    this.writeBigUInt64LE(BigInt(value));\n  }\n\n  writeBigUInt64LE(value: bigint) {\n    const length = 8;\n    this.makeRoomFor(length);\n    this.buffer.writeBigUInt64LE(value, this.position);\n    this.position += length;\n  }\n\n  writeUInt32BE(value: number) {\n    const length = 4;\n    this.makeRoomFor(length);\n    this.buffer.writeUInt32BE(value, this.position);\n    this.position += length;\n  }\n\n  writeUInt40LE(value: number) {\n    // inspired by https://github.com/dpw/node-buffer-more-ints\n    this.writeInt32LE(value & -1);\n    this.writeUInt8(Math.floor(value * SHIFT_RIGHT_32));\n  }\n\n  writeInt8(value: number) {\n    const length = 1;\n    this.makeRoomFor(length);\n    this.buffer.writeInt8(value, this.position);\n    this.position += length;\n  }\n\n  writeInt16LE(value: number) {\n    const length = 2;\n    this.makeRoomFor(length);\n    this.buffer.writeInt16LE(value, this.position);\n    this.position += length;\n  }\n\n  writeInt16BE(value: number) {\n    const length = 2;\n    this.makeRoomFor(length);\n    this.buffer.writeInt16BE(value, this.position);\n    this.position += length;\n  }\n\n  writeInt32LE(value: number) {\n    const length = 4;\n    this.makeRoomFor(length);\n    this.buffer.writeInt32LE(value, this.position);\n    this.position += length;\n  }\n\n  writeInt32BE(value: number) {\n    const length = 4;\n    this.makeRoomFor(length);\n    this.buffer.writeInt32BE(value, this.position);\n    this.position += length;\n  }\n\n  writeFloatLE(value: number) {\n    const length = 4;\n    this.makeRoomFor(length);\n    this.buffer.writeFloatLE(value, this.position);\n    this.position += length;\n  }\n\n  writeDoubleLE(value: number) {\n    const length = 8;\n    this.makeRoomFor(length);\n    this.buffer.writeDoubleLE(value, this.position);\n    this.position += length;\n  }\n\n  writeString(value: string, encoding?: Encoding | null) {\n    if (encoding == null) {\n      encoding = this.encoding;\n    }\n\n    const length = Buffer.byteLength(value, encoding);\n    this.makeRoomFor(length);\n\n    // $FlowFixMe https://github.com/facebook/flow/pull/5398\n    this.buffer.write(value, this.position, encoding);\n    this.position += length;\n  }\n\n  writeBVarchar(value: string, encoding?: Encoding | null) {\n    this.writeUInt8(value.length);\n    this.writeString(value, encoding);\n  }\n\n  writeUsVarchar(value: string, encoding?: Encoding | null) {\n    this.writeUInt16LE(value.length);\n    this.writeString(value, encoding);\n  }\n\n  // TODO: Figure out what types are passed in other than `Buffer`\n  writeUsVarbyte(value: any, encoding?: Encoding | null) {\n    if (encoding == null) {\n      encoding = this.encoding;\n    }\n\n    let length;\n    if (value instanceof Buffer) {\n      length = value.length;\n    } else {\n      value = value.toString();\n      length = Buffer.byteLength(value, encoding);\n    }\n    this.writeUInt16LE(length);\n\n    if (value instanceof Buffer) {\n      this.writeBuffer(value);\n    } else {\n      this.makeRoomFor(length);\n      // $FlowFixMe https://github.com/facebook/flow/pull/5398\n      this.buffer.write(value, this.position, encoding);\n      this.position += length;\n    }\n  }\n\n  writePLPBody(value: any, encoding?: Encoding | null) {\n    if (encoding == null) {\n      encoding = this.encoding;\n    }\n\n    let length;\n    if (value instanceof Buffer) {\n      length = value.length;\n    } else {\n      value = value.toString();\n      length = Buffer.byteLength(value, encoding);\n    }\n\n    // Length of all chunks.\n    // this.writeUInt64LE(length);\n    // unknown seems to work better here - might revisit later.\n    this.writeBuffer(UNKNOWN_PLP_LEN);\n\n    // In the UNKNOWN_PLP_LEN case, the data is represented as a series of zero or more chunks.\n    if (length > 0) {\n      // One chunk.\n      this.writeUInt32LE(length);\n      if (value instanceof Buffer) {\n        this.writeBuffer(value);\n      } else {\n        this.makeRoomFor(length);\n        this.buffer.write(value, this.position, encoding);\n        this.position += length;\n      }\n    }\n\n    // PLP_TERMINATOR (no more chunks).\n    this.writeUInt32LE(0);\n  }\n\n  writeBuffer(value: Buffer) {\n    const length = value.length;\n    this.makeRoomFor(length);\n    value.copy(this.buffer, this.position);\n    this.position += length;\n  }\n\n  writeMoney(value: number) {\n    this.writeInt32LE(Math.floor(value * SHIFT_RIGHT_32));\n    this.writeInt32LE(value & -1);\n  }\n}\n\nexport default WritableTrackingBuffer;\nmodule.exports = WritableTrackingBuffer;\n"],"mappings":"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","ignoreList":[]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SHIFT_LEFT_32","SHIFT_RIGHT_32","MIN_CHUNK_SIZE","WritableTrackingBuffer","CHUNK_SIZE","constructor","length","_bufs","_open","Buffer","allocUnsafe","_pos","data","subarray","slice","_seal","push","Math","min","_ensure","size","getBuffers","consume","bytes","bufs","i","result","position","buffer","copy","writeUInt8","value","writeUInt16LE","writeUShort","writeUInt16BE","writeUInt24LE","writeUInt32LE","writeBigInt64LE","writeInt64LE","BigInt","writeUInt64LE","writeBigUInt64LE","writeUInt32BE","writeUInt40LE","writeInt32LE","floor","writeInt8","writeInt16LE","writeInt16BE","writeInt32BE","writeFloatLE","writeDoubleLE","writeString","encoding","byteLength","write","writeBVarchar","writeUsVarchar","writeUsVarbyte","writeBuffer","_default","exports","default","module"],"sources":["../../src/tracking-buffer/writable-tracking-buffer.ts"],"sourcesContent":["const SHIFT_LEFT_32 = (1 << 16) * (1 << 16);\nconst SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;\n\n// The first chunk starts small and doubles up to `CHUNK_SIZE`: most payloads\n// built through this class are a few dozen bytes.\nconst MIN_CHUNK_SIZE = 64;\n\nexport type Encoding = 'utf8' | 'ucs2' | 'ascii';\n\n/**\n * A write-side buffer list.\n *\n * Bytes are appended through the `write*` methods, and taken out again\n * either as a single buffer (`data`, `slice`) or as a list of chunks\n * (`getBuffers`, `consume`). Small pieces are coalesced into chunks of at\n * most `CHUNK_SIZE` bytes. Buffers of at least `CHUNK_SIZE` bytes written\n * through `writeBuffer` are referenced rather than copied, so that large\n * values cost no extra memory. (The caller must therefore not modify such\n * buffers until they have been consumed.)\n *\n * The consumer side (`length`, `getBuffers`, `consume`, `slice`) mirrors\n * that of `bl`'s `BufferList`.\n */\nclass WritableTrackingBuffer {\n  /**\n   * The size of the chunks a `WritableTrackingBuffer` produces, and the size\n   * from which written buffers are referenced rather than copied.\n   */\n  static readonly CHUNK_SIZE = 8 * 1024;\n\n  /**\n   * The number of bytes appended and not yet consumed.\n   */\n  declare length: number;\n\n  declare private _bufs: Buffer[];\n  declare private _open: Buffer;\n  declare private _pos: number;\n\n  constructor() {\n    this.length = 0;\n    this._bufs = [];\n    this._open = Buffer.allocUnsafe(MIN_CHUNK_SIZE);\n    this._pos = 0;\n  }\n\n  /**\n   * All appended and not yet consumed bytes as a single buffer.\n   *\n   * When everything fits into a single chunk this is a view of that chunk\n   * rather than a copy. The returned buffer must not be modified.\n   */\n  get data(): Buffer {\n    if (this._bufs.length === 0) {\n      return this._open.subarray(0, this._pos);\n    }\n\n    return this.slice();\n  }\n\n  private _seal() {\n    if (this._pos > 0) {\n      this._bufs.push(this._open.subarray(0, this._pos));\n      this._open = Buffer.allocUnsafe(Math.min(this._open.length * 2, WritableTrackingBuffer.CHUNK_SIZE));\n      this._pos = 0;\n    }\n  }\n\n  private _ensure(size: number) {\n    if (this._open.length - this._pos < size) {\n      this._seal();\n\n      if (this._open.length < size) {\n        this._open = Buffer.allocUnsafe(size);\n      }\n    }\n  }\n\n  /**\n   * The chunks holding all appended and not yet consumed bytes.\n   *\n   * The returned array is the list's own: later appends can add chunks to\n   * it. `consume` does not modify it, so taking the chunks and consuming\n   * them right away yields a stable snapshot.\n   */\n  getBuffers(): Buffer[] {\n    this._seal();\n    return this._bufs;\n  }\n\n  /**\n   * Discards the given number of bytes from the front of the list.\n   */\n  consume(bytes: number): this {\n    this._seal();\n\n    const bufs = this._bufs;\n    let i = 0;\n    while (i < bufs.length && bytes >= bufs[i].length) {\n      bytes -= bufs[i].length;\n      this.length -= bufs[i].length;\n      i++;\n    }\n\n    // A fresh array, so that a previously returned `getBuffers()` result\n    // stays intact.\n    this._bufs = bufs.slice(i);\n\n    if (bytes > 0 && this._bufs.length) {\n      this._bufs[0] = this._bufs[0].subarray(bytes);\n      this.length -= bytes;\n    }\n\n    return this;\n  }\n\n  /**\n   * Copies all appended and not yet consumed bytes into a new buffer.\n   */\n  slice(): Buffer {\n    this._seal();\n\n    const result = Buffer.allocUnsafe(this.length);\n    let position = 0;\n    for (const buffer of this._bufs) {\n      position += buffer.copy(result, position);\n    }\n\n    return result;\n  }\n\n  writeUInt8(value: number) {\n    this._ensure(1);\n    this._open.writeUInt8(value, this._pos);\n    this._pos += 1;\n    this.length += 1;\n  }\n\n  writeUInt16LE(value: number) {\n    this._ensure(2);\n    this._open.writeUInt16LE(value, this._pos);\n    this._pos += 2;\n    this.length += 2;\n  }\n\n  writeUShort(value: number) {\n    this.writeUInt16LE(value);\n  }\n\n  writeUInt16BE(value: number) {\n    this._ensure(2);\n    this._open.writeUInt16BE(value, this._pos);\n    this._pos += 2;\n    this.length += 2;\n  }\n\n  writeUInt24LE(value: number) {\n    this._ensure(3);\n    this._open[this._pos + 2] = (value >>> 16) & 0xff;\n    this._open[this._pos + 1] = (value >>> 8) & 0xff;\n    this._open[this._pos] = value & 0xff;\n    this._pos += 3;\n    this.length += 3;\n  }\n\n  writeUInt32LE(value: number) {\n    this._ensure(4);\n    this._open.writeUInt32LE(value, this._pos);\n    this._pos += 4;\n    this.length += 4;\n  }\n\n  writeBigInt64LE(value: bigint) {\n    this._ensure(8);\n    this._open.writeBigInt64LE(value, this._pos);\n    this._pos += 8;\n    this.length += 8;\n  }\n\n  writeInt64LE(value: number) {\n    this.writeBigInt64LE(BigInt(value));\n  }\n\n  writeUInt64LE(value: number) {\n    this.writeBigUInt64LE(BigInt(value));\n  }\n\n  writeBigUInt64LE(value: bigint) {\n    this._ensure(8);\n    this._open.writeBigUInt64LE(value, this._pos);\n    this._pos += 8;\n    this.length += 8;\n  }\n\n  writeUInt32BE(value: number) {\n    this._ensure(4);\n    this._open.writeUInt32BE(value, this._pos);\n    this._pos += 4;\n    this.length += 4;\n  }\n\n  writeUInt40LE(value: number) {\n    // inspired by https://github.com/dpw/node-buffer-more-ints\n    this.writeInt32LE(value & -1);\n    this.writeUInt8(Math.floor(value * SHIFT_RIGHT_32));\n  }\n\n  writeInt8(value: number) {\n    this._ensure(1);\n    this._open.writeInt8(value, this._pos);\n    this._pos += 1;\n    this.length += 1;\n  }\n\n  writeInt16LE(value: number) {\n    this._ensure(2);\n    this._open.writeInt16LE(value, this._pos);\n    this._pos += 2;\n    this.length += 2;\n  }\n\n  writeInt16BE(value: number) {\n    this._ensure(2);\n    this._open.writeInt16BE(value, this._pos);\n    this._pos += 2;\n    this.length += 2;\n  }\n\n  writeInt32LE(value: number) {\n    this._ensure(4);\n    this._open.writeInt32LE(value, this._pos);\n    this._pos += 4;\n    this.length += 4;\n  }\n\n  writeInt32BE(value: number) {\n    this._ensure(4);\n    this._open.writeInt32BE(value, this._pos);\n    this._pos += 4;\n    this.length += 4;\n  }\n\n  writeFloatLE(value: number) {\n    this._ensure(4);\n    this._open.writeFloatLE(value, this._pos);\n    this._pos += 4;\n    this.length += 4;\n  }\n\n  writeDoubleLE(value: number) {\n    this._ensure(8);\n    this._open.writeDoubleLE(value, this._pos);\n    this._pos += 8;\n    this.length += 8;\n  }\n\n  writeString(value: string, encoding: Encoding) {\n    // UCS-2 is two bytes per UTF-16 code unit.\n    const length = encoding === 'ucs2' ? value.length * 2 : Buffer.byteLength(value, encoding);\n    this._ensure(length);\n    this._open.write(value, this._pos, encoding);\n    this._pos += length;\n    this.length += length;\n  }\n\n  writeBVarchar(value: string, encoding: Encoding) {\n    this.writeUInt8(value.length);\n    this.writeString(value, encoding);\n  }\n\n  writeUsVarchar(value: string, encoding: Encoding) {\n    this.writeUInt16LE(value.length);\n    this.writeString(value, encoding);\n  }\n\n  writeUsVarbyte(value: Buffer) {\n    this.writeUInt16LE(value.length);\n    this.writeBuffer(value);\n  }\n\n  /**\n   * Appends a buffer. Buffers of at least `CHUNK_SIZE` bytes are referenced\n   * rather than copied, and must not be modified until consumed.\n   */\n  writeBuffer(value: Buffer) {\n    const length = value.length;\n    if (length >= WritableTrackingBuffer.CHUNK_SIZE) {\n      this._seal();\n      this._bufs.push(value);\n    } else {\n      this._ensure(length);\n      value.copy(this._open, this._pos);\n      this._pos += length;\n    }\n\n    this.length += length;\n  }\n}\n\nexport default WritableTrackingBuffer;\nmodule.exports = WritableTrackingBuffer;\n"],"mappings":"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","ignoreList":[]}

package/lib/tracking-buffer/writable-tracking-buffer.js.map

@@ -1 +1 @@
-{"version":3,"file":"writable-tracking-buffer.js","names":["SHIFT_LEFT_32","SHIFT_RIGHT_32","UNKNOWN_PLP_LEN","Buffer","from","ZERO_LENGTH_BUFFER","alloc","WritableTrackingBuffer","constructor","initialSize","encoding","doubleSizeGrowth","buffer","compositeBuffer","position","data","newBuffer","copyFrom","length","makeRoomFor","copy","requiredLength","size","Math","max","slice","concat","writeUInt8","value","writeUInt16LE","writeUShort","writeUInt16BE","writeUInt24LE","writeUInt32LE","writeBigInt64LE","writeInt64LE","BigInt","writeUInt64LE","writeBigUInt64LE","writeUInt32BE","writeUInt40LE","writeInt32LE","floor","writeInt8","writeInt16LE","writeInt16BE","writeInt32BE","writeFloatLE","writeDoubleLE","writeString","byteLength","write","writeBVarchar","writeUsVarchar","writeUsVarbyte","toString","writeBuffer","writePLPBody","writeMoney","_default","exports","default","module"],"sources":["../../src/tracking-buffer/writable-tracking-buffer.ts"],"sourcesContent":["const SHIFT_LEFT_32 = (1 << 16) * (1 << 16);\nconst SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;\nconst UNKNOWN_PLP_LEN = Buffer.from([0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);\nconst ZERO_LENGTH_BUFFER = Buffer.alloc(0);\n\nexport type Encoding = 'utf8' | 'ucs2' | 'ascii';\n\n/**\n  A Buffer-like class that tracks position.\n\n  As values are written, the position advances by the size of the written data.\n  When writing, automatically allocates new buffers if there's not enough space.\n */\nclass WritableTrackingBuffer {\n  declare initialSize: number;\n  declare encoding: Encoding;\n  declare doubleSizeGrowth: boolean;\n\n  declare buffer: Buffer;\n  declare compositeBuffer: Buffer;\n\n  declare position: number;\n\n  constructor(initialSize: number, encoding?: Encoding | null, doubleSizeGrowth?: boolean) {\n    this.initialSize = initialSize;\n    this.encoding = encoding || 'ucs2';\n    this.doubleSizeGrowth = doubleSizeGrowth || false;\n    this.buffer = Buffer.alloc(this.initialSize, 0);\n    this.compositeBuffer = ZERO_LENGTH_BUFFER;\n    this.position = 0;\n  }\n\n  get data() {\n    this.newBuffer(0);\n    return this.compositeBuffer;\n  }\n\n  copyFrom(buffer: Buffer) {\n    const length = buffer.length;\n    this.makeRoomFor(length);\n    buffer.copy(this.buffer, this.position);\n    this.position += length;\n  }\n\n  makeRoomFor(requiredLength: number) {\n    if (this.buffer.length - this.position < requiredLength) {\n      if (this.doubleSizeGrowth) {\n        let size = Math.max(128, this.buffer.length * 2);\n        while (size < requiredLength) {\n          size *= 2;\n        }\n        this.newBuffer(size);\n      } else {\n        this.newBuffer(requiredLength);\n      }\n    }\n  }\n\n  newBuffer(size: number) {\n    const buffer = this.buffer.slice(0, this.position);\n    this.compositeBuffer = Buffer.concat([this.compositeBuffer, buffer]);\n    this.buffer = (size === 0) ? ZERO_LENGTH_BUFFER : Buffer.alloc(size, 0);\n    this.position = 0;\n  }\n\n  writeUInt8(value: number) {\n    const length = 1;\n    this.makeRoomFor(length);\n    this.buffer.writeUInt8(value, this.position);\n    this.position += length;\n  }\n\n  writeUInt16LE(value: number) {\n    const length = 2;\n    this.makeRoomFor(length);\n    this.buffer.writeUInt16LE(value, this.position);\n    this.position += length;\n  }\n\n  writeUShort(value: number) {\n    this.writeUInt16LE(value);\n  }\n\n  writeUInt16BE(value: number) {\n    const length = 2;\n    this.makeRoomFor(length);\n    this.buffer.writeUInt16BE(value, this.position);\n    this.position += length;\n  }\n\n  writeUInt24LE(value: number) {\n    const length = 3;\n    this.makeRoomFor(length);\n    this.buffer[this.position + 2] = (value >>> 16) & 0xff;\n    this.buffer[this.position + 1] = (value >>> 8) & 0xff;\n    this.buffer[this.position] = value & 0xff;\n    this.position += length;\n  }\n\n  writeUInt32LE(value: number) {\n    const length = 4;\n    this.makeRoomFor(length);\n    this.buffer.writeUInt32LE(value, this.position);\n    this.position += length;\n  }\n\n  writeBigInt64LE(value: bigint) {\n    const length = 8;\n    this.makeRoomFor(length);\n    this.buffer.writeBigInt64LE(value, this.position);\n    this.position += length;\n  }\n\n  writeInt64LE(value: number) {\n    this.writeBigInt64LE(BigInt(value));\n  }\n\n  writeUInt64LE(value: number) {\n    this.writeBigUInt64LE(BigInt(value));\n  }\n\n  writeBigUInt64LE(value: bigint) {\n    const length = 8;\n    this.makeRoomFor(length);\n    this.buffer.writeBigUInt64LE(value, this.position);\n    this.position += length;\n  }\n\n  writeUInt32BE(value: number) {\n    const length = 4;\n    this.makeRoomFor(length);\n    this.buffer.writeUInt32BE(value, this.position);\n    this.position += length;\n  }\n\n  writeUInt40LE(value: number) {\n    // inspired by https://github.com/dpw/node-buffer-more-ints\n    this.writeInt32LE(value & -1);\n    this.writeUInt8(Math.floor(value * SHIFT_RIGHT_32));\n  }\n\n  writeInt8(value: number) {\n    const length = 1;\n    this.makeRoomFor(length);\n    this.buffer.writeInt8(value, this.position);\n    this.position += length;\n  }\n\n  writeInt16LE(value: number) {\n    const length = 2;\n    this.makeRoomFor(length);\n    this.buffer.writeInt16LE(value, this.position);\n    this.position += length;\n  }\n\n  writeInt16BE(value: number) {\n    const length = 2;\n    this.makeRoomFor(length);\n    this.buffer.writeInt16BE(value, this.position);\n    this.position += length;\n  }\n\n  writeInt32LE(value: number) {\n    const length = 4;\n    this.makeRoomFor(length);\n    this.buffer.writeInt32LE(value, this.position);\n    this.position += length;\n  }\n\n  writeInt32BE(value: number) {\n    const length = 4;\n    this.makeRoomFor(length);\n    this.buffer.writeInt32BE(value, this.position);\n    this.position += length;\n  }\n\n  writeFloatLE(value: number) {\n    const length = 4;\n    this.makeRoomFor(length);\n    this.buffer.writeFloatLE(value, this.position);\n    this.position += length;\n  }\n\n  writeDoubleLE(value: number) {\n    const length = 8;\n    this.makeRoomFor(length);\n    this.buffer.writeDoubleLE(value, this.position);\n    this.position += length;\n  }\n\n  writeString(value: string, encoding?: Encoding | null) {\n    if (encoding == null) {\n      encoding = this.encoding;\n    }\n\n    const length = Buffer.byteLength(value, encoding);\n    this.makeRoomFor(length);\n\n    // $FlowFixMe https://github.com/facebook/flow/pull/5398\n    this.buffer.write(value, this.position, encoding);\n    this.position += length;\n  }\n\n  writeBVarchar(value: string, encoding?: Encoding | null) {\n    this.writeUInt8(value.length);\n    this.writeString(value, encoding);\n  }\n\n  writeUsVarchar(value: string, encoding?: Encoding | null) {\n    this.writeUInt16LE(value.length);\n    this.writeString(value, encoding);\n  }\n\n  // TODO: Figure out what types are passed in other than `Buffer`\n  writeUsVarbyte(value: any, encoding?: Encoding | null) {\n    if (encoding == null) {\n      encoding = this.encoding;\n    }\n\n    let length;\n    if (value instanceof Buffer) {\n      length = value.length;\n    } else {\n      value = value.toString();\n      length = Buffer.byteLength(value, encoding);\n    }\n    this.writeUInt16LE(length);\n\n    if (value instanceof Buffer) {\n      this.writeBuffer(value);\n    } else {\n      this.makeRoomFor(length);\n      // $FlowFixMe https://github.com/facebook/flow/pull/5398\n      this.buffer.write(value, this.position, encoding);\n      this.position += length;\n    }\n  }\n\n  writePLPBody(value: any, encoding?: Encoding | null) {\n    if (encoding == null) {\n      encoding = this.encoding;\n    }\n\n    let length;\n    if (value instanceof Buffer) {\n      length = value.length;\n    } else {\n      value = value.toString();\n      length = Buffer.byteLength(value, encoding);\n    }\n\n    // Length of all chunks.\n    // this.writeUInt64LE(length);\n    // unknown seems to work better here - might revisit later.\n    this.writeBuffer(UNKNOWN_PLP_LEN);\n\n    // In the UNKNOWN_PLP_LEN case, the data is represented as a series of zero or more chunks.\n    if (length > 0) {\n      // One chunk.\n      this.writeUInt32LE(length);\n      if (value instanceof Buffer) {\n        this.writeBuffer(value);\n      } else {\n        this.makeRoomFor(length);\n        this.buffer.write(value, this.position, encoding);\n        this.position += length;\n      }\n    }\n\n    // PLP_TERMINATOR (no more chunks).\n    this.writeUInt32LE(0);\n  }\n\n  writeBuffer(value: Buffer) {\n    const length = value.length;\n    this.makeRoomFor(length);\n    value.copy(this.buffer, this.position);\n    this.position += length;\n  }\n\n  writeMoney(value: number) {\n    this.writeInt32LE(Math.floor(value * SHIFT_RIGHT_32));\n    this.writeInt32LE(value & -1);\n  }\n}\n\nexport default WritableTrackingBuffer;\nmodule.exports = WritableTrackingBuffer;\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"writable-tracking-buffer.js","names":["SHIFT_LEFT_32","SHIFT_RIGHT_32","MIN_CHUNK_SIZE","WritableTrackingBuffer","CHUNK_SIZE","constructor","length","_bufs","_open","Buffer","allocUnsafe","_pos","data","subarray","slice","_seal","push","Math","min","_ensure","size","getBuffers","consume","bytes","bufs","i","result","position","buffer","copy","writeUInt8","value","writeUInt16LE","writeUShort","writeUInt16BE","writeUInt24LE","writeUInt32LE","writeBigInt64LE","writeInt64LE","BigInt","writeUInt64LE","writeBigUInt64LE","writeUInt32BE","writeUInt40LE","writeInt32LE","floor","writeInt8","writeInt16LE","writeInt16BE","writeInt32BE","writeFloatLE","writeDoubleLE","writeString","encoding","byteLength","write","writeBVarchar","writeUsVarchar","writeUsVarbyte","writeBuffer","_default","exports","default","module"],"sources":["../../src/tracking-buffer/writable-tracking-buffer.ts"],"sourcesContent":["const SHIFT_LEFT_32 = (1 << 16) * (1 << 16);\nconst SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;\n\n// The first chunk starts small and doubles up to `CHUNK_SIZE`: most payloads\n// built through this class are a few dozen bytes.\nconst MIN_CHUNK_SIZE = 64;\n\nexport type Encoding = 'utf8' | 'ucs2' | 'ascii';\n\n/**\n * A write-side buffer list.\n *\n * Bytes are appended through the `write*` methods, and taken out again\n * either as a single buffer (`data`, `slice`) or as a list of chunks\n * (`getBuffers`, `consume`). Small pieces are coalesced into chunks of at\n * most `CHUNK_SIZE` bytes. Buffers of at least `CHUNK_SIZE` bytes written\n * through `writeBuffer` are referenced rather than copied, so that large\n * values cost no extra memory. (The caller must therefore not modify such\n * buffers until they have been consumed.)\n *\n * The consumer side (`length`, `getBuffers`, `consume`, `slice`) mirrors\n * that of `bl`'s `BufferList`.\n */\nclass WritableTrackingBuffer {\n  /**\n   * The size of the chunks a `WritableTrackingBuffer` produces, and the size\n   * from which written buffers are referenced rather than copied.\n   */\n  static readonly CHUNK_SIZE = 8 * 1024;\n\n  /**\n   * The number of bytes appended and not yet consumed.\n   */\n  declare length: number;\n\n  declare private _bufs: Buffer[];\n  declare private _open: Buffer;\n  declare private _pos: number;\n\n  constructor() {\n    this.length = 0;\n    this._bufs = [];\n    this._open = Buffer.allocUnsafe(MIN_CHUNK_SIZE);\n    this._pos = 0;\n  }\n\n  /**\n   * All appended and not yet consumed bytes as a single buffer.\n   *\n   * When everything fits into a single chunk this is a view of that chunk\n   * rather than a copy. The returned buffer must not be modified.\n   */\n  get data(): Buffer {\n    if (this._bufs.length === 0) {\n      return this._open.subarray(0, this._pos);\n    }\n\n    return this.slice();\n  }\n\n  private _seal() {\n    if (this._pos > 0) {\n      this._bufs.push(this._open.subarray(0, this._pos));\n      this._open = Buffer.allocUnsafe(Math.min(this._open.length * 2, WritableTrackingBuffer.CHUNK_SIZE));\n      this._pos = 0;\n    }\n  }\n\n  private _ensure(size: number) {\n    if (this._open.length - this._pos < size) {\n      this._seal();\n\n      if (this._open.length < size) {\n        this._open = Buffer.allocUnsafe(size);\n      }\n    }\n  }\n\n  /**\n   * The chunks holding all appended and not yet consumed bytes.\n   *\n   * The returned array is the list's own: later appends can add chunks to\n   * it. `consume` does not modify it, so taking the chunks and consuming\n   * them right away yields a stable snapshot.\n   */\n  getBuffers(): Buffer[] {\n    this._seal();\n    return this._bufs;\n  }\n\n  /**\n   * Discards the given number of bytes from the front of the list.\n   */\n  consume(bytes: number): this {\n    this._seal();\n\n    const bufs = this._bufs;\n    let i = 0;\n    while (i < bufs.length && bytes >= bufs[i].length) {\n      bytes -= bufs[i].length;\n      this.length -= bufs[i].length;\n      i++;\n    }\n\n    // A fresh array, so that a previously returned `getBuffers()` result\n    // stays intact.\n    this._bufs = bufs.slice(i);\n\n    if (bytes > 0 && this._bufs.length) {\n      this._bufs[0] = this._bufs[0].subarray(bytes);\n      this.length -= bytes;\n    }\n\n    return this;\n  }\n\n  /**\n   * Copies all appended and not yet consumed bytes into a new buffer.\n   */\n  slice(): Buffer {\n    this._seal();\n\n    const result = Buffer.allocUnsafe(this.length);\n    let position = 0;\n    for (const buffer of this._bufs) {\n      position += buffer.copy(result, position);\n    }\n\n    return result;\n  }\n\n  writeUInt8(value: number) {\n    this._ensure(1);\n    this._open.writeUInt8(value, this._pos);\n    this._pos += 1;\n    this.length += 1;\n  }\n\n  writeUInt16LE(value: number) {\n    this._ensure(2);\n    this._open.writeUInt16LE(value, this._pos);\n    this._pos += 2;\n    this.length += 2;\n  }\n\n  writeUShort(value: number) {\n    this.writeUInt16LE(value);\n  }\n\n  writeUInt16BE(value: number) {\n    this._ensure(2);\n    this._open.writeUInt16BE(value, this._pos);\n    this._pos += 2;\n    this.length += 2;\n  }\n\n  writeUInt24LE(value: number) {\n    this._ensure(3);\n    this._open[this._pos + 2] = (value >>> 16) & 0xff;\n    this._open[this._pos + 1] = (value >>> 8) & 0xff;\n    this._open[this._pos] = value & 0xff;\n    this._pos += 3;\n    this.length += 3;\n  }\n\n  writeUInt32LE(value: number) {\n    this._ensure(4);\n    this._open.writeUInt32LE(value, this._pos);\n    this._pos += 4;\n    this.length += 4;\n  }\n\n  writeBigInt64LE(value: bigint) {\n    this._ensure(8);\n    this._open.writeBigInt64LE(value, this._pos);\n    this._pos += 8;\n    this.length += 8;\n  }\n\n  writeInt64LE(value: number) {\n    this.writeBigInt64LE(BigInt(value));\n  }\n\n  writeUInt64LE(value: number) {\n    this.writeBigUInt64LE(BigInt(value));\n  }\n\n  writeBigUInt64LE(value: bigint) {\n    this._ensure(8);\n    this._open.writeBigUInt64LE(value, this._pos);\n    this._pos += 8;\n    this.length += 8;\n  }\n\n  writeUInt32BE(value: number) {\n    this._ensure(4);\n    this._open.writeUInt32BE(value, this._pos);\n    this._pos += 4;\n    this.length += 4;\n  }\n\n  writeUInt40LE(value: number) {\n    // inspired by https://github.com/dpw/node-buffer-more-ints\n    this.writeInt32LE(value & -1);\n    this.writeUInt8(Math.floor(value * SHIFT_RIGHT_32));\n  }\n\n  writeInt8(value: number) {\n    this._ensure(1);\n    this._open.writeInt8(value, this._pos);\n    this._pos += 1;\n    this.length += 1;\n  }\n\n  writeInt16LE(value: number) {\n    this._ensure(2);\n    this._open.writeInt16LE(value, this._pos);\n    this._pos += 2;\n    this.length += 2;\n  }\n\n  writeInt16BE(value: number) {\n    this._ensure(2);\n    this._open.writeInt16BE(value, this._pos);\n    this._pos += 2;\n    this.length += 2;\n  }\n\n  writeInt32LE(value: number) {\n    this._ensure(4);\n    this._open.writeInt32LE(value, this._pos);\n    this._pos += 4;\n    this.length += 4;\n  }\n\n  writeInt32BE(value: number) {\n    this._ensure(4);\n    this._open.writeInt32BE(value, this._pos);\n    this._pos += 4;\n    this.length += 4;\n  }\n\n  writeFloatLE(value: number) {\n    this._ensure(4);\n    this._open.writeFloatLE(value, this._pos);\n    this._pos += 4;\n    this.length += 4;\n  }\n\n  writeDoubleLE(value: number) {\n    this._ensure(8);\n    this._open.writeDoubleLE(value, this._pos);\n    this._pos += 8;\n    this.length += 8;\n  }\n\n  writeString(value: string, encoding: Encoding) {\n    // UCS-2 is two bytes per UTF-16 code unit.\n    const length = encoding === 'ucs2' ? value.length * 2 : Buffer.byteLength(value, encoding);\n    this._ensure(length);\n    this._open.write(value, this._pos, encoding);\n    this._pos += length;\n    this.length += length;\n  }\n\n  writeBVarchar(value: string, encoding: Encoding) {\n    this.writeUInt8(value.length);\n    this.writeString(value, encoding);\n  }\n\n  writeUsVarchar(value: string, encoding: Encoding) {\n    this.writeUInt16LE(value.length);\n    this.writeString(value, encoding);\n  }\n\n  writeUsVarbyte(value: Buffer) {\n    this.writeUInt16LE(value.length);\n    this.writeBuffer(value);\n  }\n\n  /**\n   * Appends a buffer. Buffers of at least `CHUNK_SIZE` bytes are referenced\n   * rather than copied, and must not be modified until consumed.\n   */\n  writeBuffer(value: Buffer) {\n    const length = value.length;\n    if (length >= WritableTrackingBuffer.CHUNK_SIZE) {\n      this._seal();\n      this._bufs.push(value);\n    } else {\n      this._ensure(length);\n      value.copy(this._open, this._pos);\n      this._pos += length;\n    }\n\n    this.length += length;\n  }\n}\n\nexport default WritableTrackingBuffer;\nmodule.exports = WritableTrackingBuffer;\n"],"mappings":"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","ignoreList":[]}