@fuman/io 0.0.1

package/write/index.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const numbers = require("./numbers.cjs");
+const pipe = require("./pipe.cjs");
+const strings = require("./strings.cjs");
+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.pipe = pipe.pipe;
+exports.bytes = strings.bytes;
+exports.bytesReversed = strings.bytesReversed;
+exports.cUtf8String = strings.cUtf8String;
+exports.rawString = strings.rawString;
+exports.utf8String = strings.utf8String;

package/write/index.d.ts

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

package/write/index.js

@@ -0,0 +1,37 @@
+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 { pipe } from "./pipe.js";
+import { bytes, bytesReversed, cUtf8String, rawString, utf8String } from "./strings.js";
+export {
+  bytes,
+  bytesReversed,
+  cUtf8String,
+  float32be,
+  float32le,
+  float64be,
+  float64le,
+  int16be,
+  int16le,
+  int24be,
+  int24le,
+  int32be,
+  int32le,
+  int64be,
+  int64le,
+  int8,
+  intbe,
+  intle,
+  pipe,
+  rawString,
+  uint16be,
+  uint16le,
+  uint24be,
+  uint24le,
+  uint32be,
+  uint32le,
+  uint64be,
+  uint64le,
+  uint8,
+  uintbe,
+  uintle,
+  utf8String
+};

package/write/numbers.cjs

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _utils = require("../_utils.cjs");
+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);
+  _utils.getDv(buf).setFloat32(buf.byteOffset, value, true);
+}
+function float32be(writable, value) {
+  const buf = _maybeWrite(writable, 4);
+  _utils.getDv(buf).setFloat32(buf.byteOffset, value, false);
+}
+function float64le(writable, value) {
+  const buf = _maybeWrite(writable, 8);
+  _utils.getDv(buf).setFloat64(buf.byteOffset, value, true);
+}
+function float64be(writable, value) {
+  const buf = _maybeWrite(writable, 8);
+  _utils.getDv(buf).setFloat64(buf.byteOffset, value, 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/write/numbers.d.ts

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