@thi.ng/transducers-binary 2.1.81 → 2.1.82

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:04Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -68,7 +68,7 @@ For Node.js REPL:
 const transducersBinary = await import("@thi.ng/transducers-binary");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 2.51 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 2.50 KB
 
 ## Dependencies
 

package/api.js

@@ -1 +0,0 @@
-export {};

package/base64.js

@@ -3,84 +3,101 @@ import { iterator, iterator1, __iter } from "@thi.ng/transducers/iterator";
 import { isReduced, reduced } from "@thi.ng/transducers/reduced";
 const B64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 const B64_SAFE = B64_CHARS.substring(0, 62) + "-_";
-export function base64Decode(src) {
-    return src
-        ? new Uint8Array([...iterator1(base64Decode(), src)])
-        : (rfn) => {
-            const r = rfn[2];
-            let bc = 0, bs = 0;
-            return compR(rfn, (acc, x) => {
-                switch (x) {
-                    case "-":
-                        x = "+";
-                        break;
-                    case "_":
-                        x = "/";
-                        break;
-                    case "=":
-                        return reduced(acc);
-                    default:
-                }
-                const y = B64_CHARS.indexOf(x);
-                bs = bc & 3 ? (bs << 6) + y : y;
-                if (bc++ & 3) {
-                    acc = r(acc, 255 & (bs >> ((-2 * bc) & 6)));
-                }
-                return acc;
-            });
-        };
+function base64Decode(src) {
+  return src ? new Uint8Array([...iterator1(base64Decode(), src)]) : (rfn) => {
+    const r = rfn[2];
+    let bc = 0, bs = 0;
+    return compR(rfn, (acc, x) => {
+      switch (x) {
+        case "-":
+          x = "+";
+          break;
+        case "_":
+          x = "/";
+          break;
+        case "=":
+          return reduced(acc);
+        default:
+      }
+      const y = B64_CHARS.indexOf(x);
+      bs = bc & 3 ? (bs << 6) + y : y;
+      if (bc++ & 3) {
+        acc = r(acc, 255 & bs >> (-2 * bc & 6));
+      }
+      return acc;
+    });
+  };
 }
-export function base64Encode(...args) {
-    const iter = __iter(base64Encode, args, iterator);
-    if (iter) {
-        return [...iter].join("");
-    }
-    return ([init, complete, reduce]) => {
-        let state = 0;
-        let b;
-        const opts = { safe: false, buffer: 1024, ...args[0] };
-        const chars = opts.safe ? B64_SAFE : B64_CHARS;
-        const buf = [];
-        return [
-            init,
-            (acc) => {
-                switch (state) {
-                    case 1:
-                        buf.push(chars[(b >> 18) & 0x3f], chars[(b >> 12) & 0x3f], "=", "=");
-                        break;
-                    case 2:
-                        buf.push(chars[(b >> 18) & 0x3f], chars[(b >> 12) & 0x3f], chars[(b >> 6) & 0x3f], "=");
-                        break;
-                    default:
-                }
-                while (buf.length && !isReduced(acc)) {
-                    acc = reduce(acc, buf.shift());
-                }
-                return complete(acc);
-            },
-            (acc, x) => {
-                switch (state) {
-                    case 0:
-                        state = 1;
-                        b = x << 16;
-                        break;
-                    case 1:
-                        state = 2;
-                        b += x << 8;
-                        break;
-                    default:
-                        state = 0;
-                        b += x;
-                        buf.push(chars[(b >> 18) & 0x3f], chars[(b >> 12) & 0x3f], chars[(b >> 6) & 0x3f], chars[b & 0x3f]);
-                        if (buf.length >= opts.buffer) {
-                            for (let i = 0, n = buf.length; i < n && !isReduced(acc); i++) {
-                                acc = reduce(acc, buf[i]);
-                            }
-                            buf.length = 0;
-                        }
-                }
-                return acc;
-            },
-        ];
-    };
+function base64Encode(...args) {
+  const iter = __iter(base64Encode, args, iterator);
+  if (iter) {
+    return [...iter].join("");
+  }
+  return ([init, complete, reduce]) => {
+    let state = 0;
+    let b;
+    const opts = { safe: false, buffer: 1024, ...args[0] };
+    const chars = opts.safe ? B64_SAFE : B64_CHARS;
+    const buf = [];
+    return [
+      init,
+      (acc) => {
+        switch (state) {
+          case 1:
+            buf.push(
+              chars[b >> 18 & 63],
+              chars[b >> 12 & 63],
+              "=",
+              "="
+            );
+            break;
+          case 2:
+            buf.push(
+              chars[b >> 18 & 63],
+              chars[b >> 12 & 63],
+              chars[b >> 6 & 63],
+              "="
+            );
+            break;
+          default:
+        }
+        while (buf.length && !isReduced(acc)) {
+          acc = reduce(acc, buf.shift());
+        }
+        return complete(acc);
+      },
+      (acc, x) => {
+        switch (state) {
+          case 0:
+            state = 1;
+            b = x << 16;
+            break;
+          case 1:
+            state = 2;
+            b += x << 8;
+            break;
+          default:
+            state = 0;
+            b += x;
+            buf.push(
+              chars[b >> 18 & 63],
+              chars[b >> 12 & 63],
+              chars[b >> 6 & 63],
+              chars[b & 63]
+            );
+            if (buf.length >= opts.buffer) {
+              for (let i = 0, n = buf.length; i < n && !isReduced(acc); i++) {
+                acc = reduce(acc, buf[i]);
+              }
+              buf.length = 0;
+            }
+        }
+        return acc;
+      }
+    ];
+  };
 }
+export {
+  base64Decode,
+  base64Encode
+};

package/bits.js

@@ -1,24 +1,27 @@
 import { compR } from "@thi.ng/transducers/compr";
 import { iterator, __iter } from "@thi.ng/transducers/iterator";
 import { isReduced } from "@thi.ng/transducers/reduced";
-export function bits(...args) {
-    return (__iter(bits, args, iterator) ||
-        ((rfn) => {
-            const reduce = rfn[2];
-            const size = args[0] || 8;
-            const msb = args[1] !== false;
-            return compR(rfn, msb
-                ? (acc, x) => {
-                    for (let i = size; i-- > 0 && !isReduced(acc);) {
-                        acc = reduce(acc, (x >>> i) & 1);
-                    }
-                    return acc;
-                }
-                : (acc, x) => {
-                    for (let i = 0; i < size && !isReduced(acc); i++) {
-                        acc = reduce(acc, (x >>> i) & 1);
-                    }
-                    return acc;
-                });
-        }));
+function bits(...args) {
+  return __iter(bits, args, iterator) || ((rfn) => {
+    const reduce = rfn[2];
+    const size = args[0] || 8;
+    const msb = args[1] !== false;
+    return compR(
+      rfn,
+      msb ? (acc, x) => {
+        for (let i = size; i-- > 0 && !isReduced(acc); ) {
+          acc = reduce(acc, x >>> i & 1);
+        }
+        return acc;
+      } : (acc, x) => {
+        for (let i = 0; i < size && !isReduced(acc); i++) {
+          acc = reduce(acc, x >>> i & 1);
+        }
+        return acc;
+      }
+    );
+  });
 }
+export {
+  bits
+};

package/bytes.js

@@ -1,237 +1,267 @@
-import { bytes16, bytes24, bytes32, bytesF32, bytesF64, } from "@thi.ng/binary/bytes";
+import {
+  bytes16,
+  bytes24,
+  bytes32,
+  bytesF32,
+  bytesF64
+} from "@thi.ng/binary/bytes";
 import { unsupported } from "@thi.ng/errors/unsupported";
 import { iterator } from "@thi.ng/transducers/iterator";
 import { mapcat } from "@thi.ng/transducers/mapcat";
 import { reduce } from "@thi.ng/transducers/reduce";
 import { utf8Encode } from "./utf8.js";
-export const i8 = (x) => ["i8", x];
-export const i8array = (x) => ["i8a", x];
-export const u8 = (x) => ["u8", x];
-export const u8array = (x) => ["u8a", x];
-export const i16 = (x, le = false) => ["i16", x, le];
-export const i16array = (x, le = false) => [
-    "i16a",
-    x,
-    le,
+const i8 = (x) => ["i8", x];
+const i8array = (x) => ["i8a", x];
+const u8 = (x) => ["u8", x];
+const u8array = (x) => ["u8a", x];
+const i16 = (x, le = false) => ["i16", x, le];
+const i16array = (x, le = false) => [
+  "i16a",
+  x,
+  le
 ];
-export const u16 = (x, le = false) => ["u16", x, le];
-export const u16array = (x, le = false) => [
-    "u16a",
-    x,
-    le,
+const u16 = (x, le = false) => ["u16", x, le];
+const u16array = (x, le = false) => [
+  "u16a",
+  x,
+  le
 ];
-export const i24 = (x, le = false) => ["i24", x, le];
-export const i24array = (x, le = false) => [
-    "i24a",
-    x,
-    le,
+const i24 = (x, le = false) => ["i24", x, le];
+const i24array = (x, le = false) => [
+  "i24a",
+  x,
+  le
 ];
-export const u24 = (x, le = false) => ["u24", x, le];
-export const u24array = (x, le = false) => [
-    "u24a",
-    x,
-    le,
+const u24 = (x, le = false) => ["u24", x, le];
+const u24array = (x, le = false) => [
+  "u24a",
+  x,
+  le
 ];
-export const i32 = (x, le = false) => ["i32", x, le];
-export const i32array = (x, le = false) => [
-    "i32a",
-    x,
-    le,
+const i32 = (x, le = false) => ["i32", x, le];
+const i32array = (x, le = false) => [
+  "i32a",
+  x,
+  le
 ];
-export const u32 = (x, le = false) => ["u32", x, le];
-export const u32array = (x, le = false) => [
-    "u32a",
-    x,
-    le,
+const u32 = (x, le = false) => ["u32", x, le];
+const u32array = (x, le = false) => [
+  "u32a",
+  x,
+  le
 ];
-export const f32 = (x, le = false) => ["f32", x, le];
-export const f32array = (x, le = false) => [
-    "f32a",
-    x,
-    le,
+const f32 = (x, le = false) => ["f32", x, le];
+const f32array = (x, le = false) => [
+  "f32a",
+  x,
+  le
 ];
-export const f64 = (x, le = false) => ["f64", x, le];
-export const f64array = (x, le = false) => [
-    "f64a",
-    x,
-    le,
+const f64 = (x, le = false) => ["f64", x, le];
+const f64array = (x, le = false) => [
+  "f64a",
+  x,
+  le
 ];
-export const str = (x) => ["str", x];
-export function asBytes(src) {
-    return src
-        ? iterator(asBytes(), src)
-        : mapcat((x) => {
-            const val = x[1];
-            const le = x[2];
-            switch (x[0]) {
-                case "i8":
-                case "u8":
-                    return [val];
-                case "i8a":
-                case "u8a":
-                    return x[1];
-                case "i16":
-                case "u16":
-                    return bytes16(val, le);
-                case "i16a":
-                case "u16a":
-                    return mapcat((x) => bytes16(x, le), x[1]);
-                case "i24":
-                case "u24":
-                    return bytes24(val, le);
-                case "i24a":
-                case "u24a":
-                    return mapcat((x) => bytes24(x, le), x[1]);
-                case "i32":
-                case "u32":
-                    return bytes32(val, le);
-                case "i32a":
-                case "u32a":
-                    return mapcat((x) => bytes32(x, le), x[1]);
-                case "f32":
-                    return bytesF32(val, le);
-                case "f32a":
-                    return mapcat((x) => bytesF32(x, le), x[1]);
-                case "f64":
-                    return bytesF64(val, le);
-                case "f64a":
-                    return mapcat((x) => bytesF64(x, le), x[1]);
-                case "str":
-                    return utf8Encode(x[1]);
-                default:
-                    unsupported(`invalid struct item: ${x[0]}`);
-            }
-        });
+const str = (x) => ["str", x];
+function asBytes(src) {
+  return src ? iterator(asBytes(), src) : mapcat((x) => {
+    const val = x[1];
+    const le = x[2];
+    switch (x[0]) {
+      case "i8":
+      case "u8":
+        return [val];
+      case "i8a":
+      case "u8a":
+        return x[1];
+      case "i16":
+      case "u16":
+        return bytes16(val, le);
+      case "i16a":
+      case "u16a":
+        return mapcat((x2) => bytes16(x2, le), x[1]);
+      case "i24":
+      case "u24":
+        return bytes24(val, le);
+      case "i24a":
+      case "u24a":
+        return mapcat((x2) => bytes24(x2, le), x[1]);
+      case "i32":
+      case "u32":
+        return bytes32(val, le);
+      case "i32a":
+      case "u32a":
+        return mapcat((x2) => bytes32(x2, le), x[1]);
+      case "f32":
+        return bytesF32(val, le);
+      case "f32a":
+        return mapcat((x2) => bytesF32(x2, le), x[1]);
+      case "f64":
+        return bytesF64(val, le);
+      case "f64a":
+        return mapcat((x2) => bytesF64(x2, le), x[1]);
+      case "str":
+        return utf8Encode(x[1]);
+      default:
+        unsupported(`invalid struct item: ${x[0]}`);
+    }
+  });
 }
-export function bytes(cap = 1024, src) {
-    let view;
-    let pos = 0;
-    const ensure = (acc, size) => {
-        if (pos + size <= cap)
-            return acc;
-        cap *= 2;
-        const buf = new Uint8Array(cap);
-        buf.set(acc);
-        view = new DataView(buf.buffer);
-        return buf;
-    };
-    const setArray = (fn, stride, acc, x, le) => {
-        const n = x.length;
-        acc = ensure(acc, stride * n);
-        for (let i = 0; i < n; i++, pos += stride) {
-            view[fn](pos, x[i], le);
+function bytes(cap = 1024, src) {
+  let view;
+  let pos = 0;
+  const ensure = (acc, size) => {
+    if (pos + size <= cap)
+      return acc;
+    cap *= 2;
+    const buf = new Uint8Array(cap);
+    buf.set(acc);
+    view = new DataView(buf.buffer);
+    return buf;
+  };
+  const setArray = (fn, stride, acc, x, le) => {
+    const n = x.length;
+    acc = ensure(acc, stride * n);
+    for (let i = 0; i < n; i++, pos += stride) {
+      view[fn](pos, x[i], le);
+    }
+    return acc;
+  };
+  return src ? reduce(bytes(cap), src) : [
+    () => new Uint8Array(cap),
+    (acc) => acc.subarray(0, pos),
+    (acc, [type, x, le = false]) => {
+      if (!view || view.buffer !== acc.buffer) {
+        cap = acc.byteLength;
+        view = new DataView(acc.buffer, acc.byteOffset);
+      }
+      switch (type) {
+        case "i8":
+          acc = ensure(acc, 1);
+          view.setInt8(pos, x);
+          pos++;
+          break;
+        case "i8a": {
+          const n = x.length;
+          acc = ensure(acc, n);
+          new Int8Array(acc.buffer, acc.byteOffset).set(
+            x,
+            pos
+          );
+          pos += n;
+          break;
         }
-        return acc;
-    };
-    return src
-        ? reduce(bytes(cap), src)
-        : [
-            () => new Uint8Array(cap),
-            (acc) => acc.subarray(0, pos),
-            (acc, [type, x, le = false]) => {
-                if (!view || view.buffer !== acc.buffer) {
-                    cap = acc.byteLength;
-                    view = new DataView(acc.buffer, acc.byteOffset);
-                }
-                switch (type) {
-                    case "i8":
-                        acc = ensure(acc, 1);
-                        view.setInt8(pos, x);
-                        pos++;
-                        break;
-                    case "i8a": {
-                        const n = x.length;
-                        acc = ensure(acc, n);
-                        new Int8Array(acc.buffer, acc.byteOffset).set(x, pos);
-                        pos += n;
-                        break;
-                    }
-                    case "u8":
-                        acc = ensure(acc, 1);
-                        view.setUint8(pos, x);
-                        pos++;
-                        break;
-                    case "u8a": {
-                        const n = x.length;
-                        acc = ensure(acc, n);
-                        acc.set(x, pos);
-                        pos += n;
-                        break;
-                    }
-                    case "i16":
-                        acc = ensure(acc, 2);
-                        view.setInt16(pos, x, le);
-                        pos += 2;
-                        break;
-                    case "i16a":
-                        acc = setArray("setInt16", 2, acc, x, le);
-                        break;
-                    case "u16":
-                        acc = ensure(acc, 2);
-                        view.setUint16(pos, x, le);
-                        pos += 2;
-                        break;
-                    case "u16a":
-                        acc = setArray("setUint16", 2, acc, x, le);
-                        break;
-                    case "i24":
-                        acc = ensure(acc, 4);
-                        view.setInt32(pos, x, le);
-                        pos += 3;
-                        break;
-                    case "i24a":
-                        acc = setArray("setInt32", 3, acc, x, le);
-                        break;
-                    case "u24":
-                        acc = ensure(acc, 4);
-                        view.setUint32(pos, x, le);
-                        pos += 3;
-                        break;
-                    case "u24a":
-                        acc = setArray("setUint32", 3, acc, x, le);
-                        break;
-                    case "i32":
-                        acc = ensure(acc, 4);
-                        view.setInt32(pos, x, le);
-                        pos += 4;
-                        break;
-                    case "i32a":
-                        acc = setArray("setInt32", 4, acc, x, le);
-                        break;
-                    case "u32":
-                        acc = ensure(acc, 4);
-                        view.setUint32(pos, x, le);
-                        pos += 4;
-                        break;
-                    case "u32a":
-                        acc = setArray("setUint32", 4, acc, x, le);
-                        break;
-                    case "f32":
-                        acc = ensure(acc, 4);
-                        view.setFloat32(pos, x, le);
-                        pos += 4;
-                        break;
-                    case "f32a":
-                        acc = setArray("setFloat32", 4, acc, x, le);
-                        break;
-                    case "f64":
-                        acc = ensure(acc, 8);
-                        view.setFloat64(pos, x, le);
-                        pos += 8;
-                        break;
-                    case "f64a":
-                        acc = setArray("setFloat64", 8, acc, x, le);
-                        break;
-                    case "str": {
-                        let utf = utf8Encode(x);
-                        acc = ensure(acc, utf.length);
-                        acc.set(utf, pos);
-                        pos += utf.length;
-                        break;
-                    }
-                    default:
-                }
-                return acc;
-            },
-        ];
+        case "u8":
+          acc = ensure(acc, 1);
+          view.setUint8(pos, x);
+          pos++;
+          break;
+        case "u8a": {
+          const n = x.length;
+          acc = ensure(acc, n);
+          acc.set(x, pos);
+          pos += n;
+          break;
+        }
+        case "i16":
+          acc = ensure(acc, 2);
+          view.setInt16(pos, x, le);
+          pos += 2;
+          break;
+        case "i16a":
+          acc = setArray("setInt16", 2, acc, x, le);
+          break;
+        case "u16":
+          acc = ensure(acc, 2);
+          view.setUint16(pos, x, le);
+          pos += 2;
+          break;
+        case "u16a":
+          acc = setArray("setUint16", 2, acc, x, le);
+          break;
+        case "i24":
+          acc = ensure(acc, 4);
+          view.setInt32(pos, x, le);
+          pos += 3;
+          break;
+        case "i24a":
+          acc = setArray("setInt32", 3, acc, x, le);
+          break;
+        case "u24":
+          acc = ensure(acc, 4);
+          view.setUint32(pos, x, le);
+          pos += 3;
+          break;
+        case "u24a":
+          acc = setArray("setUint32", 3, acc, x, le);
+          break;
+        case "i32":
+          acc = ensure(acc, 4);
+          view.setInt32(pos, x, le);
+          pos += 4;
+          break;
+        case "i32a":
+          acc = setArray("setInt32", 4, acc, x, le);
+          break;
+        case "u32":
+          acc = ensure(acc, 4);
+          view.setUint32(pos, x, le);
+          pos += 4;
+          break;
+        case "u32a":
+          acc = setArray("setUint32", 4, acc, x, le);
+          break;
+        case "f32":
+          acc = ensure(acc, 4);
+          view.setFloat32(pos, x, le);
+          pos += 4;
+          break;
+        case "f32a":
+          acc = setArray("setFloat32", 4, acc, x, le);
+          break;
+        case "f64":
+          acc = ensure(acc, 8);
+          view.setFloat64(pos, x, le);
+          pos += 8;
+          break;
+        case "f64a":
+          acc = setArray("setFloat64", 8, acc, x, le);
+          break;
+        case "str": {
+          let utf = utf8Encode(x);
+          acc = ensure(acc, utf.length);
+          acc.set(utf, pos);
+          pos += utf.length;
+          break;
+        }
+        default:
+      }
+      return acc;
+    }
+  ];
 }
+export {
+  asBytes,
+  bytes,
+  f32,
+  f32array,
+  f64,
+  f64array,
+  i16,
+  i16array,
+  i24,
+  i24array,
+  i32,
+  i32array,
+  i8,
+  i8array,
+  str,
+  u16,
+  u16array,
+  u24,
+  u24array,
+  u32,
+  u32array,
+  u8,
+  u8array
+};

package/hex-dump.js

@@ -6,19 +6,29 @@ import { map } from "@thi.ng/transducers/map";
 import { mapIndexed } from "@thi.ng/transducers/map-indexed";
 import { padLast } from "@thi.ng/transducers/pad-last";
 import { partition } from "@thi.ng/transducers/partition";
-export function hexDump(...args) {
-    const iter = __iter(hexDump, args, iterator);
-    if (iter) {
-        return iter;
-    }
-    const { cols, address } = { cols: 16, address: 0, ...args[0] };
-    return comp(padLast(cols, 0), map(juxt(U8, (x) => (x > 31 && x < 127 ? String.fromCharCode(x) : "."))), partition(cols, true), map(juxt((x) => x.map((y) => y[0]).join(" "), (x) => x.map((y) => y[1]).join(""))), mapIndexed((i, [h, a]) => `${U32(address + i * cols)} | ${h} | ${a}`));
+function hexDump(...args) {
+  const iter = __iter(hexDump, args, iterator);
+  if (iter) {
+    return iter;
+  }
+  const { cols, address } = { cols: 16, address: 0, ...args[0] };
+  return comp(
+    padLast(cols, 0),
+    map(
+      juxt(U8, (x) => x > 31 && x < 127 ? String.fromCharCode(x) : ".")
+    ),
+    partition(cols, true),
+    map(
+      juxt(
+        (x) => x.map((y) => y[0]).join(" "),
+        (x) => x.map((y) => y[1]).join("")
+      )
+    ),
+    mapIndexed((i, [h, a]) => `${U32(address + i * cols)} | ${h} | ${a}`)
+  );
 }
-/**
- * Convenience wrapper for {@link hexDump}, return the hexdump as a
- * single result string.
- *
- * @param opts -
- * @param src -
- */
-export const hexDumpString = (opts, src) => [...hexDump(opts, src)].join("\n");
+const hexDumpString = (opts, src) => [...hexDump(opts, src)].join("\n");
+export {
+  hexDump,
+  hexDumpString
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/transducers-binary",
-  "version": "2.1.81",
+  "version": "2.1.82",
   "description": "Binary data related transducers & reducers",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,16 +35,17 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/binary": "^3.3.40",
-    "@thi.ng/compose": "^2.1.50",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/hex": "^2.3.23",
-    "@thi.ng/random": "^3.6.17",
-    "@thi.ng/strings": "^3.7.2",
-    "@thi.ng/transducers": "^8.8.14"
+    "@thi.ng/binary": "^3.4.0",
+    "@thi.ng/compose": "^2.1.51",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/hex": "^2.3.24",
+    "@thi.ng/random": "^3.6.18",
+    "@thi.ng/strings": "^3.7.3",
+    "@thi.ng/transducers": "^8.8.15"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -111,5 +114,5 @@
     ],
     "year": 2018
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/partition-bits.js

@@ -1,65 +1,62 @@
 import { iterator, __iter } from "@thi.ng/transducers/iterator";
 import { isReduced } from "@thi.ng/transducers/reduced";
-export function partitionBits(...args) {
-    return (__iter(partitionBits, args, iterator) ||
-        ((rfn) => {
-            const destSize = args[0];
-            const srcSize = args[1] || 8;
-            return destSize < srcSize
-                ? small(rfn, destSize, srcSize)
-                : destSize > srcSize
-                    ? large(rfn, destSize, srcSize)
-                    : rfn;
-        }));
+function partitionBits(...args) {
+  return __iter(partitionBits, args, iterator) || ((rfn) => {
+    const destSize = args[0];
+    const srcSize = args[1] || 8;
+    return destSize < srcSize ? small(rfn, destSize, srcSize) : destSize > srcSize ? large(rfn, destSize, srcSize) : rfn;
+  });
 }
 const small = ([init, complete, reduce], n, wordSize) => {
-    const maxb = wordSize - n;
-    const m1 = (1 << wordSize) - 1;
-    const m2 = (1 << n) - 1;
-    let r = 0;
-    let y = 0;
-    return [
-        init,
-        (acc) => complete(r > 0 ? reduce(acc, y) : acc),
-        (acc, x) => {
-            let b = 0;
-            do {
-                acc = reduce(acc, y + ((x >>> (maxb + r)) & m2));
-                b += n - r;
-                x = (x << (n - r)) & m1;
-                y = 0;
-                r = 0;
-            } while (b <= maxb && !isReduced(acc));
-            r = wordSize - b;
-            y = r > 0 ? (x >>> maxb) & m2 : 0;
-            return acc;
-        },
-    ];
+  const maxb = wordSize - n;
+  const m1 = (1 << wordSize) - 1;
+  const m2 = (1 << n) - 1;
+  let r = 0;
+  let y = 0;
+  return [
+    init,
+    (acc) => complete(r > 0 ? reduce(acc, y) : acc),
+    (acc, x) => {
+      let b = 0;
+      do {
+        acc = reduce(acc, y + (x >>> maxb + r & m2));
+        b += n - r;
+        x = x << n - r & m1;
+        y = 0;
+        r = 0;
+      } while (b <= maxb && !isReduced(acc));
+      r = wordSize - b;
+      y = r > 0 ? x >>> maxb & m2 : 0;
+      return acc;
+    }
+  ];
 };
 const large = ([init, complete, reduce], n, wordSize) => {
-    const m1 = (1 << wordSize) - 1;
-    let r = 0;
-    let y = 0;
-    return [
-        init,
-        (acc) => complete(r > 0 ? reduce(acc, y) : acc),
-        (acc, x) => {
-            if (r + wordSize <= n) {
-                y |= (x & m1) << (n - wordSize - r);
-                r += wordSize;
-                if (r === n) {
-                    acc = reduce(acc, y);
-                    y = 0;
-                    r = 0;
-                }
-            }
-            else {
-                const k = n - r;
-                r = wordSize - k;
-                acc = reduce(acc, y | ((x >>> r) & ((1 << k) - 1)));
-                y = (x & ((1 << r) - 1)) << (n - r);
-            }
-            return acc;
-        },
-    ];
+  const m1 = (1 << wordSize) - 1;
+  let r = 0;
+  let y = 0;
+  return [
+    init,
+    (acc) => complete(r > 0 ? reduce(acc, y) : acc),
+    (acc, x) => {
+      if (r + wordSize <= n) {
+        y |= (x & m1) << n - wordSize - r;
+        r += wordSize;
+        if (r === n) {
+          acc = reduce(acc, y);
+          y = 0;
+          r = 0;
+        }
+      } else {
+        const k = n - r;
+        r = wordSize - k;
+        acc = reduce(acc, y | x >>> r & (1 << k) - 1);
+        y = (x & (1 << r) - 1) << n - r;
+      }
+      return acc;
+    }
+  ];
+};
+export {
+  partitionBits
 };

package/random-bits.js

@@ -1,16 +1,6 @@
 import { SYSTEM } from "@thi.ng/random/system";
 import { repeatedly } from "@thi.ng/transducers/repeatedly";
-/**
- * Returns an iterator of random bits, with 1's occurring w/ given probability
- * `prob` (in the [0,1] interval). If `num` is given, only that many bits will
- * be produced.
- *
- * By default, uses system PRNG, but a custom
- * [`IRandom`](https://docs.thi.ng/umbrella/random/interfaces/IRandom.html) impl
- * can be provided via `rnd` arg.
- *
- * @param prob -
- * @param num -
- * @param rnd -
- */
-export const randomBits = (prob, num, rnd = SYSTEM) => repeatedly(() => (rnd.probability(prob) ? 1 : 0), num);
+const randomBits = (prob, num, rnd = SYSTEM) => repeatedly(() => rnd.probability(prob) ? 1 : 0, num);
+export {
+  randomBits
+};

package/utf8.js

@@ -1,145 +1,148 @@
-import { fromUtf8CodePoint, utf8Length as $utf8Length, } from "@thi.ng/strings/utf8";
+import {
+  fromUtf8CodePoint,
+  utf8Length as $utf8Length
+} from "@thi.ng/strings/utf8";
 import { compR } from "@thi.ng/transducers/compr";
 import { iterator, iterator1 } from "@thi.ng/transducers/iterator";
 import { isReduced } from "@thi.ng/transducers/reduced";
-export function utf8Decode(src) {
-    return src
-        ? [...iterator1(utf8Decode(), src)].join("")
-        : (rfn) => {
-            const r = rfn[2];
-            let state = 0;
-            let u0;
-            let u1;
-            let u2;
-            let u3;
-            let u4;
-            return compR(rfn, (acc, x) => {
-                switch (state) {
-                    case 0:
-                    default:
-                        if (x < 0x80) {
-                            return r(acc, String.fromCharCode(x));
-                        }
-                        u0 = x;
-                        state = 1;
-                        break;
-                    case 1:
-                        u1 = x & 0x3f;
-                        if ((u0 & 0xe0) === 0xc0) {
-                            state = 0;
-                            return r(acc, String.fromCharCode(((u0 & 0x1f) << 6) | u1));
-                        }
-                        state = 2;
-                        break;
-                    case 2:
-                        u2 = x & 0x3f;
-                        if ((u0 & 0xf0) === 0xe0) {
-                            state = 0;
-                            return r(acc, String.fromCharCode(((u0 & 0x0f) << 12) | (u1 << 6) | u2));
-                        }
-                        state = 3;
-                        break;
-                    case 3:
-                        u3 = x & 0x3f;
-                        if ((u0 & 0xf8) === 0xf0) {
-                            state = 0;
-                            return r(acc, fromUtf8CodePoint(((u0 & 7) << 18) |
-                                (u1 << 12) |
-                                (u2 << 6) |
-                                u3));
-                        }
-                        state = 4;
-                        break;
-                    case 4:
-                        u4 = x & 0x3f;
-                        if ((u0 & 0xfc) === 0xf8) {
-                            state = 0;
-                            return r(acc, fromUtf8CodePoint(((u0 & 3) << 24) |
-                                (u1 << 18) |
-                                (u2 << 12) |
-                                (u3 << 6) |
-                                u4));
-                        }
-                        state = 5;
-                        break;
-                    case 5:
-                        state = 0;
-                        return r(acc, fromUtf8CodePoint(((u0 & 1) << 30) |
-                            (u1 << 24) |
-                            (u2 << 18) |
-                            (u3 << 12) |
-                            (u4 << 6) |
-                            (x & 0x3f)));
-                }
-                return acc;
-            });
-        };
+function utf8Decode(src) {
+  return src ? [...iterator1(utf8Decode(), src)].join("") : (rfn) => {
+    const r = rfn[2];
+    let state = 0;
+    let u0;
+    let u1;
+    let u2;
+    let u3;
+    let u4;
+    return compR(rfn, (acc, x) => {
+      switch (state) {
+        case 0:
+        default:
+          if (x < 128) {
+            return r(acc, String.fromCharCode(x));
+          }
+          u0 = x;
+          state = 1;
+          break;
+        case 1:
+          u1 = x & 63;
+          if ((u0 & 224) === 192) {
+            state = 0;
+            return r(
+              acc,
+              String.fromCharCode((u0 & 31) << 6 | u1)
+            );
+          }
+          state = 2;
+          break;
+        case 2:
+          u2 = x & 63;
+          if ((u0 & 240) === 224) {
+            state = 0;
+            return r(
+              acc,
+              String.fromCharCode(
+                (u0 & 15) << 12 | u1 << 6 | u2
+              )
+            );
+          }
+          state = 3;
+          break;
+        case 3:
+          u3 = x & 63;
+          if ((u0 & 248) === 240) {
+            state = 0;
+            return r(
+              acc,
+              fromUtf8CodePoint(
+                (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u3
+              )
+            );
+          }
+          state = 4;
+          break;
+        case 4:
+          u4 = x & 63;
+          if ((u0 & 252) === 248) {
+            state = 0;
+            return r(
+              acc,
+              fromUtf8CodePoint(
+                (u0 & 3) << 24 | u1 << 18 | u2 << 12 | u3 << 6 | u4
+              )
+            );
+          }
+          state = 5;
+          break;
+        case 5:
+          state = 0;
+          return r(
+            acc,
+            fromUtf8CodePoint(
+              (u0 & 1) << 30 | u1 << 24 | u2 << 18 | u3 << 12 | u4 << 6 | x & 63
+            )
+          );
+      }
+      return acc;
+    });
+  };
 }
-export function utf8Encode(src) {
-    return src != null
-        ? new Uint8Array([...iterator(utf8Encode(), src)])
-        : (rfn) => {
-            const r = rfn[2];
-            return compR(rfn, (acc, x) => {
-                let u = x.charCodeAt(0), buf;
-                if (u >= 0xd800 && u <= 0xdfff) {
-                    u =
-                        (0x10000 + ((u & 0x3ff) << 10)) |
-                            (x.charCodeAt(1) & 0x3ff);
-                }
-                if (u < 0x80) {
-                    return r(acc, u);
-                }
-                else if (u < 0x800) {
-                    buf = [0xc0 | (u >> 6), 0x80 | (u & 0x3f)];
-                }
-                else if (u < 0x10000) {
-                    buf = [
-                        0xe0 | (u >> 12),
-                        0x80 | ((u >> 6) & 0x3f),
-                        0x80 | (u & 0x3f),
-                    ];
-                }
-                else if (u < 0x200000) {
-                    buf = [
-                        0xf0 | (u >> 18),
-                        0x80 | ((u >> 12) & 0x3f),
-                        0x80 | ((u >> 6) & 0x3f),
-                        0x80 | (u & 0x3f),
-                    ];
-                }
-                else if (u < 0x4000000) {
-                    buf = [
-                        0xf8 | (u >> 24),
-                        0x80 | ((u >> 18) & 0x3f),
-                        0x80 | ((u >> 12) & 0x3f),
-                        0x80 | ((u >> 6) & 0x3f),
-                        0x80 | (u & 0x3f),
-                    ];
-                }
-                else {
-                    buf = [
-                        0xfc | (u >> 30),
-                        0x80 | ((u >> 24) & 0x3f),
-                        0x80 | ((u >> 18) & 0x3f),
-                        0x80 | ((u >> 12) & 0x3f),
-                        0x80 | ((u >> 6) & 0x3f),
-                        0x80 | (u & 0x3f),
-                    ];
-                }
-                for (let i = 0, n = buf.length; i < n; i++) {
-                    acc = r(acc, buf[i]);
-                    if (isReduced(acc)) {
-                        break;
-                    }
-                }
-                return acc;
-            });
-        };
+function utf8Encode(src) {
+  return src != null ? new Uint8Array([...iterator(utf8Encode(), src)]) : (rfn) => {
+    const r = rfn[2];
+    return compR(rfn, (acc, x) => {
+      let u = x.charCodeAt(0), buf;
+      if (u >= 55296 && u <= 57343) {
+        u = 65536 + ((u & 1023) << 10) | x.charCodeAt(1) & 1023;
+      }
+      if (u < 128) {
+        return r(acc, u);
+      } else if (u < 2048) {
+        buf = [192 | u >> 6, 128 | u & 63];
+      } else if (u < 65536) {
+        buf = [
+          224 | u >> 12,
+          128 | u >> 6 & 63,
+          128 | u & 63
+        ];
+      } else if (u < 2097152) {
+        buf = [
+          240 | u >> 18,
+          128 | u >> 12 & 63,
+          128 | u >> 6 & 63,
+          128 | u & 63
+        ];
+      } else if (u < 67108864) {
+        buf = [
+          248 | u >> 24,
+          128 | u >> 18 & 63,
+          128 | u >> 12 & 63,
+          128 | u >> 6 & 63,
+          128 | u & 63
+        ];
+      } else {
+        buf = [
+          252 | u >> 30,
+          128 | u >> 24 & 63,
+          128 | u >> 18 & 63,
+          128 | u >> 12 & 63,
+          128 | u >> 6 & 63,
+          128 | u & 63
+        ];
+      }
+      for (let i = 0, n = buf.length; i < n; i++) {
+        acc = r(acc, buf[i]);
+        if (isReduced(acc)) {
+          break;
+        }
+      }
+      return acc;
+    });
+  };
 }
-/**
- * Re-export of [utf8Length()](https://docs.thi.ng/umbrella/strings/functions/utf8Length.html).
- *
- * @deprecated migrated to thi.ng/strings pkg
- */
-export const utf8Length = $utf8Length;
+const utf8Length = $utf8Length;
+export {
+  utf8Decode,
+  utf8Encode,
+  utf8Length
+};