@fuman/io 0.0.1

package/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2024 alina sireneva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

package/_utils.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function nextPowerOfTwo(n) {
+  n--;
+  n |= n >> 1;
+  n |= n >> 2;
+  n |= n >> 4;
+  n |= n >> 8;
+  n |= n >> 16;
+  return n + 1;
+}
+const dvCache = /* @__PURE__ */ new WeakMap();
+function getDv(buffer) {
+  const ab = buffer.buffer;
+  let dv = dvCache.get(ab);
+  if (!dv) {
+    dv = new DataView(ab);
+    dvCache.set(ab, dv);
+  }
+  return dv;
+}
+exports.getDv = getDv;
+exports.nextPowerOfTwo = nextPowerOfTwo;

package/_utils.d.ts

@@ -0,0 +1,2 @@
+export declare function nextPowerOfTwo(n: number): number;
+export declare function getDv(buffer: Uint8Array): DataView;

package/_utils.js

@@ -0,0 +1,23 @@
+function nextPowerOfTwo(n) {
+  n--;
+  n |= n >> 1;
+  n |= n >> 2;
+  n |= n >> 4;
+  n |= n >> 8;
+  n |= n >> 16;
+  return n + 1;
+}
+const dvCache = /* @__PURE__ */ new WeakMap();
+function getDv(buffer) {
+  const ab = buffer.buffer;
+  let dv = dvCache.get(ab);
+  if (!dv) {
+    dv = new DataView(ab);
+    dvCache.set(ab, dv);
+  }
+  return dv;
+}
+export {
+  getDv,
+  nextPowerOfTwo
+};

package/bits/index.d.ts

@@ -0,0 +1,2 @@
+export * from './reader.js';
+export * from './utils.js';

package/bits/reader.cjs

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const strings = require("../read/strings.cjs");
+class BitReader {
+  #readable;
+  #currentByte = 0;
+  #currentBitIdx = 0;
+  constructor(readable) {
+    this.#readable = readable;
+  }
+  /** Whether the reader is currently aligned on a byte boundary */
+  get isAligned() {
+    return this.#currentBitIdx === 0;
+  }
+  /** Skip any remaining bits in the current byte. No-op if already aligned */
+  align() {
+    this.#currentBitIdx = 0;
+  }
+  /** The current bit position within the last consumed byte */
+  get bitPosition() {
+    return this.#currentBitIdx;
+  }
+  readSync(bytes) {
+    if (this.#currentBitIdx === 0) {
+      return this.#readable.readSync(bytes);
+    }
+    if (bytes === 1) {
+      return utils.u8.allocWith([this.readBits(8)]);
+    }
+    const bit = this.#currentBitIdx;
+    const nbit = 8 - bit;
+    const mask1 = (1 << nbit) - 1;
+    const result = utils.u8.alloc(bytes);
+    const tmp = this.#readable.readSync(bytes);
+    for (let i = 0; i < bytes; i++) {
+      const byte1 = this.#currentByte;
+      const byte2 = tmp[i];
+      result[i] = (byte1 & mask1) << bit | byte2 >> nbit;
+      this.#currentByte = byte2;
+    }
+    return result;
+  }
+  readBits(size) {
+    let result = 0;
+    if (this.#currentBitIdx !== 0) {
+      const bitsLeft = 8 - this.#currentBitIdx;
+      if (size <= bitsLeft) {
+        result = this.#currentByte & (1 << size) - 1;
+        this.#currentBitIdx += size;
+        if (this.#currentBitIdx === 8) {
+          this.#currentBitIdx = 0;
+        }
+        return result;
+      }
+      result = this.#currentByte & (1 << bitsLeft) - 1;
+      size -= bitsLeft;
+      this.#currentBitIdx = 0;
+    }
+    const bytes = Math.ceil(size / 8);
+    const data = strings.exactly(this.#readable, bytes);
+    let byteIdx = 0;
+    while (size >= 8) {
+      result = result << 8 | data[byteIdx++];
+      size -= 8;
+    }
+    if (size > 0) {
+      this.#currentByte = data[byteIdx];
+      this.#currentBitIdx = size;
+      result = result << size | this.#currentByte >> 8 - size;
+    }
+    return result;
+  }
+  readBitsBig(size) {
+    let result = 0n;
+    if (this.#currentBitIdx !== 0) {
+      const bitsLeft = 8 - this.#currentBitIdx;
+      if (size <= bitsLeft) {
+        result = BigInt(this.#currentByte) & (1n << BigInt(size)) - 1n;
+        this.#currentBitIdx += Number(size);
+        if (this.#currentBitIdx === 8) {
+          this.#currentBitIdx = 0;
+        }
+        return result;
+      }
+      result = BigInt(this.#currentByte) & (1n << BigInt(bitsLeft)) - 1n;
+      size -= bitsLeft;
+      this.#currentBitIdx = 0;
+    }
+    const bytes = Math.ceil(size / 8);
+    const data = strings.exactly(this.#readable, bytes);
+    let sizeBig = BigInt(size);
+    let byteIdx = 0;
+    while (sizeBig >= 8n) {
+      result = result << 8n | BigInt(data[byteIdx++]);
+      sizeBig -= 8n;
+    }
+    if (sizeBig > 0n) {
+      this.#currentByte = data[byteIdx];
+      this.#currentBitIdx = size;
+      result = result << sizeBig | BigInt(this.#currentByte) >> 8n - sizeBig;
+    }
+    return result;
+  }
+  skipBits(size) {
+    if (size % 8 === 0) {
+      const buf = strings.exactly(this.#readable, size / 8);
+      this.#currentByte = buf[buf.length - 1];
+      return;
+    }
+    let bytesToRead = Math.ceil(size / 8);
+    if (this.#currentBitIdx !== 0) {
+      bytesToRead -= 1;
+    }
+    if (bytesToRead > 0) {
+      const buf = strings.exactly(this.#readable, bytesToRead);
+      this.#currentByte = buf[bytesToRead - 1];
+    }
+    this.#currentBitIdx = (this.#currentBitIdx + size) % 8;
+  }
+}
+exports.BitReader = BitReader;

package/bits/reader.d.ts

@@ -0,0 +1,15 @@
+import { ISyncReadable } from '../types.js';
+export declare class BitReader implements ISyncReadable {
+    #private;
+    constructor(readable: ISyncReadable);
+    /** Whether the reader is currently aligned on a byte boundary */
+    get isAligned(): boolean;
+    /** Skip any remaining bits in the current byte. No-op if already aligned */
+    align(): void;
+    /** The current bit position within the last consumed byte */
+    get bitPosition(): number;
+    readSync(bytes: number): Uint8Array;
+    readBits(size: number): number;
+    readBitsBig(size: number): bigint;
+    skipBits(size: number): void;
+}

package/bits/reader.js

@@ -0,0 +1,122 @@
+import { u8 } from "@fuman/utils";
+import { exactly } from "../read/strings.js";
+class BitReader {
+  #readable;
+  #currentByte = 0;
+  #currentBitIdx = 0;
+  constructor(readable) {
+    this.#readable = readable;
+  }
+  /** Whether the reader is currently aligned on a byte boundary */
+  get isAligned() {
+    return this.#currentBitIdx === 0;
+  }
+  /** Skip any remaining bits in the current byte. No-op if already aligned */
+  align() {
+    this.#currentBitIdx = 0;
+  }
+  /** The current bit position within the last consumed byte */
+  get bitPosition() {
+    return this.#currentBitIdx;
+  }
+  readSync(bytes) {
+    if (this.#currentBitIdx === 0) {
+      return this.#readable.readSync(bytes);
+    }
+    if (bytes === 1) {
+      return u8.allocWith([this.readBits(8)]);
+    }
+    const bit = this.#currentBitIdx;
+    const nbit = 8 - bit;
+    const mask1 = (1 << nbit) - 1;
+    const result = u8.alloc(bytes);
+    const tmp = this.#readable.readSync(bytes);
+    for (let i = 0; i < bytes; i++) {
+      const byte1 = this.#currentByte;
+      const byte2 = tmp[i];
+      result[i] = (byte1 & mask1) << bit | byte2 >> nbit;
+      this.#currentByte = byte2;
+    }
+    return result;
+  }
+  readBits(size) {
+    let result = 0;
+    if (this.#currentBitIdx !== 0) {
+      const bitsLeft = 8 - this.#currentBitIdx;
+      if (size <= bitsLeft) {
+        result = this.#currentByte & (1 << size) - 1;
+        this.#currentBitIdx += size;
+        if (this.#currentBitIdx === 8) {
+          this.#currentBitIdx = 0;
+        }
+        return result;
+      }
+      result = this.#currentByte & (1 << bitsLeft) - 1;
+      size -= bitsLeft;
+      this.#currentBitIdx = 0;
+    }
+    const bytes = Math.ceil(size / 8);
+    const data = exactly(this.#readable, bytes);
+    let byteIdx = 0;
+    while (size >= 8) {
+      result = result << 8 | data[byteIdx++];
+      size -= 8;
+    }
+    if (size > 0) {
+      this.#currentByte = data[byteIdx];
+      this.#currentBitIdx = size;
+      result = result << size | this.#currentByte >> 8 - size;
+    }
+    return result;
+  }
+  readBitsBig(size) {
+    let result = 0n;
+    if (this.#currentBitIdx !== 0) {
+      const bitsLeft = 8 - this.#currentBitIdx;
+      if (size <= bitsLeft) {
+        result = BigInt(this.#currentByte) & (1n << BigInt(size)) - 1n;
+        this.#currentBitIdx += Number(size);
+        if (this.#currentBitIdx === 8) {
+          this.#currentBitIdx = 0;
+        }
+        return result;
+      }
+      result = BigInt(this.#currentByte) & (1n << BigInt(bitsLeft)) - 1n;
+      size -= bitsLeft;
+      this.#currentBitIdx = 0;
+    }
+    const bytes = Math.ceil(size / 8);
+    const data = exactly(this.#readable, bytes);
+    let sizeBig = BigInt(size);
+    let byteIdx = 0;
+    while (sizeBig >= 8n) {
+      result = result << 8n | BigInt(data[byteIdx++]);
+      sizeBig -= 8n;
+    }
+    if (sizeBig > 0n) {
+      this.#currentByte = data[byteIdx];
+      this.#currentBitIdx = size;
+      result = result << sizeBig | BigInt(this.#currentByte) >> 8n - sizeBig;
+    }
+    return result;
+  }
+  skipBits(size) {
+    if (size % 8 === 0) {
+      const buf = exactly(this.#readable, size / 8);
+      this.#currentByte = buf[buf.length - 1];
+      return;
+    }
+    let bytesToRead = Math.ceil(size / 8);
+    if (this.#currentBitIdx !== 0) {
+      bytesToRead -= 1;
+    }
+    if (bytesToRead > 0) {
+      const buf = exactly(this.#readable, bytesToRead);
+      this.#currentByte = buf[bytesToRead - 1];
+    }
+    this.#currentBitIdx = (this.#currentBitIdx + size) % 8;
+  }
+}
+export {
+  BitReader
+};

package/bits/utils.cjs

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const REV_8BIT_LOOKUP = [
+  0,
+  8,
+  4,
+  12,
+  2,
+  10,
+  6,
+  14,
+  1,
+  9,
+  5,
+  13,
+  3,
+  11,
+  7,
+  15
+];
+function reverse8Bits(byte) {
+  return REV_8BIT_LOOKUP[byte & 15] << 4 | REV_8BIT_LOOKUP[byte >> 4];
+}
+function reverseBits(value, size) {
+  let result = 0;
+  for (let i = 0; i < size; i++) {
+    result |= (value >> i & 1) << size - i - 1;
+  }
+  return result;
+}
+function reverseBitsBig(value, size) {
+  if (typeof size === "number") {
+    size = BigInt(size);
+  }
+  let result = 0n;
+  for (let i = 0n; i < size; i++) {
+    result |= (value >> i & 1n) << size - i - 1n;
+  }
+  return result;
+}
+function reverseBitsAll(buf) {
+  for (let i = 0; i < buf.length; i++) {
+    buf[i] = reverse8Bits(buf[i]);
+  }
+}
+exports.reverse8Bits = reverse8Bits;
+exports.reverseBits = reverseBits;
+exports.reverseBitsAll = reverseBitsAll;
+exports.reverseBitsBig = reverseBitsBig;

package/bits/utils.d.ts

@@ -0,0 +1,12 @@
+/** Reverse bit ordering of a single byte */
+export declare function reverse8Bits(byte: number): number;
+/** Reverse bits of a numeric value, treating it as a `size`-bit number */
+export declare function reverseBits(value: number, size: number): number;
+/** Reverse bits of a bigint, treating it as a `size`-bit number */
+export declare function reverseBitsBig(value: bigint, size: number | bigint): bigint;
+/**
+ * Reverse the bit ordering of each byte in the byte array, **in place**
+ *
+ * @example `reverseBitsAll(new Uint8Array([0b10101010, 0b01010101])) // becomes [0b01010101, 0b10101010]
+ */
+export declare function reverseBitsAll(buf: Uint8Array): void;

package/bits/utils.js

@@ -0,0 +1,49 @@
+const REV_8BIT_LOOKUP = [
+  0,
+  8,
+  4,
+  12,
+  2,
+  10,
+  6,
+  14,
+  1,
+  9,
+  5,
+  13,
+  3,
+  11,
+  7,
+  15
+];
+function reverse8Bits(byte) {
+  return REV_8BIT_LOOKUP[byte & 15] << 4 | REV_8BIT_LOOKUP[byte >> 4];
+}
+function reverseBits(value, size) {
+  let result = 0;
+  for (let i = 0; i < size; i++) {
+    result |= (value >> i & 1) << size - i - 1;
+  }
+  return result;
+}
+function reverseBitsBig(value, size) {
+  if (typeof size === "number") {
+    size = BigInt(size);
+  }
+  let result = 0n;
+  for (let i = 0n; i < size; i++) {
+    result |= (value >> i & 1n) << size - i - 1n;
+  }
+  return result;
+}
+function reverseBitsAll(buf) {
+  for (let i = 0; i < buf.length; i++) {
+    buf[i] = reverse8Bits(buf[i]);
+  }
+}
+export {
+  reverse8Bits,
+  reverseBits,
+  reverseBitsAll,
+  reverseBitsBig
+};

package/buf-reader.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const DEFAULT_BUF_SIZE = 4096;
+const MIN_BUF_SIZE = 16;
+class BufReader {
+  #buffer;
+  #readable;
+  #readPos = 0;
+  #writePos = 0;
+  #eof = false;
+  static create(readable, size = DEFAULT_BUF_SIZE) {
+    return new BufReader(readable, size);
+  }
+  constructor(readable, size = DEFAULT_BUF_SIZE) {
+    if (size < MIN_BUF_SIZE) {
+      size = MIN_BUF_SIZE;
+    }
+    this.#buffer = utils.u8.alloc(size);
+    this.#readable = readable;
+  }
+  get bufferSize() {
+    return this.#buffer.byteLength;
+  }
+  get buffered() {
+    return this.#writePos - this.#readPos;
+  }
+  async #fill() {
+    if (this.#readPos > 0) {
+      this.#buffer.copyWithin(0, this.#readPos, this.#writePos);
+      this.#writePos -= this.#readPos;
+      this.#readPos = 0;
+    }
+    if (this.#writePos >= this.#buffer.byteLength) {
+      throw new Error("tried to fill full buffer");
+    }
+    const read = await this.#readable.read(this.#buffer.subarray(this.#writePos));
+    if (read === 0) {
+      this.#eof = true;
+      return;
+    }
+    this.#writePos += read;
+  }
+  async read(into) {
+    if (this.#eof) {
+      return 0;
+    }
+    if (this.#readPos === this.#writePos) {
+      if (into.byteLength >= this.#buffer.byteLength) {
+        return this.#readable.read(into);
+      }
+      await this.#fill();
+    }
+    const sliceSize = Math.min(this.#writePos - this.#readPos, into.byteLength);
+    into.set(this.#buffer.subarray(this.#readPos, this.#readPos + sliceSize));
+    this.#readPos += sliceSize;
+    return sliceSize;
+  }
+}
+exports.BufReader = BufReader;

package/buf-reader.d.ts

@@ -0,0 +1,9 @@
+import { IReadable } from './types.js';
+export declare class BufReader implements IReadable {
+    #private;
+    static create(readable: IReadable, size?: number): BufReader;
+    constructor(readable: IReadable, size?: number);
+    get bufferSize(): number;
+    get buffered(): number;
+    read(into: Uint8Array): Promise<number>;
+}

package/buf-reader.js

@@ -0,0 +1,60 @@
+import { u8 } from "@fuman/utils";
+const DEFAULT_BUF_SIZE = 4096;
+const MIN_BUF_SIZE = 16;
+class BufReader {
+  #buffer;
+  #readable;
+  #readPos = 0;
+  #writePos = 0;
+  #eof = false;
+  static create(readable, size = DEFAULT_BUF_SIZE) {
+    return new BufReader(readable, size);
+  }
+  constructor(readable, size = DEFAULT_BUF_SIZE) {
+    if (size < MIN_BUF_SIZE) {
+      size = MIN_BUF_SIZE;
+    }
+    this.#buffer = u8.alloc(size);
+    this.#readable = readable;
+  }
+  get bufferSize() {
+    return this.#buffer.byteLength;
+  }
+  get buffered() {
+    return this.#writePos - this.#readPos;
+  }
+  async #fill() {
+    if (this.#readPos > 0) {
+      this.#buffer.copyWithin(0, this.#readPos, this.#writePos);
+      this.#writePos -= this.#readPos;
+      this.#readPos = 0;
+    }
+    if (this.#writePos >= this.#buffer.byteLength) {
+      throw new Error("tried to fill full buffer");
+    }
+    const read = await this.#readable.read(this.#buffer.subarray(this.#writePos));
+    if (read === 0) {
+      this.#eof = true;
+      return;
+    }
+    this.#writePos += read;
+  }
+  async read(into) {
+    if (this.#eof) {
+      return 0;
+    }
+    if (this.#readPos === this.#writePos) {
+      if (into.byteLength >= this.#buffer.byteLength) {
+        return this.#readable.read(into);
+      }
+      await this.#fill();
+    }
+    const sliceSize = Math.min(this.#writePos - this.#readPos, into.byteLength);
+    into.set(this.#buffer.subarray(this.#readPos, this.#readPos + sliceSize));
+    this.#readPos += sliceSize;
+    return sliceSize;
+  }
+}
+export {
+  BufReader
+};

package/bytes.cjs

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const _utils = require("./_utils.cjs");
+class Bytes {
+  /** Underlying buffer */
+  #buffer;
+  /** Position of the write cursor (should always be >= {@link #readPos}) */
+  #writePos = 0;
+  /** Position of the read cursor */
+  #readPos = 0;
+  #preferredCapacity;
+  constructor(buf) {
+    this.#buffer = buf;
+    this.#preferredCapacity = buf.length;
+  }
+  static alloc(capacity = 1024 * 16) {
+    const bytes = new Bytes(utils.u8.alloc(capacity));
+    return bytes;
+  }
+  static from(data) {
+    const bytes = new Bytes(data);
+    bytes.#writePos = data.length;
+    return bytes;
+  }
+  /** Total number of bytes in the underlying buffer */
+  get capacity() {
+    return this.#buffer.byteLength;
+  }
+  /** Number of bytes available to be read */
+  get available() {
+    return this.#writePos - this.#readPos;
+  }
+  /** Number of bytes written */
+  get written() {
+    return this.#writePos;
+  }
+  #sharedRead = new Uint8Array(1);
+  readSync(bytes) {
+    if (this.#readPos >= this.#writePos) {
+      return utils.u8.empty;
+    }
+    if (bytes === 1) {
+      this.#sharedRead[0] = this.#buffer[this.#readPos++];
+      return this.#sharedRead;
+    }
+    const end = Math.min(this.#writePos, this.#readPos + bytes);
+    const result = this.#buffer.subarray(this.#readPos, end);
+    this.#readPos = end;
+    return result;
+  }
+  async read(into) {
+    const size = Math.min(into.length, this.#writePos - this.#readPos);
+    into.set(this.#buffer.subarray(this.#readPos, this.#readPos + size));
+    this.#readPos += size;
+    return size;
+  }
+  #lastWriteSize = 0;
+  writeSync(size) {
+    this.#lastWriteSize = size;
+    const newPos = this.#writePos + size;
+    if (newPos > this.#buffer.length) {
+      const newBuffer = utils.u8.alloc(_utils.nextPowerOfTwo(newPos));
+      newBuffer.set(this.#buffer);
+      this.#buffer = newBuffer;
+    }
+    const slice = this.#buffer.subarray(this.#writePos, newPos);
+    this.#writePos = newPos;
+    return slice;
+  }
+  disposeWriteSync(written) {
+    if (written !== void 0) {
+      if (written > this.#lastWriteSize) {
+        throw new RangeError(`written exceeds last write size: ${written} > ${this.#lastWriteSize}`);
+      }
+      this.#writePos -= this.#lastWriteSize - written;
+    }
+  }
+  async write(bytes) {
+    this.writeSync(bytes.length).set(bytes);
+    this.disposeWriteSync();
+  }
+  result() {
+    return this.#buffer.subarray(0, this.#writePos);
+  }
+  /** Reclaim memory by only keeping the yet-unread data */
+  reclaim() {
+    if (this.#readPos === 0) return;
+    const remaining = this.#writePos - this.#readPos;
+    if (remaining > 0) {
+      if (remaining < this.#preferredCapacity && this.capacity > this.#preferredCapacity) {
+        const newBuffer = utils.u8.alloc(this.#preferredCapacity);
+        newBuffer.set(this.#buffer.subarray(this.#readPos, this.#writePos));
+        this.#buffer = newBuffer;
+      } else {
+        this.#buffer.copyWithin(0, this.#readPos, this.#writePos);
+      }
+    }
+    this.#writePos = remaining;
+    this.#readPos = 0;
+  }
+  /** Mark last n bytes as unread */
+  rewind(n) {
+    if (n > this.#readPos) {
+      throw new RangeError(`rewind: ${n} > ${this.#readPos}`);
+    }
+    this.#readPos -= n;
+  }
+  reset() {
+    this.#readPos = 0;
+    this.#writePos = 0;
+  }
+}
+exports.Bytes = Bytes;