@thi.ng/bencode 2.1.8 → 2.1.11

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2022-05-07T11:33:35Z
+- **Last updated**: 2022-06-09T16:14:01Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/decode.js

@@ -11,35 +11,35 @@ export const decode = (buf, utf8 = true) => {
     while (!(i = iter.next()).done) {
         x = i.value;
         switch (x) {
-            case 100 /* DICT */:
+            case 100 /* Lit.DICT */:
                 ensureNotKey(stack, "dict");
-                stack.push({ type: 4 /* DICT */, val: {} });
+                stack.push({ type: 4 /* Type.DICT */, val: {} });
                 break;
-            case 108 /* LIST */:
+            case 108 /* Lit.LIST */:
                 ensureNotKey(stack, "list");
-                stack.push({ type: 5 /* LIST */, val: [] });
+                stack.push({ type: 5 /* Type.LIST */, val: [] });
                 break;
-            case 105 /* INT */:
+            case 105 /* Lit.INT */:
                 x = collect(stack, readInt(iter, 0));
                 if (x !== undefined) {
                     return x;
                 }
                 break;
-            case 102 /* FLOAT */:
+            case 102 /* Lit.FLOAT */:
                 x = collect(stack, readFloat(iter));
                 if (x !== undefined) {
                     return x;
                 }
                 break;
-            case 101 /* END */:
+            case 101 /* Lit.END */:
                 x = stack.pop();
                 if (x) {
                     const parent = peek(stack);
                     if (parent) {
-                        if (parent.type === 5 /* LIST */) {
+                        if (parent.type === 5 /* Type.LIST */) {
                             parent.val.push(x.val);
                         }
-                        else if (parent.type === 4 /* DICT */) {
+                        else if (parent.type === 4 /* Type.DICT */) {
                             parent.val[parent.key] = x.val;
                             parent.key = null;
                         }
@@ -53,8 +53,8 @@ export 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 >= 48 /* Lit.ZERO */ && x <= 57 /* Lit.NINE */) {
+                    x = readBytes(iter, readInt(iter, x - 48 /* Lit.ZERO */, 58 /* Lit.COLON */));
                     x = collect(stack, x, utf8);
                     if (x !== undefined) {
                         return x;
@@ -69,13 +69,13 @@ export 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 !== 4 /* 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 */) {
+    if (parent.type === 5 /* Type.LIST */) {
         parent.val.push(utf8 && isArray(x) ? utf8Decode(x) : x);
     }
     else {
@@ -88,16 +88,16 @@ const collect = (stack, x, utf8 = false) => {
         }
     }
 };
-const readInt = (iter, acc, end = 101 /* END */) => {
+const readInt = (iter, acc, end = 101 /* Lit.END */) => {
     let i;
     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 */;
+        if (x >= 48 /* Lit.ZERO */ && x <= 57 /* Lit.NINE */) {
+            acc = acc * 10 + x - 48 /* Lit.ZERO */;
         }
-        else if (x === 45 /* MINUS */) {
+        else if (x === 45 /* Lit.MINUS */) {
             assert(!isSigned, `invalid int literal`);
             isSigned = true;
         }
@@ -116,12 +116,12 @@ const readFloat = (iter) => {
     let acc = "";
     while (!(i = iter.next()).done) {
         x = i.value;
-        if ((x >= 48 /* ZERO */ && x <= 57 /* NINE */) ||
-            x === 46 /* DOT */ ||
-            x === 45 /* MINUS */) {
+        if ((x >= 48 /* Lit.ZERO */ && x <= 57 /* Lit.NINE */) ||
+            x === 46 /* Lit.DOT */ ||
+            x === 45 /* Lit.MINUS */) {
             acc += String.fromCharCode(x);
         }
-        else if (x === 101 /* END */) {
+        else if (x === 101 /* Lit.END */) {
             return parseFloat(acc);
         }
         else {

package/encode.js

@@ -13,42 +13,42 @@ const FLOAT_RE = /^[0-9.-]+$/;
 export const encode = (x, cap = 1024) => bytes(cap, encodeBin(x));
 const encodeBin = defmulti((x) => isNumber(x)
     ? Math.floor(x) !== x
-        ? 1 /* FLOAT */
-        : 0 /* INT */
+        ? 1 /* Type.FLOAT */
+        : 0 /* Type.INT */
     : isBoolean(x)
-        ? 0 /* INT */
+        ? 0 /* Type.INT */
         : isString(x)
-            ? 2 /* STR */
+            ? 2 /* Type.STR */
             : x instanceof Uint8Array
-                ? 3 /* BINARY */
+                ? 3 /* Type.BINARY */
                 : isArrayLike(x)
-                    ? 5 /* LIST */
+                    ? 5 /* Type.LIST */
                     : isPlainObject(x)
-                        ? 4 /* DICT */
+                        ? 4 /* Type.DICT */
                         : unsupported(`unsupported data type: ${x}`), {}, {
-    [0 /* INT */]: (x) => {
+    [0 /* Type.INT */]: (x) => {
         __ensureValidNumber(x);
         return [str(`i${Math.floor(x)}e`)];
     },
-    [1 /* FLOAT */]: (x) => {
+    [1 /* Type.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) => [
+    [3 /* Type.BINARY */]: (buf) => [
         str(buf.length + ":"),
         u8array(buf),
     ],
-    [2 /* STR */]: (x) => [str(utf8Length(x) + ":" + x)],
-    [5 /* LIST */]: (x) => [
-        u8(108 /* LIST */),
+    [2 /* Type.STR */]: (x) => [str(utf8Length(x) + ":" + x)],
+    [5 /* Type.LIST */]: (x) => [
+        u8(108 /* Lit.LIST */),
         ...mapcat(encodeBin, x),
-        u8(101 /* END */),
+        u8(101 /* Lit.END */),
     ],
-    [4 /* DICT */]: (x) => [
-        u8(100 /* DICT */),
+    [4 /* Type.DICT */]: (x) => [
+        u8(100 /* Lit.DICT */),
         ...mapcat((k) => encodeBin(k).concat(encodeBin(x[k])), Object.keys(x).sort()),
-        u8(101 /* END */),
+        u8(101 /* Lit.END */),
     ],
 });
 /** @internal */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/bencode",
-  "version": "2.1.8",
+  "version": "2.1.11",
   "description": "Bencode binary encoder / decoder with optional UTF8 encoding & floating point support",
   "type": "module",
   "module": "./index.js",
@@ -34,20 +34,20 @@
     "test": "testament test"
   },
   "dependencies": {
-    "@thi.ng/arrays": "^2.2.3",
-    "@thi.ng/checks": "^3.1.6",
-    "@thi.ng/defmulti": "^2.1.6",
-    "@thi.ng/errors": "^2.1.6",
-    "@thi.ng/transducers": "^8.3.3",
-    "@thi.ng/transducers-binary": "^2.1.8"
+    "@thi.ng/arrays": "^2.3.0",
+    "@thi.ng/checks": "^3.2.1",
+    "@thi.ng/defmulti": "^2.1.7",
+    "@thi.ng/errors": "^2.1.7",
+    "@thi.ng/transducers": "^8.3.6",
+    "@thi.ng/transducers-binary": "^2.1.11"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.23.1",
-    "@thi.ng/testament": "^0.2.7",
+    "@microsoft/api-extractor": "^7.25.0",
+    "@thi.ng/testament": "^0.2.8",
     "rimraf": "^3.0.2",
     "tools": "^0.0.1",
-    "typedoc": "^0.22.15",
-    "typescript": "^4.6.4"
+    "typedoc": "^0.22.17",
+    "typescript": "^4.7.3"
   },
   "keywords": [
     "array",
@@ -79,5 +79,5 @@
       "default": "./encode.js"
     }
   },
-  "gitHead": "e23901b8582af71d8a29e0ce4929f15ac509f9e5\n"
+  "gitHead": "e64b1ab39ae9bcc494ef006f6329e5182fa2a326\n"
 }