@thi.ng/bencode 2.1.147 → 3.0.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-12-27T14:11:37Z
+- **Last updated**: 2025-01-14T12:23:33Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,21 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+# [3.0.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/bencode@3.0.0) (2025-01-14)
+
+#### 🛑 Breaking changes
+
+- major internal refactor & MUCH faster decode ([ce6d528](https://github.com/thi-ng/umbrella/commit/ce6d528))
+- BREAKING CHANGE: `decode()` now requires `Uint8Array` as input
+  - update `decode()` & `encode()` internals
+  - update non-UTF-8 decoding (also add note to readme)
+  - avoid use of iterators in `decode()`
+  - update `__readBytes()` to return sub-arrays (zero copy op)
+  - remove [@thi.ng/defmulti](https://github.com/thi-ng/umbrella/tree/main/packages/defmulti) dependency
+  - remove internal use of `const enum`s
+  - update tests
+  - update readme
+
 ### [2.1.128](https://github.com/thi-ng/umbrella/tree/@thi.ng/bencode@2.1.128) (2024-07-22)
 
 #### 🩹 Bug fixes

package/README.md

@@ -43,6 +43,12 @@ All JS strings will be UTF-8 encoded. To write raw bytes without
 transformation, wrap them as `Uint8Array`. These too will be written as
 Bencode strings (e.g. `len:xxx...`), but are used as is.
 
+When decoding, UTF-8 is used by default, but can be disabled by passing `false`
+as 2nd argument to
+[`decode()`](https://docs.thi.ng/umbrella/bencode/functions/decode.html). In
+that case, strings will be decoded as `Uint8Array`s, with the exception of
+dictionary keys, which will be decoded via `String.fromCharCode()`.
+
 #### Floating point values
 
 This implementation has optional (non-standard) support for floating point
@@ -86,18 +92,20 @@ For Node.js REPL:
 const bc = await import("@thi.ng/bencode");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1.18 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 1.22 KB
 
 ## Dependencies
 
+- [@thi.ng/api](https://github.com/thi-ng/umbrella/tree/develop/packages/api)
 - [@thi.ng/arrays](https://github.com/thi-ng/umbrella/tree/develop/packages/arrays)
 - [@thi.ng/checks](https://github.com/thi-ng/umbrella/tree/develop/packages/checks)
-- [@thi.ng/defmulti](https://github.com/thi-ng/umbrella/tree/develop/packages/defmulti)
 - [@thi.ng/errors](https://github.com/thi-ng/umbrella/tree/develop/packages/errors)
 - [@thi.ng/strings](https://github.com/thi-ng/umbrella/tree/develop/packages/strings)
 - [@thi.ng/transducers](https://github.com/thi-ng/umbrella/tree/develop/packages/transducers)
 - [@thi.ng/transducers-binary](https://github.com/thi-ng/umbrella/tree/develop/packages/transducers-binary)
 
+Note: @thi.ng/api is in _most_ cases a type-only import (not used at runtime)
+
 ## API
 
 [Generated API docs](https://docs.thi.ng/umbrella/bencode/)
@@ -145,4 +153,4 @@ If this project contributes to an academic publication, please cite it as:
 
 ## License
 
-© 2016 - 2024 Karsten Schmidt // Apache License 2.0
+© 2016 - 2025 Karsten Schmidt // Apache License 2.0

package/decode.d.ts

@@ -1,2 +1,13 @@
-export declare const decode: (buf: Iterable<number>, utf8?: boolean) => any;
+/**
+ * Decodes given byte array back into JS data(structure).
+ *
+ * @remarks
+ * UTF-8 is used by default, but can be disabled by setting `utf8` to false. In
+ * that case, strings will be decoded as `Uint8Array`s, with the exception of
+ * dictionary keys, which will be decoded via `String.fromCharCode()`.
+ *
+ * @param buf
+ * @param utf8
+ */
+export declare const decode: (buf: Uint8Array, utf8?: boolean) => any;
 //# sourceMappingURL=decode.d.ts.map

package/decode.js

@@ -1,66 +1,54 @@
 import { peek } from "@thi.ng/arrays/peek";
-import { isArray } from "@thi.ng/checks/is-array";
 import { assert } from "@thi.ng/errors/assert";
 import { illegalState } from "@thi.ng/errors/illegal-state";
 import { utf8Decode } from "@thi.ng/transducers-binary/utf8";
-var Type = /* @__PURE__ */ ((Type2) => {
-  Type2[Type2["INT"] = 0] = "INT";
-  Type2[Type2["FLOAT"] = 1] = "FLOAT";
-  Type2[Type2["STR"] = 2] = "STR";
-  Type2[Type2["BINARY"] = 3] = "BINARY";
-  Type2[Type2["DICT"] = 4] = "DICT";
-  Type2[Type2["LIST"] = 5] = "LIST";
-  return Type2;
-})(Type || {});
-var Lit = /* @__PURE__ */ ((Lit2) => {
-  Lit2[Lit2["MINUS"] = 45] = "MINUS";
-  Lit2[Lit2["DOT"] = 46] = "DOT";
-  Lit2[Lit2["ZERO"] = 48] = "ZERO";
-  Lit2[Lit2["NINE"] = 57] = "NINE";
-  Lit2[Lit2["COLON"] = 58] = "COLON";
-  Lit2[Lit2["DICT"] = 100] = "DICT";
-  Lit2[Lit2["END"] = 101] = "END";
-  Lit2[Lit2["FLOAT"] = 102] = "FLOAT";
-  Lit2[Lit2["INT"] = 105] = "INT";
-  Lit2[Lit2["LIST"] = 108] = "LIST";
-  return Lit2;
-})(Lit || {});
+const [MINUS, DOT, ZERO, NINE, COLON, DICT, END, FLOAT, INT, LIST] = [
+  45,
+  46,
+  48,
+  57,
+  58,
+  100,
+  101,
+  102,
+  105,
+  108
+];
 const decode = (buf, utf8 = true) => {
-  const iter = buf[Symbol.iterator]();
+  const ctx = { i: 0, n: buf.length, buf };
   const stack = [];
-  let i;
   let x;
-  while (!(i = iter.next()).done) {
-    x = i.value;
+  while (ctx.i < buf.length) {
+    x = buf[ctx.i++];
     switch (x) {
-      case 100 /* DICT */:
+      case DICT:
         __ensureNotKey(stack, "dict");
-        stack.push({ type: 4 /* DICT */, val: {} });
+        stack.push({ type: DICT, val: {} });
         break;
-      case 108 /* LIST */:
+      case LIST:
         __ensureNotKey(stack, "list");
-        stack.push({ type: 5 /* LIST */, val: [] });
+        stack.push({ type: LIST, val: [] });
         break;
-      case 105 /* INT */:
-        x = __collect(stack, __readInt(iter, 0));
+      case INT:
+        x = __collect(stack, __readInt(ctx, 0));
         if (x !== void 0) {
           return x;
         }
         break;
-      case 102 /* FLOAT */:
-        x = __collect(stack, __readFloat(iter));
+      case FLOAT:
+        x = __collect(stack, __readFloat(ctx));
         if (x !== void 0) {
           return x;
         }
         break;
-      case 101 /* END */:
+      case END:
         x = stack.pop();
         if (x) {
           const parent = peek(stack);
           if (parent) {
-            if (parent.type === 5 /* LIST */) {
+            if (parent.type === LIST) {
               parent.val.push(x.val);
-            } else if (parent.type === 4 /* DICT */) {
+            } else if (parent.type === DICT) {
               parent.val[parent.key] = x.val;
               parent.key = null;
             }
@@ -72,19 +60,14 @@ const decode = (buf, utf8 = true) => {
         }
         break;
       default:
-        if (x >= 48 /* ZERO */ && x <= 57 /* NINE */) {
-          x = __readBytes(
-            iter,
-            __readInt(iter, x - 48 /* ZERO */, 58 /* COLON */)
-          );
+        if (x >= ZERO && x <= NINE) {
+          x = __readBytes(ctx, __readInt(ctx, x - ZERO, COLON));
           x = __collect(stack, x, utf8);
           if (x !== void 0) {
             return x;
           }
         } else {
-          illegalState(
-            `unexpected value type: 0x${i.value.toString(16)}`
-          );
+          illegalState(`unexpected value type: 0x${x.toString(16)}`);
         }
     }
   }
@@ -92,34 +75,31 @@ const decode = (buf, utf8 = true) => {
 };
 const __ensureNotKey = (stack, type) => {
   const x = peek(stack);
-  assert(
-    !x || x.type !== 4 /* DICT */ || x.key,
-    type + " not supported as dict key"
-  );
+  assert(!x || x.type !== DICT || x.key, type + " not supported as dict key");
 };
 const __collect = (stack, x, utf8 = false) => {
   const parent = peek(stack);
   if (!parent) return x;
-  if (parent.type === 5 /* LIST */) {
-    parent.val.push(utf8 && isArray(x) ? utf8Decode(x) : x);
+  utf8 &&= x instanceof Uint8Array;
+  if (parent.type === LIST) {
+    parent.val.push(utf8 ? utf8Decode(x) : x);
   } else {
     if (!parent.key) {
-      parent.key = isArray(x) ? utf8Decode(x) : x;
+      parent.key = utf8 ? utf8Decode(x) : __decodeAscii(x);
     } else {
       parent.val[parent.key] = utf8 ? utf8Decode(x) : x;
       parent.key = null;
     }
   }
 };
-const __readInt = (iter, acc, end = 101 /* END */) => {
-  let i;
+const __readInt = (ctx, acc, end = END) => {
   let x;
   let isSigned = false;
-  while (!(i = iter.next()).done) {
-    x = i.value;
-    if (x >= 48 /* ZERO */ && x <= 57 /* NINE */) {
-      acc = acc * 10 + x - 48 /* ZERO */;
-    } else if (x === 45 /* MINUS */) {
+  while (ctx.i < ctx.n) {
+    x = ctx.buf[ctx.i++];
+    if (x >= ZERO && x <= NINE) {
+      acc = acc * 10 + x - ZERO;
+    } else if (x === MINUS) {
       assert(!isSigned, `invalid int literal`);
       isSigned = true;
     } else if (x === end) {
@@ -130,29 +110,31 @@ const __readInt = (iter, acc, end = 101 /* END */) => {
   }
   illegalState(`incomplete int`);
 };
-const __readFloat = (iter) => {
-  let i;
+const __readFloat = (ctx) => {
   let x;
   let acc = "";
-  while (!(i = iter.next()).done) {
-    x = i.value;
-    if (x >= 48 /* ZERO */ && x <= 57 /* NINE */ || x === 46 /* DOT */ || x === 45 /* MINUS */) {
+  while (ctx.i < ctx.n) {
+    x = ctx.buf[ctx.i++];
+    if (x >= ZERO && x <= NINE || x === DOT || x === MINUS) {
       acc += String.fromCharCode(x);
-    } else if (x === 101 /* END */) {
-      return parseFloat(acc);
+    } else if (x === END) {
+      return +acc;
     } else {
       illegalState(`expected digit or dot, got 0x${x.toString(16)}`);
     }
   }
   illegalState(`incomplete float`);
 };
-const __readBytes = (iter, len) => {
-  let i;
-  let buf = [];
-  while (len-- > 0 && !(i = iter.next()).done) {
-    buf.push(i.value);
-  }
-  return len < 0 ? buf : illegalState(`expected string, reached EOF`);
+const __readBytes = (ctx, len) => {
+  if (ctx.i + len > ctx.n)
+    illegalState(`expected ${len} bytes, but reached EOF`);
+  return ctx.buf.subarray(ctx.i, ctx.i += len);
+};
+const __decodeAscii = (buf) => {
+  let res = "";
+  for (let i = 0, n = buf.length; i < n; i++)
+    res += String.fromCharCode(buf[i]);
+  return res;
 };
 export {
   decode

package/encode.js

@@ -3,65 +3,39 @@ import { isBoolean } from "@thi.ng/checks/is-boolean";
 import { isNumber } from "@thi.ng/checks/is-number";
 import { isPlainObject } from "@thi.ng/checks/is-plain-object";
 import { isString } from "@thi.ng/checks/is-string";
-import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { assert } from "@thi.ng/errors/assert";
 import { unsupported } from "@thi.ng/errors/unsupported";
 import { utf8Length } from "@thi.ng/strings/utf8";
 import { bytes, str, u8, u8array } from "@thi.ng/transducers-binary/bytes";
 import { mapcat } from "@thi.ng/transducers/mapcat";
-var Type = /* @__PURE__ */ ((Type2) => {
-  Type2[Type2["INT"] = 0] = "INT";
-  Type2[Type2["FLOAT"] = 1] = "FLOAT";
-  Type2[Type2["STR"] = 2] = "STR";
-  Type2[Type2["BINARY"] = 3] = "BINARY";
-  Type2[Type2["DICT"] = 4] = "DICT";
-  Type2[Type2["LIST"] = 5] = "LIST";
-  return Type2;
-})(Type || {});
-var Lit = /* @__PURE__ */ ((Lit2) => {
-  Lit2[Lit2["DICT"] = 100] = "DICT";
-  Lit2[Lit2["END"] = 101] = "END";
-  Lit2[Lit2["LIST"] = 108] = "LIST";
-  return Lit2;
-})(Lit || {});
 const FLOAT_RE = /^[0-9.-]+$/;
+const ENCODERS = {
+  i: (x) => {
+    __ensureValidNumber(x);
+    return [str(`i${Math.floor(x)}e`)];
+  },
+  f: (x) => {
+    __ensureValidNumber(x);
+    assert(
+      FLOAT_RE.test(x.toString()),
+      `values requiring exponential notation not allowed (${x})`
+    );
+    return [str(`f${x}e`)];
+  },
+  b: (buf) => [str(buf.length + ":"), u8array(buf)],
+  s: (x) => [str(utf8Length(x) + ":" + x)],
+  l: (x) => [u8(108), ...mapcat(__encodeBin, x), u8(101)],
+  d: (x) => [
+    u8(100),
+    ...mapcat(
+      (k) => __encodeBin(k).concat(__encodeBin(x[k])),
+      Object.keys(x).sort()
+    ),
+    u8(101)
+  ]
+};
 const encode = (x, cap = 1024) => bytes(cap, __encodeBin(x));
-const __encodeBin = defmulti(
-  (x) => isNumber(x) ? Math.floor(x) !== x ? 1 /* FLOAT */ : 0 /* INT */ : isBoolean(x) ? 0 /* INT */ : isString(x) ? 2 /* STR */ : x instanceof Uint8Array ? 3 /* BINARY */ : isPlainObject(x) ? 4 /* DICT */ : isArrayLike(x) ? 5 /* LIST */ : unsupported(`unsupported data type: ${x}`),
-  {},
-  {
-    [0 /* INT */]: (x) => {
-      __ensureValidNumber(x);
-      return [str(`i${Math.floor(x)}e`)];
-    },
-    [1 /* FLOAT */]: (x) => {
-      __ensureValidNumber(x);
-      assert(
-        FLOAT_RE.test(x.toString()),
-        `values requiring exponential notation not allowed (${x})`
-      );
-      return [str(`f${x}e`)];
-    },
-    [3 /* BINARY */]: (buf) => [
-      str(buf.length + ":"),
-      u8array(buf)
-    ],
-    [2 /* STR */]: (x) => [str(utf8Length(x) + ":" + x)],
-    [5 /* LIST */]: (x) => [
-      u8(108 /* LIST */),
-      ...mapcat(__encodeBin, x),
-      u8(101 /* END */)
-    ],
-    [4 /* DICT */]: (x) => [
-      u8(100 /* DICT */),
-      ...mapcat(
-        (k) => __encodeBin(k).concat(__encodeBin(x[k])),
-        Object.keys(x).sort()
-      ),
-      u8(101 /* END */)
-    ]
-  }
-);
+const __encodeBin = (x) => ENCODERS[isNumber(x) ? Math.floor(x) !== x ? "f" : "i" : isBoolean(x) ? "i" : isString(x) ? "s" : x instanceof Uint8Array ? "b" : isPlainObject(x) ? "d" : isArrayLike(x) ? "l" : unsupported(`unsupported data type: ${x}`)](x);
 const __ensureValidNumber = (x) => {
   assert(isFinite(x), `can't encode infinite value`);
   assert(!isNaN(x), `can't encode NaN`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/bencode",
-  "version": "2.1.147",
+  "version": "3.0.0",
   "description": "Bencode binary encoder / decoder with optional UTF8 encoding & floating point support",
   "type": "module",
   "module": "./index.js",
@@ -40,13 +40,13 @@
     "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
   },
   "dependencies": {
-    "@thi.ng/arrays": "^2.10.8",
-    "@thi.ng/checks": "^3.6.17",
-    "@thi.ng/defmulti": "^3.0.53",
-    "@thi.ng/errors": "^2.5.21",
-    "@thi.ng/strings": "^3.8.13",
-    "@thi.ng/transducers": "^9.2.11",
-    "@thi.ng/transducers-binary": "^2.1.145"
+    "@thi.ng/api": "^8.11.16",
+    "@thi.ng/arrays": "^2.10.10",
+    "@thi.ng/checks": "^3.6.19",
+    "@thi.ng/errors": "^2.5.22",
+    "@thi.ng/strings": "^3.9.0",
+    "@thi.ng/transducers": "^9.2.13",
+    "@thi.ng/transducers-binary": "^2.1.147"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.48.1",
@@ -89,5 +89,5 @@
   "thi.ng": {
     "alias": "bc"
   },
-  "gitHead": "48bf4c22bf23f88ac99f435106af2214f79a0be1\n"
+  "gitHead": "6542b842120bef47cc18d45a1b1db68307a7f04b\n"
 }