@fuman/io 0.0.1

package/index.d.ts

@@ -0,0 +1,12 @@
+import * as read from './read/index.js';
+import * as write from './write/index.js';
+export * from './bits/index.js';
+export * from './buf-reader.js';
+export * from './bytes.js';
+export * from './codec/index.js';
+export * from './errors.js';
+export * from './read/adapters.js';
+export * from './reader-with-final.js';
+export * from './types.js';
+export * from './write/adapters.js';
+export { read, write };

package/index.js

@@ -0,0 +1,39 @@
+import * as index from "./read/index.js";
+import * as index$1 from "./write/index.js";
+import { BufReader } from "./buf-reader.js";
+import { Bytes } from "./bytes.js";
+import { PartialReadError } from "./errors.js";
+import { fumanReadableToWeb, fumanSyncReadableToAsync, webReadableToFuman } from "./read/adapters.js";
+import { ReaderWithFinal } from "./reader-with-final.js";
+import { fumanSyncWritableToAsync, fumanWritableToWeb, webWritableToFuman } from "./write/adapters.js";
+import { BitReader } from "./bits/reader.js";
+import { reverse8Bits, reverseBits, reverseBitsAll, reverseBitsBig } from "./bits/utils.js";
+import { DelimiterCodec } from "./codec/delimiter.js";
+import { LengthDelimitedCodec } from "./codec/length-delimited.js";
+import { FramedReader } from "./codec/reader.js";
+import { TextDelimiterCodec } from "./codec/text-delimiter.js";
+import { FramedWriter } from "./codec/writer.js";
+export {
+  BitReader,
+  BufReader,
+  Bytes,
+  DelimiterCodec,
+  FramedReader,
+  FramedWriter,
+  LengthDelimitedCodec,
+  PartialReadError,
+  ReaderWithFinal,
+  TextDelimiterCodec,
+  fumanReadableToWeb,
+  fumanSyncReadableToAsync,
+  fumanSyncWritableToAsync,
+  fumanWritableToWeb,
+  index as read,
+  reverse8Bits,
+  reverseBits,
+  reverseBitsAll,
+  reverseBitsBig,
+  webReadableToFuman,
+  webWritableToFuman,
+  index$1 as write
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+    "name": "@fuman/io",
+    "type": "module",
+    "version": "0.0.1",
+    "description": "experimental i/o abstractions",
+    "license": "MIT",
+    "scripts": {},
+    "dependencies": {
+        "@fuman/utils": "^0.0.1"
+    },
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        }
+    },
+    "sideEffects": false,
+    "author": "",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/teidesu/fuman.git"
+    }
+}

package/read/adapters.cjs

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const bytes = require("../bytes.cjs");
+const streams = require("../streams.cjs");
+function fumanSyncReadableToAsync(readable) {
+  return {
+    async read(into) {
+      const buf = readable.readSync(into.length);
+      into.set(buf);
+      return buf.length;
+    }
+  };
+}
+function webReadableToFuman(readable) {
+  if (streams.isByobCapableStream(readable)) {
+    const reader2 = readable.getReader({ mode: "byob" });
+    return {
+      async read(into) {
+        const temp = new Uint8Array(into.length);
+        const { value, done } = await reader2.read(temp);
+        if (done) return 0;
+        into.set(value);
+        return value.byteLength;
+      },
+      close() {
+        reader2.cancel().catch(() => {
+        });
+      }
+    };
+  }
+  const reader = readable.getReader();
+  const buf = bytes.Bytes.alloc();
+  return {
+    async read(into) {
+      if (buf.available === 0) {
+        const { value, done } = await reader.read();
+        if (done) return 0;
+        buf.writeSync(value.byteLength).set(value);
+        buf.disposeWriteSync();
+      }
+      const read = Math.min(into.length, buf.available);
+      into.set(buf.readSync(read), 0);
+      buf.reclaim();
+      return read;
+    },
+    close() {
+      reader.cancel().catch(() => {
+      });
+    }
+  };
+}
+function fumanReadableToWeb(readable) {
+  return new ReadableStream({
+    type: "bytes",
+    async pull(controller) {
+      if (controller.byobRequest) {
+        if (!controller.byobRequest.view) {
+          controller.byobRequest.respond(0);
+          return;
+        }
+        const view = new Uint8Array(
+          controller.byobRequest.view.buffer,
+          controller.byobRequest.view.byteOffset,
+          controller.byobRequest.view.byteLength
+        );
+        const nread2 = await readable.read(view);
+        if (nread2 === 0) {
+          controller.close();
+          controller.byobRequest.respond(0);
+          return;
+        }
+        controller.byobRequest.respond(nread2);
+        return;
+      }
+      const buf = new Uint8Array(1024 * 32);
+      let nread = 0;
+      while (nread === 0) {
+        nread = await readable.read(buf);
+        if (nread === 0) break;
+        controller.enqueue(buf.subarray(0, nread));
+      }
+      if (nread === 0) {
+        controller.close();
+      }
+    }
+  });
+}
+exports.fumanReadableToWeb = fumanReadableToWeb;
+exports.fumanSyncReadableToAsync = fumanSyncReadableToAsync;
+exports.webReadableToFuman = webReadableToFuman;

package/read/adapters.d.ts

@@ -0,0 +1,4 @@
+import { IClosable, IReadable, ISyncReadable } from '../types.js';
+export declare function fumanSyncReadableToAsync(readable: ISyncReadable): IReadable;
+export declare function webReadableToFuman(readable: ReadableStream<Uint8Array>): IReadable & IClosable;
+export declare function fumanReadableToWeb(readable: IReadable): ReadableStream<Uint8Array>;

package/read/adapters.js

@@ -0,0 +1,90 @@
+import { Bytes } from "../bytes.js";
+import { isByobCapableStream } from "../streams.js";
+function fumanSyncReadableToAsync(readable) {
+  return {
+    async read(into) {
+      const buf = readable.readSync(into.length);
+      into.set(buf);
+      return buf.length;
+    }
+  };
+}
+function webReadableToFuman(readable) {
+  if (isByobCapableStream(readable)) {
+    const reader2 = readable.getReader({ mode: "byob" });
+    return {
+      async read(into) {
+        const temp = new Uint8Array(into.length);
+        const { value, done } = await reader2.read(temp);
+        if (done) return 0;
+        into.set(value);
+        return value.byteLength;
+      },
+      close() {
+        reader2.cancel().catch(() => {
+        });
+      }
+    };
+  }
+  const reader = readable.getReader();
+  const buf = Bytes.alloc();
+  return {
+    async read(into) {
+      if (buf.available === 0) {
+        const { value, done } = await reader.read();
+        if (done) return 0;
+        buf.writeSync(value.byteLength).set(value);
+        buf.disposeWriteSync();
+      }
+      const read = Math.min(into.length, buf.available);
+      into.set(buf.readSync(read), 0);
+      buf.reclaim();
+      return read;
+    },
+    close() {
+      reader.cancel().catch(() => {
+      });
+    }
+  };
+}
+function fumanReadableToWeb(readable) {
+  return new ReadableStream({
+    type: "bytes",
+    async pull(controller) {
+      if (controller.byobRequest) {
+        if (!controller.byobRequest.view) {
+          controller.byobRequest.respond(0);
+          return;
+        }
+        const view = new Uint8Array(
+          controller.byobRequest.view.buffer,
+          controller.byobRequest.view.byteOffset,
+          controller.byobRequest.view.byteLength
+        );
+        const nread2 = await readable.read(view);
+        if (nread2 === 0) {
+          controller.close();
+          controller.byobRequest.respond(0);
+          return;
+        }
+        controller.byobRequest.respond(nread2);
+        return;
+      }
+      const buf = new Uint8Array(1024 * 32);
+      let nread = 0;
+      while (nread === 0) {
+        nread = await readable.read(buf);
+        if (nread === 0) break;
+        controller.enqueue(buf.subarray(0, nread));
+      }
+      if (nread === 0) {
+        controller.close();
+      }
+    }
+  });
+}
+export {
+  fumanReadableToWeb,
+  fumanSyncReadableToAsync,
+  webReadableToFuman
+};

package/read/async/index.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const strings = require("./strings.cjs");
+exports.exactly = strings.exactly;
+exports.untilEnd = strings.untilEnd;

package/read/async/index.d.ts

@@ -0,0 +1 @@
+export * from './strings.js';

package/read/async/index.js

@@ -0,0 +1,5 @@
+import { exactly, untilEnd } from "./strings.js";
+export {
+  exactly,
+  untilEnd
+};

package/read/async/strings.cjs

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const bytes = require("../../bytes.cjs");
+const errors = require("../../errors.cjs");
+async function exactly(readable, length, onEof = "error") {
+  const res = typeof length === "number" ? utils.u8.alloc(length) : length;
+  let remaining = res.length;
+  let pos = 0;
+  while (remaining > 0) {
+    const read = await readable.read(res.subarray(pos, pos + remaining));
+    if (read === 0) {
+      if (onEof === "error") {
+        throw new errors.PartialReadError(
+          res.subarray(0, pos),
+          res.length
+        );
+      } else {
+        return res.subarray(0, pos);
+      }
+    }
+    remaining -= read;
+    pos += read;
+  }
+  return res;
+}
+async function untilEnd(readable, chunkSize = 1024 * 16) {
+  const buf = bytes.Bytes.alloc(chunkSize);
+  while (true) {
+    const into = buf.writeSync(chunkSize);
+    const read = await readable.read(into);
+    buf.disposeWriteSync(read);
+    if (read === 0) {
+      break;
+    }
+  }
+  return buf.result();
+}
+exports.exactly = exactly;
+exports.untilEnd = untilEnd;

package/read/async/strings.d.ts

@@ -0,0 +1,3 @@
+import { IReadable } from '../../types.js';
+export declare function exactly(readable: IReadable, length: number | Uint8Array, onEof?: 'error' | 'truncate'): Promise<Uint8Array>;
+export declare function untilEnd(readable: IReadable, chunkSize?: number): Promise<Uint8Array>;

package/read/async/strings.js

@@ -0,0 +1,40 @@
+import { u8 } from "@fuman/utils";
+import { Bytes } from "../../bytes.js";
+import { PartialReadError } from "../../errors.js";
+async function exactly(readable, length, onEof = "error") {
+  const res = typeof length === "number" ? u8.alloc(length) : length;
+  let remaining = res.length;
+  let pos = 0;
+  while (remaining > 0) {
+    const read = await readable.read(res.subarray(pos, pos + remaining));
+    if (read === 0) {
+      if (onEof === "error") {
+        throw new PartialReadError(
+          res.subarray(0, pos),
+          res.length
+        );
+      } else {
+        return res.subarray(0, pos);
+      }
+    }
+    remaining -= read;
+    pos += read;
+  }
+  return res;
+}
+async function untilEnd(readable, chunkSize = 1024 * 16) {
+  const buf = Bytes.alloc(chunkSize);
+  while (true) {
+    const into = buf.writeSync(chunkSize);
+    const read = await readable.read(into);
+    buf.disposeWriteSync(read);
+    if (read === 0) {
+      break;
+    }
+  }
+  return buf.result();
+}
+export {
+  exactly,
+  untilEnd
+};

package/read/index.cjs

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("./async/index.cjs");
+const numbers = require("./numbers.cjs");
+const strings = require("./strings.cjs");
+exports.async = index;
+exports.float32be = numbers.float32be;
+exports.float32le = numbers.float32le;
+exports.float64be = numbers.float64be;
+exports.float64le = numbers.float64le;
+exports.int16be = numbers.int16be;
+exports.int16le = numbers.int16le;
+exports.int24be = numbers.int24be;
+exports.int24le = numbers.int24le;
+exports.int32be = numbers.int32be;
+exports.int32le = numbers.int32le;
+exports.int64be = numbers.int64be;
+exports.int64le = numbers.int64le;
+exports.int8 = numbers.int8;
+exports.intbe = numbers.intbe;
+exports.intle = numbers.intle;
+exports.uint16be = numbers.uint16be;
+exports.uint16le = numbers.uint16le;
+exports.uint24be = numbers.uint24be;
+exports.uint24le = numbers.uint24le;
+exports.uint32be = numbers.uint32be;
+exports.uint32le = numbers.uint32le;
+exports.uint64be = numbers.uint64be;
+exports.uint64le = numbers.uint64le;
+exports.uint8 = numbers.uint8;
+exports.uintbe = numbers.uintbe;
+exports.uintle = numbers.uintle;
+exports.cUtf8String = strings.cUtf8String;
+exports.exactly = strings.exactly;
+exports.lengthPrefixed = strings.lengthPrefixed;
+exports.rawString = strings.rawString;
+exports.untilCondition = strings.untilCondition;
+exports.untilEnd = strings.untilEnd;
+exports.untilZero = strings.untilZero;
+exports.utf8String = strings.utf8String;

package/read/index.d.ts

@@ -0,0 +1,4 @@
+import * as async from './async/index.js';
+export * from './numbers.js';
+export * from './strings.js';
+export { async };

package/read/index.js

@@ -0,0 +1,40 @@
+import * as index from "./async/index.js";
+import { 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 } from "./numbers.js";
+import { cUtf8String, exactly, lengthPrefixed, rawString, untilCondition, untilEnd, untilZero, utf8String } from "./strings.js";
+export {
+  index as async,
+  cUtf8String,
+  exactly,
+  float32be,
+  float32le,
+  float64be,
+  float64le,
+  int16be,
+  int16le,
+  int24be,
+  int24le,
+  int32be,
+  int32le,
+  int64be,
+  int64le,
+  int8,
+  intbe,
+  intle,
+  lengthPrefixed,
+  rawString,
+  uint16be,
+  uint16le,
+  uint24be,
+  uint24le,
+  uint32be,
+  uint32le,
+  uint64be,
+  uint64le,
+  uint8,
+  uintbe,
+  uintle,
+  untilCondition,
+  untilEnd,
+  untilZero,
+  utf8String
+};

package/read/numbers.cjs

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _utils = require("../_utils.cjs");
+const errors = require("../errors.cjs");
+const strings = require("./strings.cjs");
+function uint8(readable) {
+  return strings.exactly(readable, 1)[0];
+}
+function _maybeRead(readable, size) {
+  if (ArrayBuffer.isView(readable)) {
+    if (readable.byteLength < size) {
+      throw new errors.PartialReadError(readable, size);
+    }
+    return readable;
+  }
+  return strings.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 _utils.getDv(buffer).getFloat32(buffer.byteOffset, true);
+}
+function float32be(readable) {
+  const buffer = _maybeRead(readable, 4);
+  return _utils.getDv(buffer).getFloat32(buffer.byteOffset, false);
+}
+function float64le(readable) {
+  const buffer = _maybeRead(readable, 8);
+  return _utils.getDv(buffer).getFloat64(buffer.byteOffset, true);
+}
+function float64be(readable) {
+  const buffer = _maybeRead(readable, 8);
+  return _utils.getDv(buffer).getFloat64(buffer.byteOffset, false);
+}
+exports.float32be = float32be;
+exports.float32le = float32le;
+exports.float64be = float64be;
+exports.float64le = float64le;
+exports.int16be = int16be;
+exports.int16le = int16le;
+exports.int24be = int24be;
+exports.int24le = int24le;
+exports.int32be = int32be;
+exports.int32le = int32le;
+exports.int64be = int64be;
+exports.int64le = int64le;
+exports.int8 = int8;
+exports.intbe = intbe;
+exports.intle = intle;
+exports.uint16be = uint16be;
+exports.uint16le = uint16le;
+exports.uint24be = uint24be;
+exports.uint24le = uint24le;
+exports.uint32be = uint32be;
+exports.uint32le = uint32le;
+exports.uint64be = uint64be;
+exports.uint64le = uint64le;
+exports.uint8 = uint8;
+exports.uintbe = uintbe;
+exports.uintle = uintle;

package/read/numbers.d.ts

@@ -0,0 +1,27 @@
+import { ISyncReadable } from '../types.js';
+export declare function uint8(readable: ISyncReadable): number;
+export declare function int8(readable: ISyncReadable | Uint8Array): number;
+export declare function uint16le(readable: ISyncReadable | Uint8Array): number;
+export declare function uint16be(readable: ISyncReadable | Uint8Array): number;
+export declare function uint24le(readable: ISyncReadable | Uint8Array): number;
+export declare function uint24be(readable: ISyncReadable | Uint8Array): number;
+export declare function uint32le(readable: ISyncReadable | Uint8Array): number;
+export declare function uint32be(readable: ISyncReadable | Uint8Array): number;
+export declare function uint64le(readable: ISyncReadable | Uint8Array): bigint;
+export declare function uint64be(readable: ISyncReadable | Uint8Array): bigint;
+export declare function int16le(readable: ISyncReadable | Uint8Array): number;
+export declare function int16be(readable: ISyncReadable | Uint8Array): number;
+export declare function int24le(readable: ISyncReadable | Uint8Array): number;
+export declare function int24be(readable: ISyncReadable | Uint8Array): number;
+export declare function int32le(readable: ISyncReadable | Uint8Array): number;
+export declare function int32be(readable: ISyncReadable | Uint8Array): number;
+export declare function int64le(readable: ISyncReadable | Uint8Array): bigint;
+export declare function int64be(readable: ISyncReadable | Uint8Array): bigint;
+export declare function uintle(readable: ISyncReadable | Uint8Array, size: number): bigint;
+export declare function uintbe(readable: ISyncReadable | Uint8Array, size: number): bigint;
+export declare function intbe(readable: ISyncReadable | Uint8Array, size: number): bigint;
+export declare function intle(readable: ISyncReadable | Uint8Array, size: number): bigint;
+export declare function float32le(readable: ISyncReadable | Uint8Array): number;
+export declare function float32be(readable: ISyncReadable | Uint8Array): number;
+export declare function float64le(readable: ISyncReadable | Uint8Array): number;
+export declare function float64be(readable: ISyncReadable | Uint8Array): number;