@xyo-network/bip39 2.79.4 → 2.79.6

package/dist/node/index.js

@@ -1,50 +1,10 @@
-"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
-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"));
-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");
+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";
 
 // src/wordlists/czech.ts
 var wordlist = `abdikace
@@ -18524,17 +18484,17 @@ function normalize(str) {
   return { nfkd: norm, words };
 }
 function assertEntropy(entropy) {
-  import_assert.default.bytes(entropy, 16, 20, 24, 28, 32);
+  assert.bytes(entropy, 16, 20, 24, 28, 32);
 }
 function generateMnemonic(wordlist10, strength = 128) {
-  import_assert.default.number(strength);
+  assert.number(strength);
   if (strength % 32 !== 0 || strength > 256)
     throw new TypeError("Invalid entropy");
-  return entropyToMnemonic((0, import_utils.randomBytes)(strength / 8), wordlist10);
+  return entropyToMnemonic(randomBytes(strength / 8), wordlist10);
 }
 var calcChecksum = (entropy) => {
   const bitsLeft = 8 - entropy.length / 4;
-  return new Uint8Array([(0, import_sha256.sha256)(entropy)[0] >> bitsLeft << bitsLeft]);
+  return new Uint8Array([sha256(entropy)[0] >> bitsLeft << bitsLeft]);
 };
 function getCoder(wordlist10) {
   if (!Array.isArray(wordlist10) || wordlist10.length !== 2048 || typeof wordlist10[0] !== "string")
@@ -18543,7 +18503,7 @@ function getCoder(wordlist10) {
     if (typeof i !== "string")
       throw new Error(`Wordlist: non-string element: ${i}`);
   });
-  return import_base.utils.chain(import_base.utils.checksum(1, calcChecksum), import_base.utils.radix2(11, true), import_base.utils.alphabet(wordlist10));
+  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist10));
 }
 function mnemonicToEntropy(mnemonic, wordlist10) {
   const { words } = normalize(mnemonic);
@@ -18566,13 +18526,12 @@ function validateMnemonic(mnemonic, wordlist10) {
 }
 var salt = (passphrase) => nfkd(`mnemonic${passphrase}`);
 function mnemonicToSeed(mnemonic, passphrase = "") {
-  return (0, import_pbkdf2.pbkdf2Async)(import_sha512.sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
 }
 function mnemonicToSeedSync(mnemonic, passphrase = "") {
-  return (0, import_pbkdf2.pbkdf2)(import_sha512.sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   entropyToMnemonic,
   generateMnemonic,
   mnemonicToEntropy,
@@ -18580,6 +18539,6 @@ function mnemonicToSeedSync(mnemonic, passphrase = "") {
   mnemonicToSeedSync,
   validateMnemonic,
   wordlists
-});
+};
 /*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
 //# sourceMappingURL=index.js.map