@fuman/io 0.0.1

package/read/numbers.js

@@ -0,0 +1,181 @@
+import { getDv } from "../_utils.js";
+import { PartialReadError } from "../errors.js";
+import { exactly } from "./strings.js";
+function uint8(readable) {
+  return exactly(readable, 1)[0];
+}
+function _maybeRead(readable, size) {
+  if (ArrayBuffer.isView(readable)) {
+    if (readable.byteLength < size) {
+      throw new PartialReadError(readable, size);
+    }
+    return readable;
+  }
+  return exactly(readable, size);
+}
+function int8(readable) {
+  const val = _maybeRead(readable, 1)[0];
+  if (!(val & 128)) return val;
+  return -(255 - val + 1);
+}
+function uint16le(readable) {
+  const buffer = _maybeRead(readable, 2);
+  return buffer[0] | buffer[1] << 8;
+}
+function uint16be(readable) {
+  const buffer = _maybeRead(readable, 2);
+  return buffer[0] << 8 | buffer[1];
+}
+function uint24le(readable) {
+  const buffer = _maybeRead(readable, 3);
+  return buffer[0] | buffer[1] << 8 | buffer[2] << 16;
+}
+function uint24be(readable) {
+  const buffer = _maybeRead(readable, 3);
+  return buffer[0] << 16 | buffer[1] << 8 | buffer[2];
+}
+function uint32le(readable) {
+  const buffer = _maybeRead(readable, 4);
+  return (buffer[0] | buffer[1] << 8 | buffer[2] << 16) + buffer[3] * 16777216;
+}
+function uint32be(readable) {
+  const buffer = _maybeRead(readable, 4);
+  return buffer[0] * 16777216 + (buffer[1] << 16 | buffer[2] << 8 | buffer[3]);
+}
+function uint64le(readable) {
+  const buffer = _maybeRead(readable, 8);
+  const lo = (buffer[0] | buffer[1] << 8 | buffer[2] << 16) + buffer[3] * 16777216;
+  const hi = (buffer[4] | buffer[5] << 8 | buffer[6] << 16) + buffer[7] * 16777216;
+  return BigInt(lo) | BigInt(hi) << 32n;
+}
+function uint64be(readable) {
+  const buffer = _maybeRead(readable, 8);
+  const lo = buffer[0] * 16777216 + (buffer[1] << 16 | buffer[2] << 8 | buffer[3]);
+  const hi = buffer[4] * 16777216 + (buffer[5] << 16 | buffer[6] << 8 | buffer[7]);
+  return BigInt(lo) << 32n | BigInt(hi);
+}
+function int16le(readable) {
+  const buffer = _maybeRead(readable, 2);
+  const val = buffer[0] | buffer[1] << 8;
+  return val & 32768 ? val | 4294901760 : val;
+}
+function int16be(readable) {
+  const buffer = _maybeRead(readable, 2);
+  const val = buffer[0] << 8 | buffer[1];
+  return val & 32768 ? val | 4294901760 : val;
+}
+function int24le(readable) {
+  const buffer = _maybeRead(readable, 3);
+  const val = buffer[0] | buffer[1] << 8 | buffer[2] << 16;
+  return val & 8388608 ? val | 4278190080 : val;
+}
+function int24be(readable) {
+  const buffer = _maybeRead(readable, 3);
+  const val = buffer[0] << 16 | buffer[1] << 8 | buffer[2];
+  return val & 8388608 ? val | 4278190080 : val;
+}
+function int32le(readable) {
+  const buffer = _maybeRead(readable, 4);
+  return buffer[0] | buffer[1] << 8 | buffer[2] << 16 | buffer[3] << 24;
+}
+function int32be(readable) {
+  const buffer = _maybeRead(readable, 4);
+  return buffer[0] << 24 | buffer[1] << 16 | buffer[2] << 8 | buffer[3];
+}
+function int64le(readable) {
+  const buffer = _maybeRead(readable, 8);
+  const val = buffer[4] + buffer[5] * 2 ** 8 + buffer[6] * 2 ** 16 + (buffer[7] << 24);
+  return (BigInt(val) << 32n) + BigInt(buffer[0] + buffer[1] * 2 ** 8 + buffer[2] * 2 ** 16 + buffer[3] * 2 ** 24);
+}
+function int64be(readable) {
+  const buffer = _maybeRead(readable, 8);
+  const val = (buffer[0] << 24) + buffer[1] * 2 ** 16 + buffer[2] * 2 ** 8 + buffer[3];
+  return (BigInt(val) << 32n) + BigInt(buffer[4] * 2 ** 24 + buffer[5] * 2 ** 16 + buffer[6] * 2 ** 8 + buffer[7]);
+}
+function uintle(readable, size) {
+  const buffer = _maybeRead(readable, size);
+  let val = BigInt(buffer[0]);
+  let mul = 1;
+  let i = 0;
+  while (++i < size && (mul *= 256)) {
+    val |= BigInt(buffer[i] * mul);
+  }
+  return val;
+}
+function uintbe(readable, size) {
+  const buffer = _maybeRead(readable, size);
+  let val = BigInt(buffer[--size]);
+  let mul = 1;
+  while (size > 0 && (mul *= 256)) {
+    val |= BigInt(buffer[--size] * mul);
+  }
+  return val;
+}
+function intbe(readable, size) {
+  const buffer = _maybeRead(readable, size);
+  let i = size - 1;
+  let mul = 1;
+  let val = BigInt(buffer[i]);
+  while (i > 0 && (mul *= 256)) {
+    val |= BigInt(buffer[--i] * mul);
+  }
+  mul *= 128;
+  if (val >= mul) val -= 2n ** BigInt(8 * size);
+  return val;
+}
+function intle(readable, size) {
+  const buffer = _maybeRead(readable, size);
+  let val = BigInt(buffer[0]);
+  let mul = 1;
+  let i = 0;
+  while (++i < size && (mul *= 256)) {
+    val |= BigInt(buffer[i] * mul);
+  }
+  mul *= 128;
+  if (val >= mul) val -= 2n ** BigInt(8 * size);
+  return val;
+}
+function float32le(readable) {
+  const buffer = _maybeRead(readable, 4);
+  return getDv(buffer).getFloat32(buffer.byteOffset, true);
+}
+function float32be(readable) {
+  const buffer = _maybeRead(readable, 4);
+  return getDv(buffer).getFloat32(buffer.byteOffset, false);
+}
+function float64le(readable) {
+  const buffer = _maybeRead(readable, 8);
+  return getDv(buffer).getFloat64(buffer.byteOffset, true);
+}
+function float64be(readable) {
+  const buffer = _maybeRead(readable, 8);
+  return getDv(buffer).getFloat64(buffer.byteOffset, false);
+}
+export {
+  float32be,
+  float32le,
+  float64be,
+  float64le,
+  int16be,
+  int16le,
+  int24be,
+  int24le,
+  int32be,
+  int32le,
+  int64be,
+  int64le,
+  int8,
+  intbe,
+  intle,
+  uint16be,
+  uint16le,
+  uint24be,
+  uint24le,
+  uint32be,
+  uint32le,
+  uint64be,
+  uint64le,
+  uint8,
+  uintbe,
+  uintle
+};

package/read/strings.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const bytes = require("../bytes.cjs");
+const errors = require("../errors.cjs");
+function exactly(readable, length) {
+  const buf = readable.readSync(length);
+  if (buf.length < length) {
+    throw new errors.PartialReadError(buf, length);
+  }
+  return buf;
+}
+function rawString(readable, length) {
+  const buf = exactly(readable, length);
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += String.fromCharCode(buf[i]);
+  }
+  return result;
+}
+function utf8String(readable, length) {
+  return utils.utf8.decoder.decode(exactly(readable, length));
+}
+function untilCondition(readable, condition) {
+  const buf = bytes.Bytes.alloc();
+  while (true) {
+    const byte = readable.readSync(1);
+    if (byte.length === 0) {
+      throw new errors.PartialReadError(buf.result(), buf.available + 1);
+    }
+    buf.writeSync(1)[0] = byte[0];
+    if (condition(byte[0])) {
+      break;
+    }
+  }
+  return buf.result();
+}
+function untilEnd(readable, chunkSize = 1024) {
+  const buf = bytes.Bytes.alloc(chunkSize);
+  while (true) {
+    const chunk = readable.readSync(chunkSize);
+    if (chunk.length === 0) {
+      break;
+    }
+    buf.writeSync(chunk.length).set(chunk);
+  }
+  return buf.result();
+}
+function untilZero(readable) {
+  return untilCondition(readable, (byte) => byte === 0);
+}
+function cUtf8String(readable) {
+  const buf = untilZero(readable);
+  return utils.utf8.decoder.decode(buf.subarray(0, buf.length - 1));
+}
+function lengthPrefixed(readLength, readable) {
+  const length = readLength(readable);
+  return exactly(readable, length);
+}
+exports.cUtf8String = cUtf8String;
+exports.exactly = exactly;
+exports.lengthPrefixed = lengthPrefixed;
+exports.rawString = rawString;
+exports.untilCondition = untilCondition;
+exports.untilEnd = untilEnd;
+exports.untilZero = untilZero;
+exports.utf8String = utf8String;

package/read/strings.d.ts

@@ -0,0 +1,9 @@
+import { ISyncReadable } from '../types.js';
+export declare function exactly(readable: ISyncReadable, length: number): Uint8Array;
+export declare function rawString(readable: ISyncReadable, length: number): string;
+export declare function utf8String(readable: ISyncReadable, length: number): string;
+export declare function untilCondition(readable: ISyncReadable, condition: (byte: number) => boolean): Uint8Array;
+export declare function untilEnd(readable: ISyncReadable, chunkSize?: number): Uint8Array;
+export declare function untilZero(readable: ISyncReadable): Uint8Array;
+export declare function cUtf8String(readable: ISyncReadable): string;
+export declare function lengthPrefixed(readLength: (readable: ISyncReadable) => number, readable: ISyncReadable): Uint8Array;

package/read/strings.js

@@ -0,0 +1,67 @@
+import { utf8 } from "@fuman/utils";
+import { Bytes } from "../bytes.js";
+import { PartialReadError } from "../errors.js";
+function exactly(readable, length) {
+  const buf = readable.readSync(length);
+  if (buf.length < length) {
+    throw new PartialReadError(buf, length);
+  }
+  return buf;
+}
+function rawString(readable, length) {
+  const buf = exactly(readable, length);
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += String.fromCharCode(buf[i]);
+  }
+  return result;
+}
+function utf8String(readable, length) {
+  return utf8.decoder.decode(exactly(readable, length));
+}
+function untilCondition(readable, condition) {
+  const buf = Bytes.alloc();
+  while (true) {
+    const byte = readable.readSync(1);
+    if (byte.length === 0) {
+      throw new PartialReadError(buf.result(), buf.available + 1);
+    }
+    buf.writeSync(1)[0] = byte[0];
+    if (condition(byte[0])) {
+      break;
+    }
+  }
+  return buf.result();
+}
+function untilEnd(readable, chunkSize = 1024) {
+  const buf = Bytes.alloc(chunkSize);
+  while (true) {
+    const chunk = readable.readSync(chunkSize);
+    if (chunk.length === 0) {
+      break;
+    }
+    buf.writeSync(chunk.length).set(chunk);
+  }
+  return buf.result();
+}
+function untilZero(readable) {
+  return untilCondition(readable, (byte) => byte === 0);
+}
+function cUtf8String(readable) {
+  const buf = untilZero(readable);
+  return utf8.decoder.decode(buf.subarray(0, buf.length - 1));
+}
+function lengthPrefixed(readLength, readable) {
+  const length = readLength(readable);
+  return exactly(readable, length);
+}
+export {
+  cUtf8String,
+  exactly,
+  lengthPrefixed,
+  rawString,
+  untilCondition,
+  untilEnd,
+  untilZero,
+  utf8String
+};

package/reader-with-final.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class ReaderWithFinal {
+  #buf1;
+  #buf2;
+  #readable;
+  #prev = null;
+  #ended = false;
+  constructor(readable, params) {
+    this.#readable = readable;
+    const bufSize = params?.internalBufferSize ?? 1024 * 32;
+    this.#buf1 = new Uint8Array(bufSize);
+    this.#buf2 = new Uint8Array(bufSize);
+  }
+  #swapBufs() {
+    const tmp = this.#buf1;
+    this.#buf1 = this.#buf2;
+    this.#buf2 = tmp;
+  }
+  async readWithFinal(into) {
+    if (this.#ended) {
+      return {
+        nread: 0,
+        final: true
+      };
+    }
+    if (!this.#prev) {
+      const nread2 = await this.#readable.read(this.#buf1);
+      if (nread2 === 0) {
+        return {
+          nread: 0,
+          final: true
+        };
+      }
+      this.#prev = this.#buf1.subarray(0, nread2);
+      this.#swapBufs();
+    }
+    if (this.#prev.length > into.length) {
+      into.set(this.#prev.subarray(0, into.length));
+      this.#prev = this.#prev.subarray(into.length);
+      return {
+        nread: into.length,
+        final: false
+      };
+    }
+    const nread = await this.#readable.read(this.#buf1);
+    if (nread === 0) {
+      into.set(this.#prev);
+      this.#ended = true;
+      return {
+        nread: this.#prev.length,
+        final: true
+      };
+    }
+    into.set(this.#prev);
+    const nwritten = this.#prev.length;
+    this.#prev = this.#buf1.subarray(0, nread);
+    this.#swapBufs();
+    return {
+      nread: nwritten,
+      final: false
+    };
+  }
+  async read(into) {
+    const res = await this.readWithFinal(into);
+    return res.nread;
+  }
+}
+exports.ReaderWithFinal = ReaderWithFinal;

package/reader-with-final.d.ts

@@ -0,0 +1,13 @@
+import { IReadable } from './types.js';
+export interface ReaderWithFinalResult {
+    readonly nread: number;
+    readonly final: boolean;
+}
+export declare class ReaderWithFinal implements IReadable {
+    #private;
+    constructor(readable: IReadable, params?: {
+        internalBufferSize?: number;
+    });
+    readWithFinal(into: Uint8Array): Promise<ReaderWithFinalResult>;
+    read(into: Uint8Array): Promise<number>;
+}

package/reader-with-final.js

@@ -0,0 +1,69 @@
+class ReaderWithFinal {
+  #buf1;
+  #buf2;
+  #readable;
+  #prev = null;
+  #ended = false;
+  constructor(readable, params) {
+    this.#readable = readable;
+    const bufSize = params?.internalBufferSize ?? 1024 * 32;
+    this.#buf1 = new Uint8Array(bufSize);
+    this.#buf2 = new Uint8Array(bufSize);
+  }
+  #swapBufs() {
+    const tmp = this.#buf1;
+    this.#buf1 = this.#buf2;
+    this.#buf2 = tmp;
+  }
+  async readWithFinal(into) {
+    if (this.#ended) {
+      return {
+        nread: 0,
+        final: true
+      };
+    }
+    if (!this.#prev) {
+      const nread2 = await this.#readable.read(this.#buf1);
+      if (nread2 === 0) {
+        return {
+          nread: 0,
+          final: true
+        };
+      }
+      this.#prev = this.#buf1.subarray(0, nread2);
+      this.#swapBufs();
+    }
+    if (this.#prev.length > into.length) {
+      into.set(this.#prev.subarray(0, into.length));
+      this.#prev = this.#prev.subarray(into.length);
+      return {
+        nread: into.length,
+        final: false
+      };
+    }
+    const nread = await this.#readable.read(this.#buf1);
+    if (nread === 0) {
+      into.set(this.#prev);
+      this.#ended = true;
+      return {
+        nread: this.#prev.length,
+        final: true
+      };
+    }
+    into.set(this.#prev);
+    const nwritten = this.#prev.length;
+    this.#prev = this.#buf1.subarray(0, nread);
+    this.#swapBufs();
+    return {
+      nread: nwritten,
+      final: false
+    };
+  }
+  async read(into) {
+    const res = await this.readWithFinal(into);
+    return res.nread;
+  }
+}
+export {
+  ReaderWithFinal
+};

package/streams.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function isByobCapableStream(stream) {
+  try {
+    const reader = stream.getReader({ mode: "byob" });
+    reader.releaseLock();
+    return true;
+  } catch (e) {
+    if (e instanceof TypeError) {
+      return false;
+    }
+    throw e;
+  }
+}
+exports.isByobCapableStream = isByobCapableStream;

package/streams.d.ts

@@ -0,0 +1 @@
+export declare function isByobCapableStream(stream: ReadableStream<Uint8Array>): boolean;

package/streams.js

@@ -0,0 +1,15 @@
+function isByobCapableStream(stream) {
+  try {
+    const reader = stream.getReader({ mode: "byob" });
+    reader.releaseLock();
+    return true;
+  } catch (e) {
+    if (e instanceof TypeError) {
+      return false;
+    }
+    throw e;
+  }
+}
+export {
+  isByobCapableStream
+};

package/types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * An interface for reading bytes synchronously from somewhere.
+ */
+export interface ISyncReadable {
+    /**
+     * Read the specified number of bytes from the source
+     * and return them as a Uint8Array.
+     *
+     * **The returned Uint8Array**:
+     * - *may* be a view into a larger buffer
+     * - is only valid until the next call to `readSync`
+     * - may be smaller than the requested number of bytes if the end of the source is reached.
+     * > these constraints allow for more efficient zero-copy implementations in many cases
+     *
+     * @param bytes The number of bytes to read
+     * @returns Uint8Array containing the bytes that were read.
+     */
+    readSync: (bytes: number) => Uint8Array;
+}
+export interface IReadable {
+    /**
+     * Read data from the underlying source into the provided Uint8Array,
+     * up to the length of the array, and return the number of bytes read.
+     *
+     * If there are no bytes available currently, the implementation is supposed to wait
+     * until at least one byte is available, and only then resolve the promise.
+     * Resolving the promise with a zero-length Uint8Array is marking the end of the source.
+     *
+     * @param bytes The number of bytes to read
+     * @returns Uint8Array containing the bytes that were read.
+     */
+    read: (into: Uint8Array) => Promise<number>;
+}
+export interface IClosable {
+    /**
+     * Close the underlying source.
+     */
+    close: () => void;
+}
+export interface ISyncWritable {
+    /**
+     * Write the specified number of bytes to the underlying source.
+     *
+     * The implementation is supposed to make sure there are at least `bytes` bytes
+     * available in the underlying source and return a Uint8Array that can be written to.
+     * The returned Uint8Array must be valid at least until the next call to `writeSync`
+     * or `disposeWriteSync`.
+     *
+     * If the caller writes less than `bytes` bytes to the returned Uint8Array,
+     * `disposeWriteSync` must be called with the number of bytes that were actually written.
+     *
+     * @param bytes The number of bytes to write
+     * @returns Uint8Array of length `bytes` that can be written to
+     */
+    writeSync: (bytes: number) => Uint8Array;
+    /**
+     * Explicitly dispose of the buffer that was returned by the last call to `writeSync`.
+     *
+     * If less than `bytes` bytes were written to the buffer, the number of bytes that were
+     * written must be passed as the `written` argument.
+     */
+    disposeWriteSync: (written?: number) => void;
+}
+export interface IWritable {
+    write: (bytes: Uint8Array) => Promise<void>;
+}

package/write/adapters.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function fumanSyncWritableToAsync(sync) {
+  return {
+    async write(bytes) {
+      const buf = sync.writeSync(bytes.length);
+      buf.set(bytes);
+      sync.disposeWriteSync();
+    }
+  };
+}
+function webWritableToFuman(writable) {
+  const writer = writable.getWriter();
+  return {
+    async write(bytes) {
+      await writer.write(bytes);
+    },
+    close() {
+      writer.close().catch(() => {
+      });
+    }
+  };
+}
+function fumanWritableToWeb(writable) {
+  return new WritableStream({
+    async write(chunk) {
+      await writable.write(chunk);
+    },
+    close() {
+      if ("close" in writable) {
+        writable.close();
+      }
+    }
+  });
+}
+exports.fumanSyncWritableToAsync = fumanSyncWritableToAsync;
+exports.fumanWritableToWeb = fumanWritableToWeb;
+exports.webWritableToFuman = webWritableToFuman;

package/write/adapters.d.ts

@@ -0,0 +1,4 @@
+import { IClosable, ISyncWritable, IWritable } from '../types.js';
+export declare function fumanSyncWritableToAsync(sync: ISyncWritable): IWritable;
+export declare function webWritableToFuman(writable: WritableStream<Uint8Array>): IWritable & IClosable;
+export declare function fumanWritableToWeb(writable: IWritable): WritableStream<Uint8Array>;

package/write/adapters.js

@@ -0,0 +1,38 @@
+function fumanSyncWritableToAsync(sync) {
+  return {
+    async write(bytes) {
+      const buf = sync.writeSync(bytes.length);
+      buf.set(bytes);
+      sync.disposeWriteSync();
+    }
+  };
+}
+function webWritableToFuman(writable) {
+  const writer = writable.getWriter();
+  return {
+    async write(bytes) {
+      await writer.write(bytes);
+    },
+    close() {
+      writer.close().catch(() => {
+      });
+    }
+  };
+}
+function fumanWritableToWeb(writable) {
+  return new WritableStream({
+    async write(chunk) {
+      await writable.write(chunk);
+    },
+    close() {
+      if ("close" in writable) {
+        writable.close();
+      }
+    }
+  });
+}
+export {
+  fumanSyncWritableToAsync,
+  fumanWritableToWeb,
+  webWritableToFuman
+};