@sythos/js_barcode_universal 1.5.8 → 1.5.10

package/src/js/compactpdf417/encoder.js

@@ -27,59 +27,49 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /** Compact PDF417 (truncated PDF417) encoder. @module compactpdf417/encoder */
-
 import { BitMatrix } from '../core/bit-matrix.js';
 import { EncodeError } from '../core/errors.js';
 import { compactPdf417 } from '../pdf417/compaction.js';
 import { pdf417ErrorCorrection, pdf417EccLength } from '../pdf417/error-correction.js';
 import { pdf417PatternForCodeword } from '../pdf417/tables.js';
-import {
-  COMPACT_PDF417_START,
-  compactPdf417Indicators,
-  compactPdf417Width,
-  validateCompactPdf417Options,
-} from './tables.js';
-
+import { COMPACT_PDF417_START, compactPdf417Indicators, compactPdf417Width, validateCompactPdf417Options, } from './tables.js';
 function appendWidths(matrix, y, x, sequence, height) {
-  let dark = true;
-  for (const digit of sequence) {
-    const width = digit.charCodeAt(0) - 48;
-    if (!Number.isInteger(width) || width < 1 || width > 8) {
-      throw new EncodeError('Compact PDF417: invalid module-width sequence');
+    let dark = true;
+    for (const digit of sequence) {
+        const width = digit.charCodeAt(0) - 48;
+        if (!Number.isInteger(width) || width < 1 || width > 8) {
+            throw new EncodeError('Compact PDF417: invalid module-width sequence');
+        }
+        if (dark)
+            matrix.setRegion(x, y, width, height);
+        x += width;
+        dark = !dark;
     }
-    if (dark) matrix.setRegion(x, y, width, height);
-    x += width;
-    dark = !dark;
-  }
-  return x;
+    return x;
 }
-
 function patternSequence(pattern) {
-  return pattern.toString(2).padStart(17, '0').replace(/0+|1+/g, (run) => String(run.length));
+    return pattern.toString(2).padStart(17, '0').replace(/0+|1+/g, (run) => String(run.length));
 }
-
 function dimensions(needed, level, options, rowHeight) {
-  const ecc = pdf417EccLength(level);
-  let best = null;
-  for (let rows = options.rows ?? 3; rows <= (options.rows ?? 90); rows++) {
-    for (let columns = options.columns ?? 1; columns <= (options.columns ?? 30); columns++) {
-      if (rows * columns > 928 || rows * columns - ecc < needed) continue;
-      const ratio = compactPdf417Width(columns) / (rows * rowHeight);
-      const score = (rows * columns - ecc - needed) * 10 +
-        Math.abs(ratio - (options.aspectRatio ?? 3));
-      if (!best || score < best.score) best = { rows, columns, score };
+    const ecc = pdf417EccLength(level);
+    let best = null;
+    for (let rows = options.rows ?? 3; rows <= (options.rows ?? 90); rows++) {
+        for (let columns = options.columns ?? 1; columns <= (options.columns ?? 30); columns++) {
+            if (rows * columns > 928 || rows * columns - ecc < needed)
+                continue;
+            const ratio = compactPdf417Width(columns) / (rows * rowHeight);
+            const score = (rows * columns - ecc - needed) * 10 +
+                Math.abs(ratio - (options.aspectRatio ?? 3));
+            if (!best || score < best.score)
+                best = { rows, columns, score };
+        }
     }
-  }
-  if (!best) {
-    throw new EncodeError(
-      'Compact PDF417: payload does not fit the requested dimensions and error correction level'
-    );
-  }
-  return best;
+    if (!best) {
+        throw new EncodeError('Compact PDF417: payload does not fit the requested dimensions and error correction level');
+    }
+    return best;
 }
-
 /**
  * Encode Compact PDF417.
  *
@@ -93,48 +83,45 @@ function dimensions(needed, level, options, rowHeight) {
  * @returns {import('../core/bit-matrix.js').BitMatrix}
  */
 export function encodeCompactPDF417(value, options = {}) {
-  const rowHeight = validateCompactPdf417Options(options);
-  const level = options.eccLevel ?? 2;
-  if (!Number.isInteger(level) || level < 0 || level > 8) {
-    throw new EncodeError('Compact PDF417: eccLevel must be an integer in 0..8');
-  }
-
-  const payload = compactPdf417(value, { compaction: options.compaction, charset: options.charset });
-  const { rows, columns } = dimensions(payload.length + 1, level, options, rowHeight);
-  const eccLength = pdf417EccLength(level);
-  const dataLength = rows * columns - eccLength;
-  const data = [dataLength, ...payload];
-  while (data.length < dataLength) data.push(900);
-  const codewords = data.concat(pdf417ErrorCorrection(data, level));
-
-  const matrix = new BitMatrix(compactPdf417Width(columns), rows * rowHeight);
-  for (let row = 0; row < rows; row++) {
-    const y = row * rowHeight;
-    const cluster = (row % 3) * 3;
-    let x = appendWidths(matrix, y, 0, COMPACT_PDF417_START, rowHeight);
-    const left = compactPdf417Indicators(row, rows, columns, level);
-    x = appendWidths(matrix, y, x, patternSequence(pdf417PatternForCodeword(left, cluster)), rowHeight);
-    for (let column = 0; column < columns; column++) {
-      const codeword = codewords[row * columns + column];
-      x = appendWidths(matrix, y, x,
-        patternSequence(pdf417PatternForCodeword(codeword, cluster)), rowHeight);
+    const rowHeight = validateCompactPdf417Options(options);
+    const level = options.eccLevel ?? 2;
+    if (!Number.isInteger(level) || level < 0 || level > 8) {
+        throw new EncodeError('Compact PDF417: eccLevel must be an integer in 0..8');
+    }
+    const payload = compactPdf417(value, { compaction: options.compaction, charset: options.charset });
+    const { rows, columns } = dimensions(payload.length + 1, level, options, rowHeight);
+    const eccLength = pdf417EccLength(level);
+    const dataLength = rows * columns - eccLength;
+    const data = [dataLength, ...payload];
+    while (data.length < dataLength)
+        data.push(900);
+    const codewords = data.concat(pdf417ErrorCorrection(data, level));
+    const matrix = new BitMatrix(compactPdf417Width(columns), rows * rowHeight);
+    for (let row = 0; row < rows; row++) {
+        const y = row * rowHeight;
+        const cluster = (row % 3) * 3;
+        let x = appendWidths(matrix, y, 0, COMPACT_PDF417_START, rowHeight);
+        const left = compactPdf417Indicators(row, rows, columns, level);
+        x = appendWidths(matrix, y, x, patternSequence(pdf417PatternForCodeword(left, cluster)), rowHeight);
+        for (let column = 0; column < columns; column++) {
+            const codeword = codewords[row * columns + column];
+            x = appendWidths(matrix, y, x, patternSequence(pdf417PatternForCodeword(codeword, cluster)), rowHeight);
+        }
+        // Compact PDF417 terminates every row with one dark module, not the normal
+        // right indicator plus 18-module stop pattern.
+        matrix.setRegion(x, y, 1, rowHeight);
+        x++;
+        if (x !== matrix.width)
+            throw new EncodeError('Compact PDF417: internal row width mismatch');
     }
-    // Compact PDF417 terminates every row with one dark module, not the normal
-    // right indicator plus 18-module stop pattern.
-    matrix.setRegion(x, y, 1, rowHeight);
-    x++;
-    if (x !== matrix.width) throw new EncodeError('Compact PDF417: internal row width mismatch');
-  }
-
-  matrix.compactPdf417 = {
-    rows,
-    columns,
-    eccLevel: level,
-    rowHeight,
-    codewords,
-    layout: 'compact',
-  };
-  return matrix;
+    matrix.compactPdf417 = {
+        rows,
+        columns,
+        eccLevel: level,
+        rowHeight,
+        codewords,
+        layout: 'compact',
+    };
+    return matrix;
 }
-
 export { dimensions as compactPdf417Dimensions };

package/src/js/compactpdf417/index.js

@@ -1,17 +1,5 @@
 /* Compact PDF417 public module exports. */
-
-export {
-  COMPACT_PDF417_START,
-  COMPACT_PDF417_START_BITS,
-  COMPACT_PDF417_STOP_MODULES,
-  COMPACT_PDF417_LIMITS,
-  compactPdf417Width,
-  compactPdf417Geometry,
-  compactPdf417Indicators,
-  compactPdf417MatchingLevels,
-  validateCompactPdf417Options,
-  validateCompactPdf417Tables,
-} from './tables.js';
+export { COMPACT_PDF417_START, COMPACT_PDF417_START_BITS, COMPACT_PDF417_STOP_MODULES, COMPACT_PDF417_LIMITS, compactPdf417Width, compactPdf417Geometry, compactPdf417Indicators, compactPdf417MatchingLevels, validateCompactPdf417Options, validateCompactPdf417Tables, } from './tables.js';
 export { encodeCompactPDF417, compactPdf417Dimensions } from './encoder.js';
 export { decodeCompactPDF417 } from './decoder.js';
 export { detectCompactPDF417, detectAndDecodeCompactPDF417 } from './detector.js';

package/src/js/compactpdf417/tables.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Compact (truncated) PDF417 layout.
  *
@@ -40,27 +39,21 @@
  *
  * @module compactpdf417/tables
  */
-
 import { EncodeError } from '../core/errors.js';
-
 /** PDF417 start pattern, in module widths. */
 export const COMPACT_PDF417_START = '81111113';
-
 /** Binary module representation of the start pattern. */
 export const COMPACT_PDF417_START_BITS = '11111111010101000';
-
 /** Compact PDF417's reduced stop is one dark module. */
 export const COMPACT_PDF417_STOP_MODULES = 1;
-
 /** Minimum/maximum number of rows and data columns. */
 export const COMPACT_PDF417_LIMITS = Object.freeze({
-  minRows: 3,
-  maxRows: 90,
-  minColumns: 1,
-  maxColumns: 30,
-  maxCodewords: 928,
+    minRows: 3,
+    maxRows: 90,
+    minColumns: 1,
+    maxColumns: 30,
+    maxCodewords: 928,
 });
-
 /**
  * Return the printed width in modules for a compact symbol.
  *
@@ -68,12 +61,11 @@ export const COMPACT_PDF417_LIMITS = Object.freeze({
  * @param {number} columns
  */
 export function compactPdf417Width(columns) {
-  if (!Number.isInteger(columns) || columns < 1 || columns > 30) {
-    throw new RangeError(`Compact PDF417: columns must be an integer in 1..30, got ${columns}`);
-  }
-  return 35 + columns * 17;
+    if (!Number.isInteger(columns) || columns < 1 || columns > 30) {
+        throw new RangeError(`Compact PDF417: columns must be an integer in 1..30, got ${columns}`);
+    }
+    return 35 + columns * 17;
 }
-
 /**
  * Validate a compact matrix geometry and return its dimensions.
  *
@@ -82,92 +74,91 @@ export function compactPdf417Width(columns) {
  * @param {number} rowHeight
  */
 export function compactPdf417Geometry(width, height, rowHeight = 3) {
-  if (!Number.isInteger(width) || !Number.isInteger(height)) {
-    throw new RangeError('Compact PDF417: matrix dimensions must be integers');
-  }
-  if (!Number.isInteger(rowHeight) || rowHeight < 1) {
-    throw new RangeError('Compact PDF417: rowHeight must be a positive integer');
-  }
-  if ((width - 35) % 17 !== 0) {
-    throw new RangeError(`Compact PDF417: width ${width} does not match the compact layout`);
-  }
-  const columns = (width - 35) / 17;
-  const rows = height / rowHeight;
-  if (!Number.isInteger(rows) || rows < 3 || rows > 90) {
-    throw new RangeError(`Compact PDF417: rows must be an integer in 3..90, got ${rows}`);
-  }
-  if (columns < 1 || columns > 30) {
-    throw new RangeError(`Compact PDF417: columns must be an integer in 1..30, got ${columns}`);
-  }
-  return { rows, columns, rowHeight, width, height };
+    if (!Number.isInteger(width) || !Number.isInteger(height)) {
+        throw new RangeError('Compact PDF417: matrix dimensions must be integers');
+    }
+    if (!Number.isInteger(rowHeight) || rowHeight < 1) {
+        throw new RangeError('Compact PDF417: rowHeight must be a positive integer');
+    }
+    if ((width - 35) % 17 !== 0) {
+        throw new RangeError(`Compact PDF417: width ${width} does not match the compact layout`);
+    }
+    const columns = (width - 35) / 17;
+    const rows = height / rowHeight;
+    if (!Number.isInteger(rows) || rows < 3 || rows > 90) {
+        throw new RangeError(`Compact PDF417: rows must be an integer in 3..90, got ${rows}`);
+    }
+    if (columns < 1 || columns > 30) {
+        throw new RangeError(`Compact PDF417: columns must be an integer in 1..30, got ${columns}`);
+    }
+    return { rows, columns, rowHeight, width, height };
 }
-
 /**
  * Validate encoder dimensions before codeword packing.
  * @param {object} options
  */
 export function validateCompactPdf417Options(options = {}) {
-  const { minRows, maxRows, minColumns, maxColumns } = COMPACT_PDF417_LIMITS;
-  const rowHeight = options.rowHeight ?? 3;
-  if (!Number.isInteger(rowHeight) || rowHeight < 3) {
-    throw new EncodeError('Compact PDF417: rowHeight must be an integer of at least 3');
-  }
-  for (const [name, value, min, max] of [
-    ['rows', options.rows, minRows, maxRows],
-    ['columns', options.columns, minColumns, maxColumns],
-  ]) {
-    if (value !== undefined && (!Number.isInteger(value) || value < min || value > max)) {
-      throw new EncodeError(`Compact PDF417: ${name} must be an integer in ${min}..${max}`);
+    const { minRows, maxRows, minColumns, maxColumns } = COMPACT_PDF417_LIMITS;
+    const rowHeight = options.rowHeight ?? 3;
+    if (!Number.isInteger(rowHeight) || rowHeight < 3) {
+        throw new EncodeError('Compact PDF417: rowHeight must be an integer of at least 3');
+    }
+    for (const [name, value, min, max] of [
+        ['rows', options.rows, minRows, maxRows],
+        ['columns', options.columns, minColumns, maxColumns],
+    ]) {
+        if (value !== undefined && (!Number.isInteger(value) || value < min || value > max)) {
+            throw new EncodeError(`Compact PDF417: ${name} must be an integer in ${min}..${max}`);
+        }
+    }
+    if (options.aspectRatio !== undefined &&
+        (!Number.isFinite(options.aspectRatio) || options.aspectRatio <= 0)) {
+        throw new EncodeError('Compact PDF417: aspectRatio must be positive');
     }
-  }
-  if (options.aspectRatio !== undefined &&
-      (!Number.isFinite(options.aspectRatio) || options.aspectRatio <= 0)) {
-    throw new EncodeError('Compact PDF417: aspectRatio must be positive');
-  }
-  return rowHeight;
+    return rowHeight;
 }
-
 /**
  * The row indicator values used by ordinary PDF417 are retained unchanged.
  * Compact symbols omit only the right indicator, so the left indicator still
  * carries the row group, row count, error-correction level and column count.
  */
 export function compactPdf417Indicators(row, rows, columns, level) {
-  const group = Math.floor(row / 3);
-  const y = Math.floor((rows - 1) / 3);
-  const z = level * 3 + (rows - 1) % 3;
-  const v = columns - 1;
-  if (row % 3 === 0) return 30 * group + y;
-  if (row % 3 === 1) return 30 * group + z;
-  return 30 * group + v;
+    const group = Math.floor(row / 3);
+    const y = Math.floor((rows - 1) / 3);
+    const z = level * 3 + (rows - 1) % 3;
+    const v = columns - 1;
+    if (row % 3 === 0)
+        return 30 * group + y;
+    if (row % 3 === 1)
+        return 30 * group + z;
+    return 30 * group + v;
 }
-
 /**
  * Return all standard ECC levels which agree with the observed left
  * indicators. This is kept as a table helper so decoder and tests share the
  * same compact-layout rule.
  */
 export function compactPdf417MatchingLevels(leftIndicators, rows, columns) {
-  const matches = [];
-  for (let level = 0; level <= 8; level++) {
-    if (leftIndicators.every((value, row) =>
-      value === compactPdf417Indicators(row, rows, columns, level))) matches.push(level);
-  }
-  return matches;
+    const matches = [];
+    for (let level = 0; level <= 8; level++) {
+        if (leftIndicators.every((value, row) => value === compactPdf417Indicators(row, rows, columns, level)))
+            matches.push(level);
+    }
+    return matches;
 }
-
 /** Validate representative layout invariants. */
 export function validateCompactPdf417Tables() {
-  const problems = [];
-  for (const columns of [1, 2, 3, 10, 30]) {
-    const width = compactPdf417Width(columns);
-    if (width !== 35 + columns * 17) problems.push(`columns ${columns}: width mismatch`);
-  }
-  for (const rows of [3, 4, 5, 6, 90]) {
-    const left = Array.from({ length: rows }, (_, row) => compactPdf417Indicators(row, rows, 3, 2));
-    if (compactPdf417MatchingLevels(left, rows, 3).length !== 1) {
-      problems.push(`rows ${rows}: row indicators do not identify one ECC level`);
+    const problems = [];
+    for (const columns of [1, 2, 3, 10, 30]) {
+        const width = compactPdf417Width(columns);
+        if (width !== 35 + columns * 17)
+            problems.push(`columns ${columns}: width mismatch`);
+    }
+    for (const rows of [3, 4, 5, 6, 90]) {
+        const left = Array.from({ length: rows }, (_, row) => compactPdf417Indicators(row, rows, 3, 2));
+        if (compactPdf417MatchingLevels(left, rows, 3).length !== 1) {
+            problems.push(`rows ${rows}: row indicators do not identify one ECC level`);
+        }
     }
-  }
-  return problems;
+    return problems;
 }

package/src/js/core/bit-buffer.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Bit-level writing and reading, MSB-first.
  *
@@ -38,137 +37,122 @@
  *
  * @module core/bit-buffer
  */
-
 import { FormatError } from './errors.js';
-
 /** Growable MSB-first bit writer. */
 export class BitWriter {
-  constructor() {
-    /** @type {number[]} Packed bytes; the last one may be partially filled. */
-    this.bytes = [];
-    this.bitLength = 0;
-  }
-
-  /** @returns {number} Bits written so far. */
-  get length() {
-    return this.bitLength;
-  }
-
-  /**
-   * Append the low `count` bits of `value`, most significant first.
-   *
-   * @param {number} value
-   * @param {number} count
-   */
-  put(value, count) {
-    for (let i = count - 1; i >= 0; i--) {
-      this.putBit(((value >>> i) & 1) === 1);
+    constructor() {
+        /** @type {number[]} Packed bytes; the last one may be partially filled. */
+        this.bytes = [];
+        this.bitLength = 0;
     }
-  }
-
-  /** @param {boolean} bit */
-  putBit(bit) {
-    const idx = this.bitLength >>> 3;
-    if (this.bytes.length <= idx) this.bytes.push(0);
-    if (bit) this.bytes[idx] |= 0x80 >>> (this.bitLength & 7);
-    this.bitLength++;
-  }
-
-  /** @param {ArrayLike<number>} data */
-  putBytes(data) {
-    for (let i = 0; i < data.length; i++) this.put(data[i], 8);
-  }
-
-  /** Pad with zero bits until the length is a multiple of 8. */
-  padToByte() {
-    while (this.bitLength & 7) this.putBit(false);
-  }
-
-  /**
-   * @returns {Uint8Array} Byte view; trailing bits of the final byte are zero.
-   */
-  toBytes() {
-    return Uint8Array.from(this.bytes);
-  }
-
-  /** @returns {string} Debug view, e.g. "0100 0011 0101". */
-  toString() {
-    let s = '';
-    for (let i = 0; i < this.bitLength; i++) {
-      if (i && i % 4 === 0) s += ' ';
-      s += (this.bytes[i >>> 3] >>> (7 - (i & 7))) & 1;
+    /** @returns {number} Bits written so far. */
+    get length() {
+        return this.bitLength;
+    }
+    /**
+     * Append the low `count` bits of `value`, most significant first.
+     *
+     * @param {number} value
+     * @param {number} count
+     */
+    put(value, count) {
+        for (let i = count - 1; i >= 0; i--) {
+            this.putBit(((value >>> i) & 1) === 1);
+        }
+    }
+    /** @param {boolean} bit */
+    putBit(bit) {
+        const idx = this.bitLength >>> 3;
+        if (this.bytes.length <= idx)
+            this.bytes.push(0);
+        if (bit)
+            this.bytes[idx] |= 0x80 >>> (this.bitLength & 7);
+        this.bitLength++;
+    }
+    /** @param {ArrayLike<number>} data */
+    putBytes(data) {
+        for (let i = 0; i < data.length; i++)
+            this.put(data[i], 8);
+    }
+    /** Pad with zero bits until the length is a multiple of 8. */
+    padToByte() {
+        while (this.bitLength & 7)
+            this.putBit(false);
+    }
+    /**
+     * @returns {Uint8Array} Byte view; trailing bits of the final byte are zero.
+     */
+    toBytes() {
+        return Uint8Array.from(this.bytes);
+    }
+    /** @returns {string} Debug view, e.g. "0100 0011 0101". */
+    toString() {
+        let s = '';
+        for (let i = 0; i < this.bitLength; i++) {
+            if (i && i % 4 === 0)
+                s += ' ';
+            s += (this.bytes[i >>> 3] >>> (7 - (i & 7))) & 1;
+        }
+        return s;
     }
-    return s;
-  }
 }
-
 /** MSB-first bit reader over a byte array. */
 export class BitReader {
-  /** @param {ArrayLike<number>} bytes */
-  constructor(bytes) {
-    this.bytes = bytes;
-    this.byteOffset = 0;
-    this.bitOffset = 0;
-  }
-
-  /** @returns {number} Bits not yet consumed. */
-  available() {
-    return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset;
-  }
-
-  /**
-   * Read `count` bits (1..32) as an unsigned integer, most significant first.
-   *
-   * @param {number} count
-   * @returns {number}
-   * @throws {FormatError} If the stream is exhausted.
-   */
-  read(count) {
-    if (count < 1 || count > 32) {
-      throw new FormatError(`BitReader: cannot read ${count} bits`);
-    }
-    if (count > this.available()) {
-      throw new FormatError(
-        `BitReader: needed ${count} bits, ${this.available()} remain`
-      );
-    }
-
-    let result = 0;
-    let remaining = count;
-
-    // Finish the partially consumed byte first, then take whole bytes.
-    if (this.bitOffset > 0) {
-      const inCurrent = 8 - this.bitOffset;
-      const take = Math.min(remaining, inCurrent);
-      const shift = inCurrent - take;
-      const mask = (0xff >> this.bitOffset) & ~((1 << shift) - 1);
-      result = (this.bytes[this.byteOffset] & mask) >> shift;
-      remaining -= take;
-      this.bitOffset += take;
-      if (this.bitOffset === 8) {
+    /** @param {ArrayLike<number>} bytes */
+    constructor(bytes) {
+        this.bytes = bytes;
+        this.byteOffset = 0;
         this.bitOffset = 0;
-        this.byteOffset++;
-      }
     }
-
-    while (remaining >= 8) {
-      result = (result << 8) | (this.bytes[this.byteOffset] & 0xff);
-      this.byteOffset++;
-      remaining -= 8;
+    /** @returns {number} Bits not yet consumed. */
+    available() {
+        return 8 * (this.bytes.length - this.byteOffset) - this.bitOffset;
+    }
+    /**
+     * Read `count` bits (1..32) as an unsigned integer, most significant first.
+     *
+     * @param {number} count
+     * @returns {number}
+     * @throws {FormatError} If the stream is exhausted.
+     */
+    read(count) {
+        if (count < 1 || count > 32) {
+            throw new FormatError(`BitReader: cannot read ${count} bits`);
+        }
+        if (count > this.available()) {
+            throw new FormatError(`BitReader: needed ${count} bits, ${this.available()} remain`);
+        }
+        let result = 0;
+        let remaining = count;
+        // Finish the partially consumed byte first, then take whole bytes.
+        if (this.bitOffset > 0) {
+            const inCurrent = 8 - this.bitOffset;
+            const take = Math.min(remaining, inCurrent);
+            const shift = inCurrent - take;
+            const mask = (0xff >> this.bitOffset) & ~((1 << shift) - 1);
+            result = (this.bytes[this.byteOffset] & mask) >> shift;
+            remaining -= take;
+            this.bitOffset += take;
+            if (this.bitOffset === 8) {
+                this.bitOffset = 0;
+                this.byteOffset++;
+            }
+        }
+        while (remaining >= 8) {
+            result = (result << 8) | (this.bytes[this.byteOffset] & 0xff);
+            this.byteOffset++;
+            remaining -= 8;
+        }
+        if (remaining > 0) {
+            const shift = 8 - remaining;
+            const mask = ~((1 << shift) - 1) & 0xff;
+            result = (result << remaining) | ((this.bytes[this.byteOffset] & mask) >> shift);
+            this.bitOffset += remaining;
+        }
+        return result >>> 0;
     }
-
-    if (remaining > 0) {
-      const shift = 8 - remaining;
-      const mask = ~((1 << shift) - 1) & 0xff;
-      result = (result << remaining) | ((this.bytes[this.byteOffset] & mask) >> shift);
-      this.bitOffset += remaining;
+    /** @returns {boolean} */
+    readBit() {
+        return this.read(1) === 1;
     }
-
-    return result >>> 0;
-  }
-
-  /** @returns {boolean} */
-  readBit() {
-    return this.read(1) === 1;
-  }
 }