@prosopo/account 1.0.1 → 2.0.0

package/dist/cjs/extension/ExtensionWeb2.cjs

@@ -1,17 +1,15 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const Api = require("@polkadot/api/promise/Api");
-const Extension = require("./Extension.cjs");
-const keyring = require("@polkadot/keyring");
-require("../common/dist/index.cjs");
 const Signer = require("@polkadot/extension-base/page/Signer");
-const ws = require("@polkadot/rpc-provider/ws");
-const address = require("@polkadot/util-crypto/address");
+const keyring = require("@polkadot/keyring");
+const utilCrypto = require("@polkadot/util-crypto");
 const bip39 = require("@polkadot/util-crypto/mnemonic/bip39");
-const fingerprintjs = require("@fingerprintjs/fingerprintjs");
-require("../util/dist/index.cjs");
 const string = require("@polkadot/util/string");
 const u8a = require("@polkadot/util/u8a");
+require("../common/dist/index.cjs");
+const index = require("../detector/src/index.cjs");
+require("../util/dist/index.cjs");
+const Extension = require("./Extension.cjs");
 const error = require("../common/dist/error.cjs");
 const version = require("../util/dist/version.cjs");
 const canvas = require("../util/dist/canvas.cjs");
@@ -23,16 +21,16 @@ class ExtensionWeb2 extends Extension.Extension {
       const network = config.networks[config.defaultNetwork];
       if (!network) {
         throw new error.ProsopoEnvError("DEVELOPER.NETWORK_NOT_FOUND", {
-          context: { error: `No network found for environment ${config.defaultEnvironment}` }
+          context: {
+            error: `No network found for environment ${config.defaultEnvironment}`
+          }
         });
       }
       return network;
     };
   }
   async getAccount(config) {
-    const network = this.getNetwork(config);
-    const wsProvider = new ws.WsProvider(network.endpoint);
-    const account = await this.createAccount(wsProvider);
+    const account = await this.createAccount(config);
     const extension = await this.createExtension(account);
     return {
       account,
@@ -67,7 +65,8 @@ class ExtensionWeb2 extends Extension.Extension {
       signer
     };
   }
-  async createAccount(wsProvider) {
+  async createAccount(config) {
+    await utilCrypto.cryptoWaitReady();
     const params = {
       area: { width: 300, height: 300 },
       offsetParameter: 2001000001,
@@ -77,29 +76,30 @@ class ExtensionWeb2 extends Extension.Extension {
       numberOfRounds: 5,
       seed: 42
     };
-    const browserEntropy = await this.getFingerprint();
-    const canvasEntropy = canvas.picassoCanvas(params.numberOfRounds, params.seed, params);
-    const entropy = hash.hexHash([canvasEntropy, browserEntropy].join(""), 128).slice(2);
+    const browserEntropy = await index.getFingerprint();
+    const canvasEntropy = canvas.picassoCanvas(
+      params.numberOfRounds,
+      params.seed,
+      params
+    );
+    const entropy = hash.hexHash(
+      [canvasEntropy, browserEntropy].join(""),
+      128
+    ).slice(2);
     const u8Entropy = string.stringToU8a(entropy);
     const mnemonic = bip39.entropyToMnemonic(u8Entropy);
-    const api = await Api.ApiPromise.create({ provider: wsProvider, initWasm: false, noInitWarn: true });
-    const type = "ed25519";
-    const keyring$1 = new keyring.Keyring({ type, ss58Format: api.registry.chainSS58 });
+    const type = "sr25519";
+    const keyring$1 = new keyring.Keyring({
+      type,
+      ss58Format: config.networks[config.defaultNetwork].ss58Format
+    });
     const keypair = keyring$1.addFromMnemonic(mnemonic);
-    const address$1 = keypair.address.length === 42 ? keypair.address : address.encodeAddress(address.decodeAddress(keypair.address), api.registry.chainSS58);
+    const address = keypair.address;
     return {
-      address: address$1,
-      type,
-      name: address$1,
+      address,
+      name: address,
       keypair
     };
   }
-  async getFingerprint() {
-    const fpPromise = fingerprintjs.load();
-    const fp = await fpPromise;
-    const result = await fp.get();
-    const { screenFrame, ...componentsReduced } = result.components;
-    return fingerprintjs.hashComponents(componentsReduced);
-  }
 }
 exports.ExtensionWeb2 = ExtensionWeb2;

package/dist/cjs/extension/ExtensionWeb3.cjs

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const Extension = require("./Extension.cjs");
-require("../common/dist/index.cjs");
 const extensionDapp = require("@polkadot/extension-dapp");
+require("../common/dist/index.cjs");
+const Extension = require("./Extension.cjs");
 const error = require("../common/dist/error.cjs");
 class ExtensionWeb3 extends Extension.Extension {
   async getAccount(config) {
     const { dappName, userAccountAddress: address } = config;
     if (!address) {
-      throw new error.ProsopoError("WIDGET.NO_ACCOUNTS_FOUND", { context: { error: "No account address provided" } });
+      throw new error.ProsopoError("WIDGET.NO_ACCOUNTS_FOUND", {
+        context: { error: "No account address provided" }
+      });
     }
     const extensions = await extensionDapp.web3Enable(dappName);
     if (extensions.length === 0) {

package/dist/cjs/util/dist/at.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function at(items, index, options) {
+  if (items.length === 0) {
+    throw new Error("Array is empty");
+  }
+  if (!Number.isFinite(index)) {
+    throw new Error(`Index ${index} is not a finite number`);
+  }
+  if (!options?.noWrap) {
+    if (index > 0) {
+      index = index % items.length;
+    } else {
+      index = Math.ceil(Math.abs(index) / items.length) * items.length + index;
+    }
+  }
+  if (index >= items.length) {
+    throw new Error(`Index ${index} larger than array length ${items.length}`);
+  }
+  if (index < 0) {
+    throw new Error(`Index ${index} smaller than 0`);
+  }
+  return items[index];
+}
+exports.at = at;

package/dist/cjs/util/dist/canvas.cjs

@@ -1,80 +1,86 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./index.cjs");
-const util = require("./util.cjs");
+const at = require("./at.cjs");
 function x64Add(m, n) {
-  m = [util.at(m, 0) >>> 16, util.at(m, 0) & 65535, util.at(m, 1) >>> 16, util.at(m, 1) & 65535];
-  n = [util.at(n, 0) >>> 16, util.at(n, 0) & 65535, util.at(n, 1) >>> 16, util.at(n, 1) & 65535];
+  m = [at.at(m, 0) >>> 16, at.at(m, 0) & 65535, at.at(m, 1) >>> 16, at.at(m, 1) & 65535];
+  n = [at.at(n, 0) >>> 16, at.at(n, 0) & 65535, at.at(n, 1) >>> 16, at.at(n, 1) & 65535];
   const o = [0, 0, 0, 0];
-  o[3] += util.at(m, 3) + util.at(n, 3);
-  o[2] += util.at(o, 3) >>> 16;
+  o[3] += at.at(m, 3) + at.at(n, 3);
+  o[2] += at.at(o, 3) >>> 16;
   o[3] &= 65535;
-  o[2] += util.at(m, 2) + util.at(n, 2);
-  o[1] += util.at(o, 2) >>> 16;
+  o[2] += at.at(m, 2) + at.at(n, 2);
+  o[1] += at.at(o, 2) >>> 16;
   o[2] &= 65535;
-  o[1] += util.at(m, 1) + util.at(n, 1);
-  o[0] += util.at(o, 1) >>> 16;
+  o[1] += at.at(m, 1) + at.at(n, 1);
+  o[0] += at.at(o, 1) >>> 16;
   o[1] &= 65535;
-  o[0] += util.at(m, 0) + util.at(n, 0);
+  o[0] += at.at(m, 0) + at.at(n, 0);
   o[0] &= 65535;
-  return [util.at(o, 0) << 16 | util.at(o, 1), util.at(o, 2) << 16 | util.at(o, 3)];
+  return [at.at(o, 0) << 16 | at.at(o, 1), at.at(o, 2) << 16 | at.at(o, 3)];
 }
 function x64Multiply(m, n) {
-  m = [util.at(m, 0) >>> 16, util.at(m, 0) & 65535, util.at(m, 1) >>> 16, util.at(m, 1) & 65535];
-  n = [util.at(n, 0) >>> 16, util.at(n, 0) & 65535, util.at(n, 1) >>> 16, util.at(n, 1) & 65535];
+  m = [at.at(m, 0) >>> 16, at.at(m, 0) & 65535, at.at(m, 1) >>> 16, at.at(m, 1) & 65535];
+  n = [at.at(n, 0) >>> 16, at.at(n, 0) & 65535, at.at(n, 1) >>> 16, at.at(n, 1) & 65535];
   const o = [0, 0, 0, 0];
-  o[3] += util.at(m, 3) * util.at(n, 3);
-  o[2] += util.at(o, 3) >>> 16;
+  o[3] += at.at(m, 3) * at.at(n, 3);
+  o[2] += at.at(o, 3) >>> 16;
   o[3] &= 65535;
-  o[2] += util.at(m, 2) * util.at(n, 3);
-  o[1] += util.at(o, 2) >>> 16;
+  o[2] += at.at(m, 2) * at.at(n, 3);
+  o[1] += at.at(o, 2) >>> 16;
   o[2] &= 65535;
-  o[2] += util.at(m, 3) * util.at(n, 2);
-  o[1] += util.at(o, 2) >>> 16;
+  o[2] += at.at(m, 3) * at.at(n, 2);
+  o[1] += at.at(o, 2) >>> 16;
   o[2] &= 65535;
-  o[1] += util.at(m, 1) * util.at(n, 3);
-  o[0] += util.at(o, 1) >>> 16;
+  o[1] += at.at(m, 1) * at.at(n, 3);
+  o[0] += at.at(o, 1) >>> 16;
   o[1] &= 65535;
-  o[1] += util.at(m, 2) * util.at(n, 2);
-  o[0] += util.at(o, 1) >>> 16;
+  o[1] += at.at(m, 2) * at.at(n, 2);
+  o[0] += at.at(o, 1) >>> 16;
   o[1] &= 65535;
-  o[1] += util.at(m, 3) * util.at(n, 1);
-  o[0] += util.at(o, 1) >>> 16;
+  o[1] += at.at(m, 3) * at.at(n, 1);
+  o[0] += at.at(o, 1) >>> 16;
   o[1] &= 65535;
-  o[0] += util.at(m, 0) * util.at(n, 3) + util.at(m, 1) * util.at(n, 2) + util.at(m, 2) * util.at(n, 1) + util.at(m, 3) * util.at(n, 0);
+  o[0] += at.at(m, 0) * at.at(n, 3) + at.at(m, 1) * at.at(n, 2) + at.at(m, 2) * at.at(n, 1) + at.at(m, 3) * at.at(n, 0);
   o[0] &= 65535;
-  return [util.at(o, 0) << 16 | util.at(o, 1), util.at(o, 2) << 16 | util.at(o, 3)];
+  return [at.at(o, 0) << 16 | at.at(o, 1), at.at(o, 2) << 16 | at.at(o, 3)];
 }
 function x64Rotl(m, n) {
   n %= 64;
   if (n === 32) {
-    return [util.at(m, 1), util.at(m, 0)];
-  } else if (n < 32) {
-    return [util.at(m, 0) << n | util.at(m, 1) >>> 32 - n, util.at(m, 1) << n | util.at(m, 0) >>> 32 - n];
-  } else {
-    n -= 32;
-    return [util.at(m, 1) << n | util.at(m, 0) >>> 32 - n, util.at(m, 0) << n | util.at(m, 1) >>> 32 - n];
+    return [at.at(m, 1), at.at(m, 0)];
   }
+  if (n < 32) {
+    return [
+      at.at(m, 0) << n | at.at(m, 1) >>> 32 - n,
+      at.at(m, 1) << n | at.at(m, 0) >>> 32 - n
+    ];
+  }
+  n -= 32;
+  return [
+    at.at(m, 1) << n | at.at(m, 0) >>> 32 - n,
+    at.at(m, 0) << n | at.at(m, 1) >>> 32 - n
+  ];
 }
 function x64LeftShift(m, n) {
   n %= 64;
   if (n === 0) {
     return m;
-  } else if (n < 32) {
-    return [util.at(m, 0) << n | util.at(m, 1) >>> 32 - n, util.at(m, 1) << n];
-  } else {
-    return [util.at(m, 1) << n - 32, 0];
   }
+  if (n < 32) {
+    return [at.at(m, 0) << n | at.at(m, 1) >>> 32 - n, at.at(m, 1) << n];
+  }
+  return [at.at(m, 1) << n - 32, 0];
 }
 function x64Xor(m, n) {
-  return [util.at(m, 0) ^ util.at(n, 0), util.at(m, 1) ^ util.at(n, 1)];
+  return [at.at(m, 0) ^ at.at(n, 0), at.at(m, 1) ^ at.at(n, 1)];
 }
 function x64Fmix(h) {
-  h = x64Xor(h, [0, util.at(h, 0) >>> 1]);
+  h = x64Xor(h, [0, at.at(h, 0) >>> 1]);
   h = x64Multiply(h, [4283543511, 3981806797]);
-  h = x64Xor(h, [0, util.at(h, 0) >>> 1]);
+  h = x64Xor(h, [0, at.at(h, 0) >>> 1]);
   h = x64Multiply(h, [3301882366, 444984403]);
-  h = x64Xor(h, [0, util.at(h, 0) >>> 1]);
+  h = x64Xor(h, [0, at.at(h, 0) >>> 1]);
   return h;
 }
 function x64hash128(key, seed) {
@@ -177,7 +183,7 @@ function x64hash128(key, seed) {
   h2 = x64Fmix(h2);
   h1 = x64Add(h1, h2);
   h2 = x64Add(h2, h1);
-  return ("00000000" + (util.at(h1, 0) >>> 0).toString(16)).slice(-8) + ("00000000" + (util.at(h1, 1) >>> 0).toString(16)).slice(-8) + ("00000000" + (util.at(h2, 0) >>> 0).toString(16)).slice(-8) + ("00000000" + (util.at(h2, 1) >>> 0).toString(16)).slice(-8);
+  return `00000000${(at.at(h1, 0) >>> 0).toString(16)}`.slice(-8) + `00000000${(at.at(h1, 1) >>> 0).toString(16)}`.slice(-8) + `00000000${(at.at(h2, 0) >>> 0).toString(16)}`.slice(-8) + `00000000${(at.at(h2, 1) >>> 0).toString(16)}`.slice(-8);
 }
 function picassoCanvas(roundNumber, seed, params) {
   const { area, offsetParameter, multiplier, fontSizeFactor, maxShadowBlur } = params;
@@ -202,8 +208,8 @@ function picassoCanvas(roundNumber, seed, params) {
   }
   function addRandomCanvasGradient(prng, context, area2) {
     const canvasGradient = context.createRadialGradient(adaptRandomNumberToContext(prng.getNext(), area2.width, void 0), adaptRandomNumberToContext(prng.getNext(), area2.height, void 0), adaptRandomNumberToContext(prng.getNext(), area2.width, void 0), adaptRandomNumberToContext(prng.getNext(), area2.width, void 0), adaptRandomNumberToContext(prng.getNext(), area2.height, void 0), adaptRandomNumberToContext(prng.getNext(), area2.width, void 0));
-    canvasGradient.addColorStop(0, util.at(colors, adaptRandomNumberToContext(prng.getNext(), colors.length, void 0)));
-    canvasGradient.addColorStop(1, util.at(colors, adaptRandomNumberToContext(prng.getNext(), colors.length, void 0)));
+    canvasGradient.addColorStop(0, at.at(colors, adaptRandomNumberToContext(prng.getNext(), colors.length, void 0)));
+    canvasGradient.addColorStop(1, at.at(colors, adaptRandomNumberToContext(prng.getNext(), colors.length, void 0)));
     context.fillStyle = canvasGradient;
   }
   function generateRandomWord(prng, wordLength) {
@@ -312,8 +318,8 @@ function picassoCanvas(roundNumber, seed, params) {
       for (let i = 0; i < roundNumber; i++) {
         addRandomCanvasGradient(prng, context, area);
         context.shadowBlur = adaptRandomNumberToContext(prng.getNext(), maxShadowBlur, void 0);
-        context.shadowColor = util.at(colors, adaptRandomNumberToContext(prng.getNext(), colors.length, void 0));
-        const randomPrimitive = util.at(primitives, adaptRandomNumberToContext(prng.getNext(), primitives.length, void 0));
+        context.shadowColor = at.at(colors, adaptRandomNumberToContext(prng.getNext(), colors.length, void 0));
+        const randomPrimitive = at.at(primitives, adaptRandomNumberToContext(prng.getNext(), primitives.length, void 0));
         randomPrimitive(prng, context, area);
         context.fill();
       }

package/dist/cjs/util/dist/checks.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isArray = (value) => {
+  return Array.isArray(value) && value !== null;
+};
+const isObject = (value) => {
+  return value instanceof Object && !isArray(value);
+};
+exports.isArray = isArray;
+exports.isObject = isObject;

package/dist/cjs/util/dist/choice.cjs

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function choice(items, n, random, options) {
+  if (n > items.length) {
+    throw new Error(`Cannot choose ${n} items from array of length ${items.length}`);
+  }
+  const result = [];
+  const indices = [];
+  for (let i = 0; i < n; i++) {
+    let index;
+    do {
+      index = Math.floor(Math.abs(random()) * items.length) % items.length;
+    } while (options?.withReplacement === false && indices.includes(index));
+    indices.push(index);
+    result.push(items[index]);
+  }
+  return result;
+}
+exports.choice = choice;

package/dist/cjs/util/dist/get.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function get(obj, key, required = true) {
+  const value = obj[key];
+  if (required && value === void 0) {
+    throw new Error(`Object has no property '${String(key)}': ${JSON.stringify(obj, null, 2)}`);
+  }
+  return value;
+}
+exports.get = get;

package/dist/cjs/util/dist/hex.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const checks = require("./checks.cjs");
+const U8 = new Array(256);
+const U16 = new Array(256 * 256);
+for (let n = 0; n < 256; n++) {
+  U8[n] = n.toString(16).padStart(2, "0");
+}
+for (let i = 0; i < 256; i++) {
+  const s = i << 8;
+  for (let j = 0; j < 256; j++) {
+    U16[s | j] = U8[i] + U8[j];
+  }
+}
+function hex(value, result) {
+  const mod = value.length % 2 | 0;
+  const length = value.length - mod | 0;
+  for (let i = 0; i < length; i += 2) {
+    result += U16[value[i] << 8 | value[i + 1]];
+  }
+  if (mod) {
+    result += U8[value[length] | 0];
+  }
+  return result;
+}
+function u8aToHex(value, bitLength = -1, isPrefixed = true) {
+  const empty = isPrefixed ? "0x" : "";
+  if (!value?.length) {
+    return empty;
+  }
+  if (bitLength > 0) {
+    const length = Math.ceil(bitLength / 8);
+    if (value.length > length) {
+      return `${hex(value.subarray(0, length / 2), empty)}…${hex(value.subarray(value.length - length / 2), "")}`;
+    }
+  }
+  return hex(value, empty);
+}
+const hashToHex = (hash) => {
+  if (checks.isArray(hash)) {
+    return u8aToHex(new Uint8Array(hash));
+  }
+  return hash.toString();
+};
+exports.hashToHex = hashToHex;
+exports.u8aToHex = u8aToHex;

package/dist/cjs/util/dist/index.cjs

@@ -8,17 +8,17 @@ const canvas = require("./canvas.cjs");
 const solverService = require("./solverService.cjs");
 const table = require("./table.cjs");
 const url = require("./url.cjs");
+const at = require("./at.cjs");
+const get = require("./get.cjs");
+const merge = require("./merge.cjs");
+const choice = require("./choice.cjs");
+const permutations = require("./permutations.cjs");
 const version = require("./version.cjs");
-exports.at = util.at;
-exports.flattenObj = util.flattenObj;
-exports.get = util.get;
+const hex = require("./hex.cjs");
+const checks = require("./checks.cjs");
+exports.flatten = util.flatten;
 exports.getCurrentFileDirectory = util.getCurrentFileDirectory;
-exports.hashToHex = util.hashToHex;
-exports.isArray = util.isArray;
-exports.isObject = util.isObject;
 exports.kebabCase = util.kebabCase;
-exports.merge = util.merge;
-exports.permutations = util.permutations;
 exports.sleep = util.sleep;
 exports.ofLen = ofLen.ofLen;
 exports.lodash = lodash.lodash;
@@ -30,4 +30,13 @@ exports.picassoCanvas = canvas.picassoCanvas;
 exports.solvePoW = solverService.solvePoW;
 exports.consoleTableWithWrapping = table.consoleTableWithWrapping;
 exports.getURLProtocol = url.getURLProtocol;
+exports.at = at.at;
+exports.get = get.get;
+exports.merge = merge.merge;
+exports.choice = choice.choice;
+exports.permutations = permutations.permutations;
 exports.version = version.version;
+exports.hashToHex = hex.hashToHex;
+exports.u8aToHex = hex.u8aToHex;
+exports.isArray = checks.isArray;
+exports.isObject = checks.isObject;

package/dist/cjs/util/dist/merge.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const checks = require("./checks.cjs");
+function merge(dest, src, options) {
+  const atomicArrays = options?.atomicArrays;
+  const queue = [
+    {
+      src,
+      dest
+    }
+  ];
+  while (queue.length > 0) {
+    const task = queue.pop();
+    if (task === void 0) {
+      throw new Error("queue is empty");
+    }
+    if (checks.isArray(task.dest)) {
+      const src2 = task.src;
+      const dest2 = task.dest;
+      if (atomicArrays) {
+        while (dest2.length > src2.length) {
+          dest2.pop();
+        }
+        for (let i = 0; i < src2.length; i++) {
+          dest2[i] = src2[i];
+        }
+      } else {
+        for (let i = 0; i < src2.length; i++) {
+          if (checks.isArray(dest2[i]) && checks.isArray(src2[i]) || checks.isObject(dest2[i]) && checks.isObject(src2[i])) {
+            queue.push({
+              src: src2[i],
+              dest: dest2[i]
+            });
+          } else {
+            dest2[i] = src2[i];
+          }
+        }
+      }
+    } else if (checks.isObject(task.dest)) {
+      const src2 = task.src;
+      const destAny = task.dest;
+      for (const [key, value] of Object.entries(src2)) {
+        if (checks.isArray(value) && checks.isArray(destAny[key]) || checks.isObject(value) && checks.isObject(destAny[key])) {
+          queue.push({
+            src: value,
+            dest: destAny[key]
+          });
+        } else {
+          destAny[key] = value;
+        }
+      }
+    } else {
+      throw new Error(`cannot handle type in queue: ${typeof task.dest}`);
+    }
+  }
+  return dest;
+}
+exports.merge = merge;

package/dist/cjs/util/dist/ofLen.cjs

@@ -520,7 +520,7 @@ function ofLen(arr, len) {
     case 256:
       return arr;
     default:
-      throw new Error("Len" + len + " type is not enumerated");
+      throw new Error(`Len${len} type is not enumerated`);
   }
 }
 exports.ofLen = ofLen;

package/dist/cjs/util/dist/permutations.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function* permutations(bins, options) {
+  if (options?.includeEmpty) {
+    yield [];
+  }
+  if (bins.length === 0) {
+    return;
+  }
+  const arr = Array.from({ length: bins.length }, () => 0);
+  let i = arr.length - 1;
+  while (true) {
+    yield [...arr];
+    arr[i]++;
+    while (arr[i] === bins[i]) {
+      arr[i] = 0;
+      i--;
+      if (i < 0) {
+        return;
+      }
+      arr[i]++;
+    }
+    i = arr.length - 1;
+  }
+}
+exports.permutations = permutations;

package/dist/cjs/util/dist/table.cjs

@@ -9,10 +9,10 @@ function wrapItemToMultipleRows(item, maxCellWidth) {
   }
   const itemRow = {};
   const remaining = {};
-  Object.entries(item).forEach(([key, value]) => {
+  for (const [key, value] of Object.entries(item)) {
     itemRow[key] = value?.slice ? value.slice(0, maxCellWidth) : value;
     remaining[key] = value?.slice ? value.slice(maxCellWidth) : value;
-  });
+  }
   return [itemRow, ...wrapItemToMultipleRows(remaining, maxCellWidth)];
 }
 function consoleTableWithWrapping(data, maxColWidth = 90) {