@xyo-network/bip39 2.79.4 → 2.79.5

package/dist/browser/index.cjs

@@ -39,7 +39,7 @@ __export(src_exports, {
   wordlists: () => wordlists
 });
 module.exports = __toCommonJS(src_exports);
-var import_assert = __toESM(require("@noble/hashes/_assert"));
+var import_assert = __toESM(require("@noble/hashes/_assert"), 1);
 var import_pbkdf2 = require("@noble/hashes/pbkdf2");
 var import_sha256 = require("@noble/hashes/sha256");
 var import_sha512 = require("@noble/hashes/sha512");

package/dist/node/{index.mjs → index.cjs}

@@ -1,10 +1,50 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
 // src/index.ts
-import assert from "@noble/hashes/_assert";
-import { pbkdf2, pbkdf2Async } from "@noble/hashes/pbkdf2";
-import { sha256 } from "@noble/hashes/sha256";
-import { sha512 } from "@noble/hashes/sha512";
-import { randomBytes } from "@noble/hashes/utils";
-import { utils as baseUtils } from "@scure/base";
+var src_exports = {};
+__export(src_exports, {
+  entropyToMnemonic: () => entropyToMnemonic,
+  generateMnemonic: () => generateMnemonic,
+  mnemonicToEntropy: () => mnemonicToEntropy,
+  mnemonicToSeed: () => mnemonicToSeed,
+  mnemonicToSeedSync: () => mnemonicToSeedSync,
+  validateMnemonic: () => validateMnemonic,
+  wordlists: () => wordlists
+});
+module.exports = __toCommonJS(src_exports);
+var import_assert = __toESM(require("@noble/hashes/_assert"), 1);
+var import_pbkdf2 = require("@noble/hashes/pbkdf2");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_sha512 = require("@noble/hashes/sha512");
+var import_utils = require("@noble/hashes/utils");
+var import_base = require("@scure/base");
 
 // src/wordlists/czech.ts
 var wordlist = `abdikace
@@ -18484,17 +18524,17 @@ function normalize(str) {
   return { nfkd: norm, words };
 }
 function assertEntropy(entropy) {
-  assert.bytes(entropy, 16, 20, 24, 28, 32);
+  import_assert.default.bytes(entropy, 16, 20, 24, 28, 32);
 }
 function generateMnemonic(wordlist10, strength = 128) {
-  assert.number(strength);
+  import_assert.default.number(strength);
   if (strength % 32 !== 0 || strength > 256)
     throw new TypeError("Invalid entropy");
-  return entropyToMnemonic(randomBytes(strength / 8), wordlist10);
+  return entropyToMnemonic((0, import_utils.randomBytes)(strength / 8), wordlist10);
 }
 var calcChecksum = (entropy) => {
   const bitsLeft = 8 - entropy.length / 4;
-  return new Uint8Array([sha256(entropy)[0] >> bitsLeft << bitsLeft]);
+  return new Uint8Array([(0, import_sha256.sha256)(entropy)[0] >> bitsLeft << bitsLeft]);
 };
 function getCoder(wordlist10) {
   if (!Array.isArray(wordlist10) || wordlist10.length !== 2048 || typeof wordlist10[0] !== "string")
@@ -18503,7 +18543,7 @@ function getCoder(wordlist10) {
     if (typeof i !== "string")
       throw new Error(`Wordlist: non-string element: ${i}`);
   });
-  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist10));
+  return import_base.utils.chain(import_base.utils.checksum(1, calcChecksum), import_base.utils.radix2(11, true), import_base.utils.alphabet(wordlist10));
 }
 function mnemonicToEntropy(mnemonic, wordlist10) {
   const { words } = normalize(mnemonic);
@@ -18526,12 +18566,13 @@ function validateMnemonic(mnemonic, wordlist10) {
 }
 var salt = (passphrase) => nfkd(`mnemonic${passphrase}`);
 function mnemonicToSeed(mnemonic, passphrase = "") {
-  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+  return (0, import_pbkdf2.pbkdf2Async)(import_sha512.sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
 }
 function mnemonicToSeedSync(mnemonic, passphrase = "") {
-  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+  return (0, import_pbkdf2.pbkdf2)(import_sha512.sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   entropyToMnemonic,
   generateMnemonic,
   mnemonicToEntropy,
@@ -18539,6 +18580,6 @@ export {
   mnemonicToSeedSync,
   validateMnemonic,
   wordlists
-};
+});
 /*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.cjs.map