tiny-essentials 1.29.0 → 1.29.2

package/dist/v1/libs/html/loader/utils/TinyBufferReader.cjs

@@ -0,0 +1,277 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * @fileoverview Bounds-checked binary cursor shared by every media probe.
+ * Every read either returns the requested value or throws {@link TinyNeedMoreData},
+ * which is what makes the incremental parsing possible: the probe catches the
+ * sentinel, keeps the buffered bytes and retries once the next chunk arrives.
+ */
+
+/**
+ * Signals that the buffer does not hold enough bytes to satisfy a read.
+ * It is a control-flow signal, not a failure.
+ * @augments Error
+ */
+class TinyNeedMoreData extends Error {
+  /**
+   * Exception thrown when the current buffer does not contain enough bytes to fulfill a read request.
+   * @param {string} [message] - The error message.
+   */
+  constructor(message = 'The buffer does not hold enough bytes to satisfy the read.') {
+    super(message);
+    this.name = 'TinyNeedMoreData';
+  }
+}
+
+/**
+ * A forward-only, bounds-checked cursor over a {@link Uint8Array}.
+ */
+class TinyBufferReader {
+  /** @type {Uint8Array} */
+  #bytes;
+  /** @type {DataView} */
+  #view;
+  /** @type {number} */
+  #offset;
+  /** @type {number} */
+  #limit;
+
+  /**
+   * Initializes a new bounds-checked binary reader.
+   * @param {Uint8Array} bytes - The backing buffer.
+   * @param {number} [offset] - The first readable byte.
+   * @param {number} [limit] - The byte after the last readable byte.
+   * @throws {TypeError} If `bytes` is not a Uint8Array.
+   * @throws {RangeError} If `offset` or `limit` is out of bounds.
+   */
+  constructor(bytes, offset = 0, limit = bytes.length) {
+    if (!(bytes instanceof Uint8Array)) {
+      throw new TypeError('The "bytes" argument must be a Uint8Array.');
+    }
+    if (!Number.isInteger(offset) || offset < 0 || offset > bytes.length) {
+      throw new RangeError('The "offset" argument is out of bounds.');
+    }
+    if (!Number.isInteger(limit) || limit < offset || limit > bytes.length) {
+      throw new RangeError('The "limit" argument is out of bounds.');
+    }
+    this.#bytes = bytes;
+    this.#view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    this.#offset = offset;
+    this.#limit = limit;
+  }
+
+  /** @returns {number} The absolute cursor position. */
+  get offset() {
+    return this.#offset;
+  }
+
+  /** @returns {number} The byte after the last readable byte. */
+  get limit() {
+    return this.#limit;
+  }
+
+  /** @returns {number} The number of readable bytes left. */
+  get remaining() {
+    return this.#limit - this.#offset;
+  }
+
+  /** @returns {boolean} True when the cursor reached the limit. */
+  get eof() {
+    return this.#offset >= this.#limit;
+  }
+
+  /** @returns {Uint8Array} The full backing buffer. */
+  get buffer() {
+    return this.#bytes;
+  }
+
+  /**
+   * Checks if the buffer contains at least the specified number of readable bytes.
+   * @param {number} count - The number of bytes to test.
+   * @returns {boolean} True when at least `count` bytes are readable.
+   * @throws {TypeError} If `count` is not an integer.
+   */
+  has(count) {
+    if (!Number.isInteger(count)) {
+      throw new TypeError('The "count" argument must be an integer.');
+    }
+    return count >= 0 && this.#offset + count <= this.#limit;
+  }
+
+  /**
+   * Validates that the buffer has enough bytes to satisfy a read.
+   * Throws {@link TinyNeedMoreData} if the requested count exceeds the remaining bytes.
+   * @param {number} count - The number of bytes required.
+   * @returns {void}
+   * @throws {TypeError} If `count` is not an integer.
+   * @throws {RangeError} If `count` is negative.
+   * @throws {TinyNeedMoreData} If fewer than `count` bytes are readable.
+   */
+  #require(count) {
+    if (!Number.isInteger(count)) {
+      throw new TypeError('The "count" argument must be an integer.');
+    }
+    if (count < 0) {
+      throw new RangeError('The "count" argument must be a non-negative integer.');
+    }
+    if (!this.has(count)) {
+      throw new TinyNeedMoreData();
+    }
+  }
+
+  /**
+   * Moves the cursor to an absolute position in the buffer.
+   * @param {number} position - The absolute position to move to.
+   * @returns {TinyBufferReader} The current instance for chaining.
+   * @throws {RangeError} If `position` is not a positive integer.
+   */
+  seek(position) {
+    if (!Number.isInteger(position) || position < 0) {
+      throw new RangeError('The "position" argument must be a positive integer.');
+    }
+    this.#offset = position;
+    return this;
+  }
+
+  /**
+   * Skips a specified number of bytes in the buffer.
+   * @param {number} count - The number of bytes to skip.
+   * @returns {TinyBufferReader} The current instance for chaining.
+   * @throws {TinyNeedMoreData} If fewer than `count` bytes are readable.
+   */
+  skip(count) {
+    if (!Number.isInteger(count) || count < 0) {
+      throw new RangeError('The "count" argument must be a non-negative integer.');
+    }
+    this.#require(count);
+    this.#offset += count;
+    return this;
+  }
+
+  /**
+   * Reads the next unsigned 8-bit integer.
+   * @returns {number} The next unsigned 8-bit integer.
+   */
+  uint8() {
+    this.#require(1);
+    return this.#view.getUint8(this.#offset++);
+  }
+
+  /**
+   * Reads the next unsigned 16-bit big-endian integer.
+   * @returns {number} The next unsigned 16-bit big-endian integer.
+   */
+  uint16() {
+    this.#require(2);
+    const value = this.#view.getUint16(this.#offset);
+    this.#offset += 2;
+    return value;
+  }
+
+  /**
+   * Reads the next unsigned 16-bit little-endian integer.
+   * @returns {number} The next unsigned 16-bit little-endian integer.
+   */
+  uint16le() {
+    this.#require(2);
+    const value = this.#view.getUint16(this.#offset, true);
+    this.#offset += 2;
+    return value;
+  }
+
+  /**
+   * Reads the next unsigned 24-bit big-endian integer.
+   * @returns {number} The next unsigned 24-bit big-endian integer.
+   */
+  uint24() {
+    this.#require(3);
+    const value =
+      (this.#bytes[this.#offset] << 16) |
+      (this.#bytes[this.#offset + 1] << 8) |
+      this.#bytes[this.#offset + 2];
+    this.#offset += 3;
+    return value;
+  }
+
+  /**
+   * Reads the next unsigned 32-bit big-endian integer.
+   * @returns {number} The next unsigned 32-bit big-endian integer.
+   */
+  uint32() {
+    this.#require(4);
+    const value = this.#view.getUint32(this.#offset);
+    this.#offset += 4;
+    return value;
+  }
+
+  /**
+   * Reads the next unsigned 32-bit little-endian integer.
+   * @returns {number} The next unsigned 32-bit little-endian integer.
+   */
+  uint32le() {
+    this.#require(4);
+    const value = this.#view.getUint32(this.#offset, true);
+    this.#offset += 4;
+    return value;
+  }
+
+  /**
+   * Reads the next signed 32-bit little-endian integer.
+   * @returns {number} The next signed 32-bit little-endian integer.
+   */
+  int32le() {
+    this.#require(4);
+    const value = this.#view.getInt32(this.#offset, true);
+    this.#offset += 4;
+    return value;
+  }
+
+  /**
+   * Reads an unsigned 64-bit big-endian integer as a Number. Values above 2^53
+   * lose precision, which is acceptable for the box sizes and offsets we read.
+   * @returns {number} The decoded value.
+   */
+  uint64() {
+    const high = this.uint32();
+    const low = this.uint32();
+    return high * 0x100000000 + low;
+  }
+
+  /**
+   * Reads a fixed-length string using Latin-1 encoding.
+   * @param {number} length - The number of bytes to read.
+   * @returns {string} The decoded Latin-1 string.
+   */
+  ascii(length) {
+    if (!Number.isInteger(length) || length < 0) {
+      throw new RangeError('The "length" argument must be a non-negative integer.');
+    }
+    this.#require(length);
+    let value = '';
+    for (let i = 0; i < length; i += 1) {
+      value += String.fromCharCode(this.#bytes[this.#offset + i]);
+    }
+    this.#offset += length;
+    return value;
+  }
+
+  /**
+   * Extracts a view over a specified range of bytes from the buffer.
+   * @param {number} length - The number of bytes to read.
+   * @returns {Uint8Array} A view over the requested bytes.
+   */
+  bytes(length) {
+    if (!Number.isInteger(length) || length < 0) {
+      throw new RangeError('The "length" argument must be a non-negative integer.');
+    }
+    this.#require(length);
+    const slice = this.#bytes.subarray(this.#offset, this.#offset + length);
+    this.#offset += length;
+    return slice;
+  }
+}
+
+exports.TinyNeedMoreData = TinyNeedMoreData;
+exports.default = TinyBufferReader;

package/dist/v1/libs/html/loader/utils/TinyBufferReader.d.mts

@@ -0,0 +1,118 @@
+/**
+ * @fileoverview Bounds-checked binary cursor shared by every media probe.
+ * Every read either returns the requested value or throws {@link TinyNeedMoreData},
+ * which is what makes the incremental parsing possible: the probe catches the
+ * sentinel, keeps the buffered bytes and retries once the next chunk arrives.
+ */
+/**
+ * Signals that the buffer does not hold enough bytes to satisfy a read.
+ * It is a control-flow signal, not a failure.
+ * @augments Error
+ */
+export declare class TinyNeedMoreData extends Error {
+    /**
+     * Exception thrown when the current buffer does not contain enough bytes to fulfill a read request.
+     * @param {string} [message] - The error message.
+     */
+    constructor(message?: string);
+}
+/**
+ * A forward-only, bounds-checked cursor over a {@link Uint8Array}.
+ */
+export default class TinyBufferReader {
+    #private;
+    /**
+     * Initializes a new bounds-checked binary reader.
+     * @param {Uint8Array} bytes - The backing buffer.
+     * @param {number} [offset] - The first readable byte.
+     * @param {number} [limit] - The byte after the last readable byte.
+     * @throws {TypeError} If `bytes` is not a Uint8Array.
+     * @throws {RangeError} If `offset` or `limit` is out of bounds.
+     */
+    constructor(bytes: Uint8Array, offset?: number, limit?: number);
+    /** @returns {number} The absolute cursor position. */
+    get offset(): number;
+    /** @returns {number} The byte after the last readable byte. */
+    get limit(): number;
+    /** @returns {number} The number of readable bytes left. */
+    get remaining(): number;
+    /** @returns {boolean} True when the cursor reached the limit. */
+    get eof(): boolean;
+    /** @returns {Uint8Array} The full backing buffer. */
+    get buffer(): Uint8Array;
+    /**
+     * Checks if the buffer contains at least the specified number of readable bytes.
+     * @param {number} count - The number of bytes to test.
+     * @returns {boolean} True when at least `count` bytes are readable.
+     * @throws {TypeError} If `count` is not an integer.
+     */
+    has(count: number): boolean;
+    /**
+     * Moves the cursor to an absolute position in the buffer.
+     * @param {number} position - The absolute position to move to.
+     * @returns {TinyBufferReader} The current instance for chaining.
+     * @throws {RangeError} If `position` is not a positive integer.
+     */
+    seek(position: number): TinyBufferReader;
+    /**
+     * Skips a specified number of bytes in the buffer.
+     * @param {number} count - The number of bytes to skip.
+     * @returns {TinyBufferReader} The current instance for chaining.
+     * @throws {TinyNeedMoreData} If fewer than `count` bytes are readable.
+     */
+    skip(count: number): TinyBufferReader;
+    /**
+     * Reads the next unsigned 8-bit integer.
+     * @returns {number} The next unsigned 8-bit integer.
+     */
+    uint8(): number;
+    /**
+     * Reads the next unsigned 16-bit big-endian integer.
+     * @returns {number} The next unsigned 16-bit big-endian integer.
+     */
+    uint16(): number;
+    /**
+     * Reads the next unsigned 16-bit little-endian integer.
+     * @returns {number} The next unsigned 16-bit little-endian integer.
+     */
+    uint16le(): number;
+    /**
+     * Reads the next unsigned 24-bit big-endian integer.
+     * @returns {number} The next unsigned 24-bit big-endian integer.
+     */
+    uint24(): number;
+    /**
+     * Reads the next unsigned 32-bit big-endian integer.
+     * @returns {number} The next unsigned 32-bit big-endian integer.
+     */
+    uint32(): number;
+    /**
+     * Reads the next unsigned 32-bit little-endian integer.
+     * @returns {number} The next unsigned 32-bit little-endian integer.
+     */
+    uint32le(): number;
+    /**
+     * Reads the next signed 32-bit little-endian integer.
+     * @returns {number} The next signed 32-bit little-endian integer.
+     */
+    int32le(): number;
+    /**
+     * Reads an unsigned 64-bit big-endian integer as a Number. Values above 2^53
+     * lose precision, which is acceptable for the box sizes and offsets we read.
+     * @returns {number} The decoded value.
+     */
+    uint64(): number;
+    /**
+     * Reads a fixed-length string using Latin-1 encoding.
+     * @param {number} length - The number of bytes to read.
+     * @returns {string} The decoded Latin-1 string.
+     */
+    ascii(length: number): string;
+    /**
+     * Extracts a view over a specified range of bytes from the buffer.
+     * @param {number} length - The number of bytes to read.
+     * @returns {Uint8Array} A view over the requested bytes.
+     */
+    bytes(length: number): Uint8Array;
+}
+//# sourceMappingURL=TinyBufferReader.d.mts.map

package/dist/v1/libs/html/loader/utils/TinyBufferReader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TinyBufferReader.d.mts","sourceRoot":"","sources":["../../../../../../src/v1/libs/html/loader/utils/TinyBufferReader.mjs"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC;;;OAGG;IACH,YAAY,OAAO,AAFhB,CACF,EADU,MAEuE,EAGjF;CACF;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,gBAAgB;;IAUnC;;;;;;;OAOG;IACH,YAAY,KAAK,EANN,UAMM,EAAE,MAAM,AALtB,CACA,EADQ,MAKkB,EAAE,KAAK,AAJjC,CACA,EADQ,MAIwC,EAclD;IAED,sDAAsD;IACtD,IAAI,MAAM,IADI,MAAM,CAGnB;IAED,+DAA+D;IAC/D,IAAI,KAAK,IADK,MAAM,CAGnB;IAED,2DAA2D;IAC3D,IAAI,SAAS,IADC,MAAM,CAGnB;IAED,iEAAiE;IACjE,IAAI,GAAG,IADO,OAAO,CAGpB;IAED,qDAAqD;IACrD,IAAI,MAAM,IADI,UAAU,CAGvB;IAED;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAJE,MAIF,GAHI,OAAO,CAQnB;IAuBD;;;;;OAKG;IACH,IAAI,CAAC,QAAQ,EAJF,MAIE,GAHA,gBAAgB,CAS5B;IAED;;;;;OAKG;IACH,IAAI,CAAC,KAAK,EAJC,MAID,GAHG,gBAAgB,CAU5B;IAED;;;OAGG;IACH,KAAK,IAFQ,MAAM,CAKlB;IAED;;;OAGG;IACH,MAAM,IAFO,MAAM,CAOlB;IAED;;;OAGG;IACH,QAAQ,IAFK,MAAM,CAOlB;IAED;;;OAGG;IACH,MAAM,IAFO,MAAM,CAUlB;IAED;;;OAGG;IACH,MAAM,IAFO,MAAM,CAOlB;IAED;;;OAGG;IACH,QAAQ,IAFK,MAAM,CAOlB;IAED;;;OAGG;IACH,OAAO,IAFM,MAAM,CAOlB;IAED;;;;OAIG;IACH,MAAM,IAFO,MAAM,CAMlB;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAHD,MAGC,GAFC,MAAM,CAalB;IAED;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAHD,MAGC,GAFC,UAAU,CAUtB;CACF"}

package/dist/v1/libs/html/loader/utils/TinyBufferReader.mjs

@@ -0,0 +1,247 @@
+/**
+ * @fileoverview Bounds-checked binary cursor shared by every media probe.
+ * Every read either returns the requested value or throws {@link TinyNeedMoreData},
+ * which is what makes the incremental parsing possible: the probe catches the
+ * sentinel, keeps the buffered bytes and retries once the next chunk arrives.
+ */
+/**
+ * Signals that the buffer does not hold enough bytes to satisfy a read.
+ * It is a control-flow signal, not a failure.
+ * @augments Error
+ */
+export class TinyNeedMoreData extends Error {
+    /**
+     * Exception thrown when the current buffer does not contain enough bytes to fulfill a read request.
+     * @param {string} [message] - The error message.
+     */
+    constructor(message = 'The buffer does not hold enough bytes to satisfy the read.') {
+        super(message);
+        this.name = 'TinyNeedMoreData';
+    }
+}
+/**
+ * A forward-only, bounds-checked cursor over a {@link Uint8Array}.
+ */
+export default class TinyBufferReader {
+    /** @type {Uint8Array} */
+    #bytes;
+    /** @type {DataView} */
+    #view;
+    /** @type {number} */
+    #offset;
+    /** @type {number} */
+    #limit;
+    /**
+     * Initializes a new bounds-checked binary reader.
+     * @param {Uint8Array} bytes - The backing buffer.
+     * @param {number} [offset] - The first readable byte.
+     * @param {number} [limit] - The byte after the last readable byte.
+     * @throws {TypeError} If `bytes` is not a Uint8Array.
+     * @throws {RangeError} If `offset` or `limit` is out of bounds.
+     */
+    constructor(bytes, offset = 0, limit = bytes.length) {
+        if (!(bytes instanceof Uint8Array)) {
+            throw new TypeError('The "bytes" argument must be a Uint8Array.');
+        }
+        if (!Number.isInteger(offset) || offset < 0 || offset > bytes.length) {
+            throw new RangeError('The "offset" argument is out of bounds.');
+        }
+        if (!Number.isInteger(limit) || limit < offset || limit > bytes.length) {
+            throw new RangeError('The "limit" argument is out of bounds.');
+        }
+        this.#bytes = bytes;
+        this.#view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        this.#offset = offset;
+        this.#limit = limit;
+    }
+    /** @returns {number} The absolute cursor position. */
+    get offset() {
+        return this.#offset;
+    }
+    /** @returns {number} The byte after the last readable byte. */
+    get limit() {
+        return this.#limit;
+    }
+    /** @returns {number} The number of readable bytes left. */
+    get remaining() {
+        return this.#limit - this.#offset;
+    }
+    /** @returns {boolean} True when the cursor reached the limit. */
+    get eof() {
+        return this.#offset >= this.#limit;
+    }
+    /** @returns {Uint8Array} The full backing buffer. */
+    get buffer() {
+        return this.#bytes;
+    }
+    /**
+     * Checks if the buffer contains at least the specified number of readable bytes.
+     * @param {number} count - The number of bytes to test.
+     * @returns {boolean} True when at least `count` bytes are readable.
+     * @throws {TypeError} If `count` is not an integer.
+     */
+    has(count) {
+        if (!Number.isInteger(count)) {
+            throw new TypeError('The "count" argument must be an integer.');
+        }
+        return count >= 0 && this.#offset + count <= this.#limit;
+    }
+    /**
+     * Validates that the buffer has enough bytes to satisfy a read.
+     * Throws {@link TinyNeedMoreData} if the requested count exceeds the remaining bytes.
+     * @param {number} count - The number of bytes required.
+     * @returns {void}
+     * @throws {TypeError} If `count` is not an integer.
+     * @throws {RangeError} If `count` is negative.
+     * @throws {TinyNeedMoreData} If fewer than `count` bytes are readable.
+     */
+    #require(count) {
+        if (!Number.isInteger(count)) {
+            throw new TypeError('The "count" argument must be an integer.');
+        }
+        if (count < 0) {
+            throw new RangeError('The "count" argument must be a non-negative integer.');
+        }
+        if (!this.has(count)) {
+            throw new TinyNeedMoreData();
+        }
+    }
+    /**
+     * Moves the cursor to an absolute position in the buffer.
+     * @param {number} position - The absolute position to move to.
+     * @returns {TinyBufferReader} The current instance for chaining.
+     * @throws {RangeError} If `position` is not a positive integer.
+     */
+    seek(position) {
+        if (!Number.isInteger(position) || position < 0) {
+            throw new RangeError('The "position" argument must be a positive integer.');
+        }
+        this.#offset = position;
+        return this;
+    }
+    /**
+     * Skips a specified number of bytes in the buffer.
+     * @param {number} count - The number of bytes to skip.
+     * @returns {TinyBufferReader} The current instance for chaining.
+     * @throws {TinyNeedMoreData} If fewer than `count` bytes are readable.
+     */
+    skip(count) {
+        if (!Number.isInteger(count) || count < 0) {
+            throw new RangeError('The "count" argument must be a non-negative integer.');
+        }
+        this.#require(count);
+        this.#offset += count;
+        return this;
+    }
+    /**
+     * Reads the next unsigned 8-bit integer.
+     * @returns {number} The next unsigned 8-bit integer.
+     */
+    uint8() {
+        this.#require(1);
+        return this.#view.getUint8(this.#offset++);
+    }
+    /**
+     * Reads the next unsigned 16-bit big-endian integer.
+     * @returns {number} The next unsigned 16-bit big-endian integer.
+     */
+    uint16() {
+        this.#require(2);
+        const value = this.#view.getUint16(this.#offset);
+        this.#offset += 2;
+        return value;
+    }
+    /**
+     * Reads the next unsigned 16-bit little-endian integer.
+     * @returns {number} The next unsigned 16-bit little-endian integer.
+     */
+    uint16le() {
+        this.#require(2);
+        const value = this.#view.getUint16(this.#offset, true);
+        this.#offset += 2;
+        return value;
+    }
+    /**
+     * Reads the next unsigned 24-bit big-endian integer.
+     * @returns {number} The next unsigned 24-bit big-endian integer.
+     */
+    uint24() {
+        this.#require(3);
+        const value = (this.#bytes[this.#offset] << 16) |
+            (this.#bytes[this.#offset + 1] << 8) |
+            this.#bytes[this.#offset + 2];
+        this.#offset += 3;
+        return value;
+    }
+    /**
+     * Reads the next unsigned 32-bit big-endian integer.
+     * @returns {number} The next unsigned 32-bit big-endian integer.
+     */
+    uint32() {
+        this.#require(4);
+        const value = this.#view.getUint32(this.#offset);
+        this.#offset += 4;
+        return value;
+    }
+    /**
+     * Reads the next unsigned 32-bit little-endian integer.
+     * @returns {number} The next unsigned 32-bit little-endian integer.
+     */
+    uint32le() {
+        this.#require(4);
+        const value = this.#view.getUint32(this.#offset, true);
+        this.#offset += 4;
+        return value;
+    }
+    /**
+     * Reads the next signed 32-bit little-endian integer.
+     * @returns {number} The next signed 32-bit little-endian integer.
+     */
+    int32le() {
+        this.#require(4);
+        const value = this.#view.getInt32(this.#offset, true);
+        this.#offset += 4;
+        return value;
+    }
+    /**
+     * Reads an unsigned 64-bit big-endian integer as a Number. Values above 2^53
+     * lose precision, which is acceptable for the box sizes and offsets we read.
+     * @returns {number} The decoded value.
+     */
+    uint64() {
+        const high = this.uint32();
+        const low = this.uint32();
+        return high * 0x100000000 + low;
+    }
+    /**
+     * Reads a fixed-length string using Latin-1 encoding.
+     * @param {number} length - The number of bytes to read.
+     * @returns {string} The decoded Latin-1 string.
+     */
+    ascii(length) {
+        if (!Number.isInteger(length) || length < 0) {
+            throw new RangeError('The "length" argument must be a non-negative integer.');
+        }
+        this.#require(length);
+        let value = '';
+        for (let i = 0; i < length; i += 1) {
+            value += String.fromCharCode(this.#bytes[this.#offset + i]);
+        }
+        this.#offset += length;
+        return value;
+    }
+    /**
+     * Extracts a view over a specified range of bytes from the buffer.
+     * @param {number} length - The number of bytes to read.
+     * @returns {Uint8Array} A view over the requested bytes.
+     */
+    bytes(length) {
+        if (!Number.isInteger(length) || length < 0) {
+            throw new RangeError('The "length" argument must be a non-negative integer.');
+        }
+        this.#require(length);
+        const slice = this.#bytes.subarray(this.#offset, this.#offset + length);
+        this.#offset += length;
+        return slice;
+    }
+}