@fuman/io 0.0.1

package/write/numbers.js

@@ -0,0 +1,311 @@
+import { getDv } from "../_utils.js";
+function _maybeWrite(writable, size) {
+  if (ArrayBuffer.isView(writable)) {
+    return writable.subarray(0, size);
+  } else {
+    return writable.writeSync(size);
+  }
+}
+function _checkInt(value, min, max) {
+  if (value < min || value > max) {
+    throw new RangeError(`value out of bounds: ${value} (${min} ≤ value ≤ ${max})`);
+  }
+}
+function uint8(writable, value, noAssert = false) {
+  if (!noAssert) _checkInt(value, 0, 255);
+  const buf = _maybeWrite(writable, 1);
+  if (value < 0) value = 256 + value;
+  buf[0] = value & 255;
+}
+function int8(writable, value, noAssert = false) {
+  if (!noAssert) _checkInt(value, -128, 127);
+  const buf = _maybeWrite(writable, 1);
+  if (value < 0) value = 255 + value + 1;
+  buf[0] = value & 255;
+}
+function uint16le(writable, value, noAssert = false) {
+  if (!noAssert) _checkInt(value, 0, 65535);
+  const buf = _maybeWrite(writable, 2);
+  buf[0] = value & 255;
+  buf[1] = value >>> 8;
+}
+function uint16be(writable, value, noAssert = false) {
+  if (!noAssert) _checkInt(value, 0, 65535);
+  const buf = _maybeWrite(writable, 2);
+  buf[0] = value >>> 8;
+  buf[1] = value & 255;
+}
+function int16le(writable, value, noAssert = false) {
+  const buf = _maybeWrite(writable, 2);
+  if (!noAssert) _checkInt(value, -32768, 32767);
+  buf[0] = value & 255;
+  buf[1] = value >>> 8;
+}
+function int16be(writable, value, noAssert = false) {
+  const buf = _maybeWrite(writable, 2);
+  if (!noAssert) _checkInt(value, -32768, 32767);
+  buf[0] = value >>> 8;
+  buf[1] = value & 255;
+}
+function uint24le(writable, value, noAssert = false) {
+  if (!noAssert) _checkInt(value, 0, 16777215);
+  const buf = _maybeWrite(writable, 3);
+  buf[0] = value;
+  value = value >>> 8;
+  buf[1] = value;
+  value = value >>> 8;
+  buf[2] = value;
+}
+function uint24be(writable, value, noAssert = false) {
+  if (!noAssert) _checkInt(value, 0, 16777215);
+  const buf = _maybeWrite(writable, 3);
+  buf[2] = value;
+  value = value >>> 8;
+  buf[1] = value;
+  value = value >>> 8;
+  buf[0] = value;
+}
+function int24le(writable, value, noAssert = false) {
+  if (!noAssert) _checkInt(value, -8388608, 8388607);
+  const buf = _maybeWrite(writable, 3);
+  buf[0] = value;
+  value = value >>> 8;
+  buf[1] = value;
+  value = value >>> 8;
+  buf[2] = value;
+}
+function int24be(writable, value, noAssert = false) {
+  if (!noAssert) _checkInt(value, -8388608, 8388607);
+  const buf = _maybeWrite(writable, 3);
+  buf[2] = value;
+  value = value >>> 8;
+  buf[1] = value;
+  value = value >>> 8;
+  buf[0] = value;
+}
+function uint32le(writable, value, noAssert = false) {
+  const buf = _maybeWrite(writable, 4);
+  if (!noAssert) _checkInt(value, 0, 4294967295);
+  buf[0] = value;
+  value = value >>> 8;
+  buf[1] = value;
+  value = value >>> 8;
+  buf[2] = value;
+  value = value >>> 8;
+  buf[3] = value;
+}
+function uint32be(writable, value, noAssert = false) {
+  const buf = _maybeWrite(writable, 4);
+  if (!noAssert) _checkInt(value, 0, 4294967295);
+  buf[3] = value;
+  value = value >>> 8;
+  buf[2] = value;
+  value = value >>> 8;
+  buf[1] = value;
+  value = value >>> 8;
+  buf[0] = value;
+}
+function int32le(writable, value, noAssert = false) {
+  const buf = _maybeWrite(writable, 4);
+  if (!noAssert) _checkInt(value, -2147483648, 2147483647);
+  buf[0] = value;
+  value = value >>> 8;
+  buf[1] = value;
+  value = value >>> 8;
+  buf[2] = value;
+  value = value >>> 8;
+  buf[3] = value;
+}
+function int32be(writable, value, noAssert = false) {
+  const buf = _maybeWrite(writable, 4);
+  if (!noAssert) _checkInt(value, -2147483648, 2147483647);
+  buf[3] = value;
+  value = value >>> 8;
+  buf[2] = value;
+  value = value >>> 8;
+  buf[1] = value;
+  value = value >>> 8;
+  buf[0] = value;
+}
+function uint64le(writable, value, noAssert = false) {
+  const buf = _maybeWrite(writable, 8);
+  if (!noAssert) _checkInt(value, 0n, 0xFFFFFFFFFFFFFFFFn);
+  let lo = Number(value & 0xFFFFFFFFn);
+  buf[0] = lo;
+  lo = lo >> 8;
+  buf[1] = lo;
+  lo = lo >> 8;
+  buf[2] = lo;
+  lo = lo >> 8;
+  buf[3] = lo;
+  let hi = Number(value >> 32n & 0xFFFFFFFFn);
+  buf[4] = hi;
+  hi = hi >> 8;
+  buf[5] = hi;
+  hi = hi >> 8;
+  buf[6] = hi;
+  hi = hi >> 8;
+  buf[7] = hi;
+}
+function uint64be(writable, value, noAssert = false) {
+  const buf = _maybeWrite(writable, 8);
+  if (!noAssert) _checkInt(value, 0n, 0xFFFFFFFFFFFFFFFFn);
+  let lo = Number(value & 0xFFFFFFFFn);
+  buf[7] = lo;
+  lo = lo >> 8;
+  buf[6] = lo;
+  lo = lo >> 8;
+  buf[5] = lo;
+  lo = lo >> 8;
+  buf[4] = lo;
+  let hi = Number(value >> 32n & 0xFFFFFFFFn);
+  buf[3] = hi;
+  hi = hi >> 8;
+  buf[2] = hi;
+  hi = hi >> 8;
+  buf[1] = hi;
+  hi = hi >> 8;
+  buf[0] = hi;
+}
+function int64le(writable, value, noAssert = false) {
+  const buf = _maybeWrite(writable, 8);
+  if (!noAssert) _checkInt(value, -0x8000000000000000n, 0x7FFFFFFFFFFFFFFFn);
+  let lo = Number(value & 0xFFFFFFFFn);
+  buf[0] = lo;
+  lo = lo >> 8;
+  buf[1] = lo;
+  lo = lo >> 8;
+  buf[2] = lo;
+  lo = lo >> 8;
+  buf[3] = lo;
+  let hi = Number(value >> 32n & 0xFFFFFFFFn);
+  buf[4] = hi;
+  hi = hi >> 8;
+  buf[5] = hi;
+  hi = hi >> 8;
+  buf[6] = hi;
+  hi = hi >> 8;
+  buf[7] = hi;
+}
+function int64be(writable, value, noAssert = false) {
+  const buf = _maybeWrite(writable, 8);
+  if (!noAssert) _checkInt(value, -0x8000000000000000n, 0x7FFFFFFFFFFFFFFFn);
+  let lo = Number(value & 0xFFFFFFFFn);
+  buf[7] = lo;
+  lo = lo >> 8;
+  buf[6] = lo;
+  lo = lo >> 8;
+  buf[5] = lo;
+  lo = lo >> 8;
+  buf[4] = lo;
+  let hi = Number(value >> 32n & 0xFFFFFFFFn);
+  buf[3] = hi;
+  hi = hi >> 8;
+  buf[2] = hi;
+  hi = hi >> 8;
+  buf[1] = hi;
+  hi = hi >> 8;
+  buf[0] = hi;
+}
+function uintle(writable, size, value, noAssert = false) {
+  if (!noAssert) {
+    _checkInt(value, 0n, 2n ** BigInt(8 * size) - 1n);
+  }
+  const buf = _maybeWrite(writable, size);
+  let mul = 1n;
+  let i = 0;
+  buf[0] = Number(value & 0xFFn);
+  while (++i < size && (mul *= 0x100n)) {
+    buf[i] = Number(value / mul & 0xFFn);
+  }
+}
+function uintbe(writable, size, value, noAssert = false) {
+  if (!noAssert) {
+    _checkInt(value, 0n, 2n ** BigInt(8 * size) - 1n);
+  }
+  const buf = _maybeWrite(writable, size);
+  let i = size - 1;
+  let mul = 1n;
+  buf[i] = Number(value & 0xFFn);
+  while (--i >= 0 && (mul *= 0x100n)) {
+    buf[i] = Number(value / mul & 0xFFn);
+  }
+}
+function intle(writable, size, value, noAssert = false) {
+  if (!noAssert) {
+    const limit = 2n ** BigInt(8 * size - 1);
+    _checkInt(value, -limit, limit - 1n);
+  }
+  const buf = _maybeWrite(writable, size);
+  let i = 0;
+  let mul = 1n;
+  let sub = 0n;
+  buf[0] = Number(value & 0xFFn);
+  while (++i < size && (mul *= 0x100n)) {
+    if (value < 0 && sub === 0n && buf[i - 1] !== 0) {
+      sub = 1n;
+    }
+    buf[i] = Number(value / mul - sub & 0xFFn);
+  }
+}
+function intbe(writable, size, value, noAssert = false) {
+  if (!noAssert) {
+    const limit = 2n ** BigInt(8 * size - 1);
+    _checkInt(value, -limit, limit - 1n);
+  }
+  const buf = _maybeWrite(writable, size);
+  let i = size - 1;
+  let mul = 1n;
+  let sub = 0n;
+  buf[i] = Number(value & 0xFFn);
+  while (--i >= 0 && (mul *= 0x100n)) {
+    if (value < 0 && sub === 0n && buf[i + 1] !== 0) {
+      sub = 1n;
+    }
+    buf[i] = Number(value / mul - sub & 0xFFn);
+  }
+}
+function float32le(writable, value) {
+  const buf = _maybeWrite(writable, 4);
+  getDv(buf).setFloat32(buf.byteOffset, value, true);
+}
+function float32be(writable, value) {
+  const buf = _maybeWrite(writable, 4);
+  getDv(buf).setFloat32(buf.byteOffset, value, false);
+}
+function float64le(writable, value) {
+  const buf = _maybeWrite(writable, 8);
+  getDv(buf).setFloat64(buf.byteOffset, value, true);
+}
+function float64be(writable, value) {
+  const buf = _maybeWrite(writable, 8);
+  getDv(buf).setFloat64(buf.byteOffset, value, 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/write/pipe.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+async function pipe(into, readable) {
+  const chunk = new Uint8Array(1024 * 32);
+  while (true) {
+    const nread = await readable.read(chunk);
+    if (nread === 0) break;
+    await into.write(chunk.subarray(0, nread));
+  }
+}
+exports.pipe = pipe;

package/write/pipe.d.ts

@@ -0,0 +1,2 @@
+import { IReadable, IWritable } from '../types.js';
+export declare function pipe(into: IWritable, readable: IReadable): Promise<void>;

package/write/pipe.js

@@ -0,0 +1,11 @@
+async function pipe(into, readable) {
+  const chunk = new Uint8Array(1024 * 32);
+  while (true) {
+    const nread = await readable.read(chunk);
+    if (nread === 0) break;
+    await into.write(chunk.subarray(0, nread));
+  }
+}
+export {
+  pipe
+};

package/write/strings.cjs

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+function bytes(writable, bytes2) {
+  writable.writeSync(bytes2.length).set(bytes2);
+  writable.disposeWriteSync();
+}
+function bytesReversed(writable, bytes2) {
+  const buf = writable.writeSync(bytes2.length);
+  buf.set(bytes2);
+  buf.reverse();
+  writable.disposeWriteSync();
+}
+function rawString(writable, str) {
+  const buf = writable.writeSync(str.length);
+  for (let i = 0; i < str.length; i++) {
+    buf[i] = str.charCodeAt(i);
+  }
+  writable.disposeWriteSync();
+}
+function utf8String(writable, str) {
+  const len = utils.utf8.encodedLength(str);
+  const buf = writable.writeSync(len);
+  utils.utf8.encoder.encodeInto(str, buf);
+  writable.disposeWriteSync();
+}
+function cUtf8String(writable, str) {
+  const len = utils.utf8.encodedLength(str);
+  const buf = writable.writeSync(len + 1);
+  utils.utf8.encoder.encodeInto(str, buf);
+  buf[len] = 0;
+  writable.disposeWriteSync();
+}
+exports.bytes = bytes;
+exports.bytesReversed = bytesReversed;
+exports.cUtf8String = cUtf8String;
+exports.rawString = rawString;
+exports.utf8String = utf8String;

package/write/strings.d.ts

@@ -0,0 +1,6 @@
+import { ISyncWritable } from '../types.js';
+export declare function bytes(writable: ISyncWritable, bytes: Uint8Array): void;
+export declare function bytesReversed(writable: ISyncWritable, bytes: Uint8Array): void;
+export declare function rawString(writable: ISyncWritable, str: string): void;
+export declare function utf8String(writable: ISyncWritable, str: string): void;
+export declare function cUtf8String(writable: ISyncWritable, str: string): void;

package/write/strings.js

@@ -0,0 +1,38 @@
+import { utf8 } from "@fuman/utils";
+function bytes(writable, bytes2) {
+  writable.writeSync(bytes2.length).set(bytes2);
+  writable.disposeWriteSync();
+}
+function bytesReversed(writable, bytes2) {
+  const buf = writable.writeSync(bytes2.length);
+  buf.set(bytes2);
+  buf.reverse();
+  writable.disposeWriteSync();
+}
+function rawString(writable, str) {
+  const buf = writable.writeSync(str.length);
+  for (let i = 0; i < str.length; i++) {
+    buf[i] = str.charCodeAt(i);
+  }
+  writable.disposeWriteSync();
+}
+function utf8String(writable, str) {
+  const len = utf8.encodedLength(str);
+  const buf = writable.writeSync(len);
+  utf8.encoder.encodeInto(str, buf);
+  writable.disposeWriteSync();
+}
+function cUtf8String(writable, str) {
+  const len = utf8.encodedLength(str);
+  const buf = writable.writeSync(len + 1);
+  utf8.encoder.encodeInto(str, buf);
+  buf[len] = 0;
+  writable.disposeWriteSync();
+}
+export {
+  bytes,
+  bytesReversed,
+  cUtf8String,
+  rawString,
+  utf8String
+};