@xyo-network/bip39 2.109.0 → 2.110.0

package/dist/browser/index.cjs

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -66,49 +67,73 @@ var wordlists = {
 };
 
 // src/index.ts
-var isJapanese = (wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093";
+var isJapanese = /* @__PURE__ */ __name((wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093", "isJapanese");
 function nfkd(str) {
   if (typeof str !== "string") throw new TypeError(`Invalid mnemonic type: ${typeof str}`);
   return str.normalize("NFKD");
 }
+__name(nfkd, "nfkd");
 function normalize(str) {
   const norm = nfkd(str);
   const words = norm.split(" ");
-  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error("Invalid mnemonic");
-  return { nfkd: norm, words };
+  if (![
+    12,
+    15,
+    18,
+    21,
+    24
+  ].includes(words.length)) throw new Error("Invalid mnemonic");
+  return {
+    nfkd: norm,
+    words
+  };
 }
+__name(normalize, "normalize");
 function assertEntropy(entropy) {
   import_assert.default.bytes(entropy, 16, 20, 24, 28, 32);
 }
-var calcChecksum = (entropy) => {
+__name(assertEntropy, "assertEntropy");
+var calcChecksum = /* @__PURE__ */ __name((entropy) => {
   const bitsLeft = 8 - entropy.length / 4;
-  return new Uint8Array([(0, import_sha256.sha256)(entropy)[0] >> bitsLeft << bitsLeft]);
-};
+  return new Uint8Array([
+    (0, import_sha256.sha256)(entropy)[0] >> bitsLeft << bitsLeft
+  ]);
+}, "calcChecksum");
 function getCoder(wordlist) {
-  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string")
-    throw new Error("Worlist: expected array of 2048 strings");
+  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string") throw new Error("Worlist: expected array of 2048 strings");
   for (const i of wordlist) {
     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(wordlist));
 }
+__name(getCoder, "getCoder");
 function mnemonicToEntropy(mnemonic, wordlist) {
   const { words } = normalize(mnemonic);
   const entropy = getCoder(wordlist).decode(words);
   assertEntropy(entropy);
   return entropy;
 }
+__name(mnemonicToEntropy, "mnemonicToEntropy");
 function entropyToMnemonic(entropy, wordlist) {
   assertEntropy(entropy);
   const words = getCoder(wordlist).encode(entropy);
   return words.join(isJapanese(wordlist) ? "\u3000" : " ");
 }
-var salt = (passphrase) => nfkd(`mnemonic${passphrase}`);
+__name(entropyToMnemonic, "entropyToMnemonic");
+var salt = /* @__PURE__ */ __name((passphrase) => nfkd(`mnemonic${passphrase}`), "salt");
 function mnemonicToSeed(mnemonic, passphrase = "") {
-  return (0, import_pbkdf2.pbkdf2Async)(import_sha512.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
+  });
 }
+__name(mnemonicToSeed, "mnemonicToSeed");
 function mnemonicToSeedSync(mnemonic, passphrase = "") {
-  return (0, import_pbkdf2.pbkdf2)(import_sha512.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
+  });
 }
+__name(mnemonicToSeedSync, "mnemonicToSeedSync");
 /*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
 //# sourceMappingURL=index.cjs.map

package/dist/browser/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,oBAAmB;AACnB,oBAAoC;AACpC,oBAAuB;AACvB,oBAAuB;AACvB,kBAAmC;;;ACLnC,mBAAkB;AAClB,qBAAoB;AACpB,oBAAmB;AACnB,qBAAoB;AACpB,sBAAqB;AACrB,oBAAmB;AACnB,gCAA8B;AAC9B,qBAAoB;AACpB,iCAA+B;AAGxB,IAAM,YAAY;AAAA,EACvB,oBAAAA;AAAA,EACA,wBAAAC;AAAA,EACA,sBAAAC;AAAA,EACA,wBAAAC;AAAA,EACA,0BAAAC;AAAA,EACA,sBAAAC;AAAA,EACA,6CAAAC;AAAA,EACA,wBAAAC;AAAA,EACA,+CAAAC;AACF;;;ADXA,IAAM,aAAa,CAAC,aAAuB,SAAS,CAAC,MAAM;AAK3D,SAAS,KAAK,KAAa;AACzB,MAAI,OAAO,QAAQ,SAAU,OAAM,IAAI,UAAU,0BAA0B,OAAO,GAAG,EAAE;AACvF,SAAO,IAAI,UAAU,MAAM;AAC7B;AAEA,SAAS,UAAU,KAAa;AAC9B,QAAM,OAAO,KAAK,GAAG;AACrB,QAAM,QAAQ,KAAK,MAAM,GAAG;AAC5B,MAAI,CAAC,CAAC,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,SAAS,MAAM,MAAM,EAAG,OAAM,IAAI,MAAM,kBAAkB;AACpF,SAAO,EAAE,MAAM,MAAM,MAAM;AAC7B;AAEA,SAAS,cAAc,SAAqB;AAC1C,gBAAAC,QAAO,MAAM,SAAS,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1C;AAEA,IAAM,eAAe,CAAC,YAAwB;AAE5C,QAAM,WAAW,IAAI,QAAQ,SAAS;AAGtC,SAAO,IAAI,WAAW,KAAE,sBAAO,OAAO,EAAE,CAAC,KAAK,YAAa,QAAQ,CAAC;AACtE;AAEA,SAAS,SAAS,UAAoB;AACpC,MAAI,CAAC,MAAM,QAAQ,QAAQ,KAAK,SAAS,WAAW,QAAQ,OAAO,SAAS,CAAC,MAAM;AACjF,UAAM,IAAI,MAAM,yCAAyC;AAC3D,aAAW,KAAK,UAAU;AACxB,QAAI,OAAO,MAAM,SAAU,OAAM,IAAI,MAAM,iCAAiC,CAAC,EAAE;AAAA,EACjF;AACA,SAAO,YAAAC,MAAU,MAAM,YAAAA,MAAU,SAAS,GAAG,YAAY,GAAG,YAAAA,MAAU,OAAO,IAAI,IAAI,GAAG,YAAAA,MAAU,SAAS,QAAQ,CAAC;AACtH;AAiBO,SAAS,kBAAkB,UAAkB,UAAgC;AAClF,QAAM,EAAE,MAAM,IAAI,UAAU,QAAQ;AACpC,QAAM,UAAU,SAAS,QAAQ,EAAE,OAAO,KAAK;AAC/C,gBAAc,OAAO;AACrB,SAAO;AACT;AAiBO,SAAS,kBAAkB,SAAqB,UAA4B;AACjF,gBAAc,OAAO;AACrB,QAAM,QAAQ,SAAS,QAAQ,EAAE,OAAO,OAAO;AAC/C,SAAO,MAAM,KAAK,WAAW,QAAQ,IAAI,WAAW,GAAG;AACzD;AAEA,IAAM,OAAO,CAAC,eAAuB,KAAK,WAAW,UAAU,EAAE;AAc1D,SAAS,eAAe,UAAkB,aAAa,IAAI;AAChE,aAAO,2BAAY,sBAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC/F;AAcO,SAAS,mBAAmB,UAAkB,aAAa,IAAI;AACpE,aAAO,sBAAO,sBAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC1F;","names":["czech","english","french","italian","japanese","korean","simplifiedChinese","spanish","traditionalChinese","assert","baseUtils"]}
+{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists/index.js'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":"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","names":["wordlists","czech","english","french","italian","japanese","korean","simplifiedChinese","spanish","traditionalChinese","isJapanese","wordlist","nfkd","str","TypeError","normalize","norm","words","split","includes","length","Error","assertEntropy","entropy","assert","bytes","calcChecksum","bitsLeft","Uint8Array","sha256","getCoder","Array","isArray","i","baseUtils","chain","checksum","radix2","alphabet","mnemonicToEntropy","mnemonic","decode","entropyToMnemonic","encode","join","salt","passphrase","mnemonicToSeed","pbkdf2Async","sha512","c","dkLen","mnemonicToSeedSync","pbkdf2"]}

package/dist/browser/index.d.cts

@@ -1,4 +1,4 @@
-export * from './wordlists';
+export * from './wordlists/index.js';
 export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
 export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
 export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;

package/dist/browser/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,aAAa,CAAA;AAwD3B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,sBAAsB,CAAA;AAwDpC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}

package/dist/browser/index.d.mts

@@ -1,4 +1,4 @@
-export * from './wordlists';
+export * from './wordlists/index.js';
 export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
 export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
 export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;

package/dist/browser/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,aAAa,CAAA;AAwD3B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,sBAAsB,CAAA;AAwDpC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}

package/dist/browser/index.d.ts

@@ -1,4 +1,4 @@
-export * from './wordlists';
+export * from './wordlists/index.js';
 export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
 export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
 export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;

package/dist/browser/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,aAAa,CAAA;AAwD3B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,sBAAsB,CAAA;AAwDpC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}

package/dist/browser/index.js

@@ -1,3 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/index.ts
 import assert from "@noble/hashes/_assert";
 import { pbkdf2, pbkdf2Async } from "@noble/hashes/pbkdf2";
@@ -28,50 +31,74 @@ var wordlists = {
 };
 
 // src/index.ts
-var isJapanese = (wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093";
+var isJapanese = /* @__PURE__ */ __name((wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093", "isJapanese");
 function nfkd(str) {
   if (typeof str !== "string") throw new TypeError(`Invalid mnemonic type: ${typeof str}`);
   return str.normalize("NFKD");
 }
+__name(nfkd, "nfkd");
 function normalize(str) {
   const norm = nfkd(str);
   const words = norm.split(" ");
-  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error("Invalid mnemonic");
-  return { nfkd: norm, words };
+  if (![
+    12,
+    15,
+    18,
+    21,
+    24
+  ].includes(words.length)) throw new Error("Invalid mnemonic");
+  return {
+    nfkd: norm,
+    words
+  };
 }
+__name(normalize, "normalize");
 function assertEntropy(entropy) {
   assert.bytes(entropy, 16, 20, 24, 28, 32);
 }
-var calcChecksum = (entropy) => {
+__name(assertEntropy, "assertEntropy");
+var calcChecksum = /* @__PURE__ */ __name((entropy) => {
   const bitsLeft = 8 - entropy.length / 4;
-  return new Uint8Array([sha256(entropy)[0] >> bitsLeft << bitsLeft]);
-};
+  return new Uint8Array([
+    sha256(entropy)[0] >> bitsLeft << bitsLeft
+  ]);
+}, "calcChecksum");
 function getCoder(wordlist) {
-  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string")
-    throw new Error("Worlist: expected array of 2048 strings");
+  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string") throw new Error("Worlist: expected array of 2048 strings");
   for (const i of wordlist) {
     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(wordlist));
 }
+__name(getCoder, "getCoder");
 function mnemonicToEntropy(mnemonic, wordlist) {
   const { words } = normalize(mnemonic);
   const entropy = getCoder(wordlist).decode(words);
   assertEntropy(entropy);
   return entropy;
 }
+__name(mnemonicToEntropy, "mnemonicToEntropy");
 function entropyToMnemonic(entropy, wordlist) {
   assertEntropy(entropy);
   const words = getCoder(wordlist).encode(entropy);
   return words.join(isJapanese(wordlist) ? "\u3000" : " ");
 }
-var salt = (passphrase) => nfkd(`mnemonic${passphrase}`);
+__name(entropyToMnemonic, "entropyToMnemonic");
+var salt = /* @__PURE__ */ __name((passphrase) => nfkd(`mnemonic${passphrase}`), "salt");
 function mnemonicToSeed(mnemonic, passphrase = "") {
-  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), {
+    c: 2048,
+    dkLen: 64
+  });
 }
+__name(mnemonicToSeed, "mnemonicToSeed");
 function mnemonicToSeedSync(mnemonic, passphrase = "") {
-  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), {
+    c: 2048,
+    dkLen: 64
+  });
 }
+__name(mnemonicToSeedSync, "mnemonicToSeedSync");
 export {
   entropyToMnemonic,
   mnemonicToEntropy,

package/dist/browser/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":";AAEA,OAAO,YAAY;AACnB,SAAS,QAAQ,mBAAmB;AACpC,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAAS,SAAS,iBAAiB;;;ACLnC,OAAO,WAAW;AAClB,OAAO,aAAa;AACpB,OAAO,YAAY;AACnB,OAAO,aAAa;AACpB,OAAO,cAAc;AACrB,OAAO,YAAY;AACnB,OAAO,uBAAuB;AAC9B,OAAO,aAAa;AACpB,OAAO,wBAAwB;AAGxB,IAAM,YAAY;AAAA,EACvB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;;;ADXA,IAAM,aAAa,CAAC,aAAuB,SAAS,CAAC,MAAM;AAK3D,SAAS,KAAK,KAAa;AACzB,MAAI,OAAO,QAAQ,SAAU,OAAM,IAAI,UAAU,0BAA0B,OAAO,GAAG,EAAE;AACvF,SAAO,IAAI,UAAU,MAAM;AAC7B;AAEA,SAAS,UAAU,KAAa;AAC9B,QAAM,OAAO,KAAK,GAAG;AACrB,QAAM,QAAQ,KAAK,MAAM,GAAG;AAC5B,MAAI,CAAC,CAAC,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,SAAS,MAAM,MAAM,EAAG,OAAM,IAAI,MAAM,kBAAkB;AACpF,SAAO,EAAE,MAAM,MAAM,MAAM;AAC7B;AAEA,SAAS,cAAc,SAAqB;AAC1C,SAAO,MAAM,SAAS,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1C;AAEA,IAAM,eAAe,CAAC,YAAwB;AAE5C,QAAM,WAAW,IAAI,QAAQ,SAAS;AAGtC,SAAO,IAAI,WAAW,CAAE,OAAO,OAAO,EAAE,CAAC,KAAK,YAAa,QAAQ,CAAC;AACtE;AAEA,SAAS,SAAS,UAAoB;AACpC,MAAI,CAAC,MAAM,QAAQ,QAAQ,KAAK,SAAS,WAAW,QAAQ,OAAO,SAAS,CAAC,MAAM;AACjF,UAAM,IAAI,MAAM,yCAAyC;AAC3D,aAAW,KAAK,UAAU;AACxB,QAAI,OAAO,MAAM,SAAU,OAAM,IAAI,MAAM,iCAAiC,CAAC,EAAE;AAAA,EACjF;AACA,SAAO,UAAU,MAAM,UAAU,SAAS,GAAG,YAAY,GAAG,UAAU,OAAO,IAAI,IAAI,GAAG,UAAU,SAAS,QAAQ,CAAC;AACtH;AAiBO,SAAS,kBAAkB,UAAkB,UAAgC;AAClF,QAAM,EAAE,MAAM,IAAI,UAAU,QAAQ;AACpC,QAAM,UAAU,SAAS,QAAQ,EAAE,OAAO,KAAK;AAC/C,gBAAc,OAAO;AACrB,SAAO;AACT;AAiBO,SAAS,kBAAkB,SAAqB,UAA4B;AACjF,gBAAc,OAAO;AACrB,QAAM,QAAQ,SAAS,QAAQ,EAAE,OAAO,OAAO;AAC/C,SAAO,MAAM,KAAK,WAAW,QAAQ,IAAI,WAAW,GAAG;AACzD;AAEA,IAAM,OAAO,CAAC,eAAuB,KAAK,WAAW,UAAU,EAAE;AAc1D,SAAS,eAAe,UAAkB,aAAa,IAAI;AAChE,SAAO,YAAY,QAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC/F;AAcO,SAAS,mBAAmB,UAAkB,aAAa,IAAI;AACpE,SAAO,OAAO,QAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC1F;","names":[]}
+{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists/index.js'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":"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","names":["assert","pbkdf2","pbkdf2Async","sha256","sha512","utils","baseUtils","czech","english","french","italian","japanese","korean","simplifiedChinese","spanish","traditionalChinese","wordlists","isJapanese","wordlist","nfkd","str","TypeError","normalize","norm","words","split","includes","length","Error","assertEntropy","entropy","assert","bytes","calcChecksum","bitsLeft","Uint8Array","sha256","getCoder","Array","isArray","i","baseUtils","chain","checksum","radix2","alphabet","mnemonicToEntropy","mnemonic","decode","entropyToMnemonic","encode","join","salt","passphrase","mnemonicToSeed","pbkdf2Async","sha512","c","dkLen","mnemonicToSeedSync","pbkdf2"]}

package/dist/neutral/index.cjs

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -66,49 +67,73 @@ var wordlists = {
 };
 
 // src/index.ts
-var isJapanese = (wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093";
+var isJapanese = /* @__PURE__ */ __name((wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093", "isJapanese");
 function nfkd(str) {
   if (typeof str !== "string") throw new TypeError(`Invalid mnemonic type: ${typeof str}`);
   return str.normalize("NFKD");
 }
+__name(nfkd, "nfkd");
 function normalize(str) {
   const norm = nfkd(str);
   const words = norm.split(" ");
-  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error("Invalid mnemonic");
-  return { nfkd: norm, words };
+  if (![
+    12,
+    15,
+    18,
+    21,
+    24
+  ].includes(words.length)) throw new Error("Invalid mnemonic");
+  return {
+    nfkd: norm,
+    words
+  };
 }
+__name(normalize, "normalize");
 function assertEntropy(entropy) {
   import_assert.default.bytes(entropy, 16, 20, 24, 28, 32);
 }
-var calcChecksum = (entropy) => {
+__name(assertEntropy, "assertEntropy");
+var calcChecksum = /* @__PURE__ */ __name((entropy) => {
   const bitsLeft = 8 - entropy.length / 4;
-  return new Uint8Array([(0, import_sha256.sha256)(entropy)[0] >> bitsLeft << bitsLeft]);
-};
+  return new Uint8Array([
+    (0, import_sha256.sha256)(entropy)[0] >> bitsLeft << bitsLeft
+  ]);
+}, "calcChecksum");
 function getCoder(wordlist) {
-  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string")
-    throw new Error("Worlist: expected array of 2048 strings");
+  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string") throw new Error("Worlist: expected array of 2048 strings");
   for (const i of wordlist) {
     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(wordlist));
 }
+__name(getCoder, "getCoder");
 function mnemonicToEntropy(mnemonic, wordlist) {
   const { words } = normalize(mnemonic);
   const entropy = getCoder(wordlist).decode(words);
   assertEntropy(entropy);
   return entropy;
 }
+__name(mnemonicToEntropy, "mnemonicToEntropy");
 function entropyToMnemonic(entropy, wordlist) {
   assertEntropy(entropy);
   const words = getCoder(wordlist).encode(entropy);
   return words.join(isJapanese(wordlist) ? "\u3000" : " ");
 }
-var salt = (passphrase) => nfkd(`mnemonic${passphrase}`);
+__name(entropyToMnemonic, "entropyToMnemonic");
+var salt = /* @__PURE__ */ __name((passphrase) => nfkd(`mnemonic${passphrase}`), "salt");
 function mnemonicToSeed(mnemonic, passphrase = "") {
-  return (0, import_pbkdf2.pbkdf2Async)(import_sha512.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
+  });
 }
+__name(mnemonicToSeed, "mnemonicToSeed");
 function mnemonicToSeedSync(mnemonic, passphrase = "") {
-  return (0, import_pbkdf2.pbkdf2)(import_sha512.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
+  });
 }
+__name(mnemonicToSeedSync, "mnemonicToSeedSync");
 /*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
 //# sourceMappingURL=index.cjs.map

package/dist/neutral/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,oBAAmB;AACnB,oBAAoC;AACpC,oBAAuB;AACvB,oBAAuB;AACvB,kBAAmC;;;ACLnC,mBAAkB;AAClB,qBAAoB;AACpB,oBAAmB;AACnB,qBAAoB;AACpB,sBAAqB;AACrB,oBAAmB;AACnB,gCAA8B;AAC9B,qBAAoB;AACpB,iCAA+B;AAGxB,IAAM,YAAY;AAAA,EACvB,oBAAAA;AAAA,EACA,wBAAAC;AAAA,EACA,sBAAAC;AAAA,EACA,wBAAAC;AAAA,EACA,0BAAAC;AAAA,EACA,sBAAAC;AAAA,EACA,6CAAAC;AAAA,EACA,wBAAAC;AAAA,EACA,+CAAAC;AACF;;;ADXA,IAAM,aAAa,CAAC,aAAuB,SAAS,CAAC,MAAM;AAK3D,SAAS,KAAK,KAAa;AACzB,MAAI,OAAO,QAAQ,SAAU,OAAM,IAAI,UAAU,0BAA0B,OAAO,GAAG,EAAE;AACvF,SAAO,IAAI,UAAU,MAAM;AAC7B;AAEA,SAAS,UAAU,KAAa;AAC9B,QAAM,OAAO,KAAK,GAAG;AACrB,QAAM,QAAQ,KAAK,MAAM,GAAG;AAC5B,MAAI,CAAC,CAAC,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,SAAS,MAAM,MAAM,EAAG,OAAM,IAAI,MAAM,kBAAkB;AACpF,SAAO,EAAE,MAAM,MAAM,MAAM;AAC7B;AAEA,SAAS,cAAc,SAAqB;AAC1C,gBAAAC,QAAO,MAAM,SAAS,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1C;AAEA,IAAM,eAAe,CAAC,YAAwB;AAE5C,QAAM,WAAW,IAAI,QAAQ,SAAS;AAGtC,SAAO,IAAI,WAAW,KAAE,sBAAO,OAAO,EAAE,CAAC,KAAK,YAAa,QAAQ,CAAC;AACtE;AAEA,SAAS,SAAS,UAAoB;AACpC,MAAI,CAAC,MAAM,QAAQ,QAAQ,KAAK,SAAS,WAAW,QAAQ,OAAO,SAAS,CAAC,MAAM;AACjF,UAAM,IAAI,MAAM,yCAAyC;AAC3D,aAAW,KAAK,UAAU;AACxB,QAAI,OAAO,MAAM,SAAU,OAAM,IAAI,MAAM,iCAAiC,CAAC,EAAE;AAAA,EACjF;AACA,SAAO,YAAAC,MAAU,MAAM,YAAAA,MAAU,SAAS,GAAG,YAAY,GAAG,YAAAA,MAAU,OAAO,IAAI,IAAI,GAAG,YAAAA,MAAU,SAAS,QAAQ,CAAC;AACtH;AAiBO,SAAS,kBAAkB,UAAkB,UAAgC;AAClF,QAAM,EAAE,MAAM,IAAI,UAAU,QAAQ;AACpC,QAAM,UAAU,SAAS,QAAQ,EAAE,OAAO,KAAK;AAC/C,gBAAc,OAAO;AACrB,SAAO;AACT;AAiBO,SAAS,kBAAkB,SAAqB,UAA4B;AACjF,gBAAc,OAAO;AACrB,QAAM,QAAQ,SAAS,QAAQ,EAAE,OAAO,OAAO;AAC/C,SAAO,MAAM,KAAK,WAAW,QAAQ,IAAI,WAAW,GAAG;AACzD;AAEA,IAAM,OAAO,CAAC,eAAuB,KAAK,WAAW,UAAU,EAAE;AAc1D,SAAS,eAAe,UAAkB,aAAa,IAAI;AAChE,aAAO,2BAAY,sBAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC/F;AAcO,SAAS,mBAAmB,UAAkB,aAAa,IAAI;AACpE,aAAO,sBAAO,sBAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC1F;","names":["czech","english","french","italian","japanese","korean","simplifiedChinese","spanish","traditionalChinese","assert","baseUtils"]}
+{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists/index.js'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":"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","names":["wordlists","czech","english","french","italian","japanese","korean","simplifiedChinese","spanish","traditionalChinese","isJapanese","wordlist","nfkd","str","TypeError","normalize","norm","words","split","includes","length","Error","assertEntropy","entropy","assert","bytes","calcChecksum","bitsLeft","Uint8Array","sha256","getCoder","Array","isArray","i","baseUtils","chain","checksum","radix2","alphabet","mnemonicToEntropy","mnemonic","decode","entropyToMnemonic","encode","join","salt","passphrase","mnemonicToSeed","pbkdf2Async","sha512","c","dkLen","mnemonicToSeedSync","pbkdf2"]}

package/dist/neutral/index.d.cts

@@ -1,4 +1,4 @@
-export * from './wordlists';
+export * from './wordlists/index.js';
 export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
 export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
 export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;

package/dist/neutral/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,aAAa,CAAA;AAwD3B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,sBAAsB,CAAA;AAwDpC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}

package/dist/neutral/index.d.mts

@@ -1,4 +1,4 @@
-export * from './wordlists';
+export * from './wordlists/index.js';
 export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
 export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
 export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;

package/dist/neutral/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,aAAa,CAAA;AAwD3B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,sBAAsB,CAAA;AAwDpC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}

package/dist/neutral/index.d.ts

@@ -1,4 +1,4 @@
-export * from './wordlists';
+export * from './wordlists/index.js';
 export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
 export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
 export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;

package/dist/neutral/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,aAAa,CAAA;AAwD3B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,sBAAsB,CAAA;AAwDpC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}

package/dist/neutral/index.js

@@ -1,3 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/index.ts
 import assert from "@noble/hashes/_assert";
 import { pbkdf2, pbkdf2Async } from "@noble/hashes/pbkdf2";
@@ -28,50 +31,74 @@ var wordlists = {
 };
 
 // src/index.ts
-var isJapanese = (wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093";
+var isJapanese = /* @__PURE__ */ __name((wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093", "isJapanese");
 function nfkd(str) {
   if (typeof str !== "string") throw new TypeError(`Invalid mnemonic type: ${typeof str}`);
   return str.normalize("NFKD");
 }
+__name(nfkd, "nfkd");
 function normalize(str) {
   const norm = nfkd(str);
   const words = norm.split(" ");
-  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error("Invalid mnemonic");
-  return { nfkd: norm, words };
+  if (![
+    12,
+    15,
+    18,
+    21,
+    24
+  ].includes(words.length)) throw new Error("Invalid mnemonic");
+  return {
+    nfkd: norm,
+    words
+  };
 }
+__name(normalize, "normalize");
 function assertEntropy(entropy) {
   assert.bytes(entropy, 16, 20, 24, 28, 32);
 }
-var calcChecksum = (entropy) => {
+__name(assertEntropy, "assertEntropy");
+var calcChecksum = /* @__PURE__ */ __name((entropy) => {
   const bitsLeft = 8 - entropy.length / 4;
-  return new Uint8Array([sha256(entropy)[0] >> bitsLeft << bitsLeft]);
-};
+  return new Uint8Array([
+    sha256(entropy)[0] >> bitsLeft << bitsLeft
+  ]);
+}, "calcChecksum");
 function getCoder(wordlist) {
-  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string")
-    throw new Error("Worlist: expected array of 2048 strings");
+  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string") throw new Error("Worlist: expected array of 2048 strings");
   for (const i of wordlist) {
     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(wordlist));
 }
+__name(getCoder, "getCoder");
 function mnemonicToEntropy(mnemonic, wordlist) {
   const { words } = normalize(mnemonic);
   const entropy = getCoder(wordlist).decode(words);
   assertEntropy(entropy);
   return entropy;
 }
+__name(mnemonicToEntropy, "mnemonicToEntropy");
 function entropyToMnemonic(entropy, wordlist) {
   assertEntropy(entropy);
   const words = getCoder(wordlist).encode(entropy);
   return words.join(isJapanese(wordlist) ? "\u3000" : " ");
 }
-var salt = (passphrase) => nfkd(`mnemonic${passphrase}`);
+__name(entropyToMnemonic, "entropyToMnemonic");
+var salt = /* @__PURE__ */ __name((passphrase) => nfkd(`mnemonic${passphrase}`), "salt");
 function mnemonicToSeed(mnemonic, passphrase = "") {
-  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), {
+    c: 2048,
+    dkLen: 64
+  });
 }
+__name(mnemonicToSeed, "mnemonicToSeed");
 function mnemonicToSeedSync(mnemonic, passphrase = "") {
-  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), {
+    c: 2048,
+    dkLen: 64
+  });
 }
+__name(mnemonicToSeedSync, "mnemonicToSeedSync");
 export {
   entropyToMnemonic,
   mnemonicToEntropy,

package/dist/neutral/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":";AAEA,OAAO,YAAY;AACnB,SAAS,QAAQ,mBAAmB;AACpC,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAAS,SAAS,iBAAiB;;;ACLnC,OAAO,WAAW;AAClB,OAAO,aAAa;AACpB,OAAO,YAAY;AACnB,OAAO,aAAa;AACpB,OAAO,cAAc;AACrB,OAAO,YAAY;AACnB,OAAO,uBAAuB;AAC9B,OAAO,aAAa;AACpB,OAAO,wBAAwB;AAGxB,IAAM,YAAY;AAAA,EACvB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;;;ADXA,IAAM,aAAa,CAAC,aAAuB,SAAS,CAAC,MAAM;AAK3D,SAAS,KAAK,KAAa;AACzB,MAAI,OAAO,QAAQ,SAAU,OAAM,IAAI,UAAU,0BAA0B,OAAO,GAAG,EAAE;AACvF,SAAO,IAAI,UAAU,MAAM;AAC7B;AAEA,SAAS,UAAU,KAAa;AAC9B,QAAM,OAAO,KAAK,GAAG;AACrB,QAAM,QAAQ,KAAK,MAAM,GAAG;AAC5B,MAAI,CAAC,CAAC,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,SAAS,MAAM,MAAM,EAAG,OAAM,IAAI,MAAM,kBAAkB;AACpF,SAAO,EAAE,MAAM,MAAM,MAAM;AAC7B;AAEA,SAAS,cAAc,SAAqB;AAC1C,SAAO,MAAM,SAAS,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1C;AAEA,IAAM,eAAe,CAAC,YAAwB;AAE5C,QAAM,WAAW,IAAI,QAAQ,SAAS;AAGtC,SAAO,IAAI,WAAW,CAAE,OAAO,OAAO,EAAE,CAAC,KAAK,YAAa,QAAQ,CAAC;AACtE;AAEA,SAAS,SAAS,UAAoB;AACpC,MAAI,CAAC,MAAM,QAAQ,QAAQ,KAAK,SAAS,WAAW,QAAQ,OAAO,SAAS,CAAC,MAAM;AACjF,UAAM,IAAI,MAAM,yCAAyC;AAC3D,aAAW,KAAK,UAAU;AACxB,QAAI,OAAO,MAAM,SAAU,OAAM,IAAI,MAAM,iCAAiC,CAAC,EAAE;AAAA,EACjF;AACA,SAAO,UAAU,MAAM,UAAU,SAAS,GAAG,YAAY,GAAG,UAAU,OAAO,IAAI,IAAI,GAAG,UAAU,SAAS,QAAQ,CAAC;AACtH;AAiBO,SAAS,kBAAkB,UAAkB,UAAgC;AAClF,QAAM,EAAE,MAAM,IAAI,UAAU,QAAQ;AACpC,QAAM,UAAU,SAAS,QAAQ,EAAE,OAAO,KAAK;AAC/C,gBAAc,OAAO;AACrB,SAAO;AACT;AAiBO,SAAS,kBAAkB,SAAqB,UAA4B;AACjF,gBAAc,OAAO;AACrB,QAAM,QAAQ,SAAS,QAAQ,EAAE,OAAO,OAAO;AAC/C,SAAO,MAAM,KAAK,WAAW,QAAQ,IAAI,WAAW,GAAG;AACzD;AAEA,IAAM,OAAO,CAAC,eAAuB,KAAK,WAAW,UAAU,EAAE;AAc1D,SAAS,eAAe,UAAkB,aAAa,IAAI;AAChE,SAAO,YAAY,QAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC/F;AAcO,SAAS,mBAAmB,UAAkB,aAAa,IAAI;AACpE,SAAO,OAAO,QAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC1F;","names":[]}
+{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists/index.js'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":"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","names":["assert","pbkdf2","pbkdf2Async","sha256","sha512","utils","baseUtils","czech","english","french","italian","japanese","korean","simplifiedChinese","spanish","traditionalChinese","wordlists","isJapanese","wordlist","nfkd","str","TypeError","normalize","norm","words","split","includes","length","Error","assertEntropy","entropy","assert","bytes","calcChecksum","bitsLeft","Uint8Array","sha256","getCoder","Array","isArray","i","baseUtils","chain","checksum","radix2","alphabet","mnemonicToEntropy","mnemonic","decode","entropyToMnemonic","encode","join","salt","passphrase","mnemonicToSeed","pbkdf2Async","sha512","c","dkLen","mnemonicToSeedSync","pbkdf2"]}

package/dist/node/index.cjs

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -66,50 +67,74 @@ var wordlists = {
 };
 
 // src/index.ts
-var isJapanese = (wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093";
+var isJapanese = /* @__PURE__ */ __name((wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093", "isJapanese");
 function nfkd(str) {
   if (typeof str !== "string") throw new TypeError(`Invalid mnemonic type: ${typeof str}`);
   return str.normalize("NFKD");
 }
+__name(nfkd, "nfkd");
 function normalize(str) {
   const norm = nfkd(str);
   const words = norm.split(" ");
-  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error("Invalid mnemonic");
-  return { nfkd: norm, words };
+  if (![
+    12,
+    15,
+    18,
+    21,
+    24
+  ].includes(words.length)) throw new Error("Invalid mnemonic");
+  return {
+    nfkd: norm,
+    words
+  };
 }
+__name(normalize, "normalize");
 function assertEntropy(entropy) {
   import_assert.default.bytes(entropy, 16, 20, 24, 28, 32);
 }
-var calcChecksum = (entropy) => {
+__name(assertEntropy, "assertEntropy");
+var calcChecksum = /* @__PURE__ */ __name((entropy) => {
   const bitsLeft = 8 - entropy.length / 4;
-  return new Uint8Array([(0, import_sha256.sha256)(entropy)[0] >> bitsLeft << bitsLeft]);
-};
+  return new Uint8Array([
+    (0, import_sha256.sha256)(entropy)[0] >> bitsLeft << bitsLeft
+  ]);
+}, "calcChecksum");
 function getCoder(wordlist) {
-  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string")
-    throw new Error("Worlist: expected array of 2048 strings");
+  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string") throw new Error("Worlist: expected array of 2048 strings");
   for (const i of wordlist) {
     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(wordlist));
 }
+__name(getCoder, "getCoder");
 function mnemonicToEntropy(mnemonic, wordlist) {
   const { words } = normalize(mnemonic);
   const entropy = getCoder(wordlist).decode(words);
   assertEntropy(entropy);
   return entropy;
 }
+__name(mnemonicToEntropy, "mnemonicToEntropy");
 function entropyToMnemonic(entropy, wordlist) {
   assertEntropy(entropy);
   const words = getCoder(wordlist).encode(entropy);
   return words.join(isJapanese(wordlist) ? "\u3000" : " ");
 }
-var salt = (passphrase) => nfkd(`mnemonic${passphrase}`);
+__name(entropyToMnemonic, "entropyToMnemonic");
+var salt = /* @__PURE__ */ __name((passphrase) => nfkd(`mnemonic${passphrase}`), "salt");
 function mnemonicToSeed(mnemonic, passphrase = "") {
-  return (0, import_pbkdf2.pbkdf2Async)(import_sha512.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
+  });
 }
+__name(mnemonicToSeed, "mnemonicToSeed");
 function mnemonicToSeedSync(mnemonic, passphrase = "") {
-  return (0, import_pbkdf2.pbkdf2)(import_sha512.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
+  });
 }
+__name(mnemonicToSeedSync, "mnemonicToSeedSync");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   entropyToMnemonic,

package/dist/node/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,oBAAmB;AACnB,oBAAoC;AACpC,oBAAuB;AACvB,oBAAuB;AACvB,kBAAmC;;;ACLnC,mBAAkB;AAClB,qBAAoB;AACpB,oBAAmB;AACnB,qBAAoB;AACpB,sBAAqB;AACrB,oBAAmB;AACnB,gCAA8B;AAC9B,qBAAoB;AACpB,iCAA+B;AAGxB,IAAM,YAAY;AAAA,EACvB,oBAAAA;AAAA,EACA,wBAAAC;AAAA,EACA,sBAAAC;AAAA,EACA,wBAAAC;AAAA,EACA,0BAAAC;AAAA,EACA,sBAAAC;AAAA,EACA,6CAAAC;AAAA,EACA,wBAAAC;AAAA,EACA,+CAAAC;AACF;;;ADXA,IAAM,aAAa,CAAC,aAAuB,SAAS,CAAC,MAAM;AAK3D,SAAS,KAAK,KAAa;AACzB,MAAI,OAAO,QAAQ,SAAU,OAAM,IAAI,UAAU,0BAA0B,OAAO,GAAG,EAAE;AACvF,SAAO,IAAI,UAAU,MAAM;AAC7B;AAEA,SAAS,UAAU,KAAa;AAC9B,QAAM,OAAO,KAAK,GAAG;AACrB,QAAM,QAAQ,KAAK,MAAM,GAAG;AAC5B,MAAI,CAAC,CAAC,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,SAAS,MAAM,MAAM,EAAG,OAAM,IAAI,MAAM,kBAAkB;AACpF,SAAO,EAAE,MAAM,MAAM,MAAM;AAC7B;AAEA,SAAS,cAAc,SAAqB;AAC1C,gBAAAC,QAAO,MAAM,SAAS,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1C;AAEA,IAAM,eAAe,CAAC,YAAwB;AAE5C,QAAM,WAAW,IAAI,QAAQ,SAAS;AAGtC,SAAO,IAAI,WAAW,KAAE,sBAAO,OAAO,EAAE,CAAC,KAAK,YAAa,QAAQ,CAAC;AACtE;AAEA,SAAS,SAAS,UAAoB;AACpC,MAAI,CAAC,MAAM,QAAQ,QAAQ,KAAK,SAAS,WAAW,QAAQ,OAAO,SAAS,CAAC,MAAM;AACjF,UAAM,IAAI,MAAM,yCAAyC;AAC3D,aAAW,KAAK,UAAU;AACxB,QAAI,OAAO,MAAM,SAAU,OAAM,IAAI,MAAM,iCAAiC,CAAC,EAAE;AAAA,EACjF;AACA,SAAO,YAAAC,MAAU,MAAM,YAAAA,MAAU,SAAS,GAAG,YAAY,GAAG,YAAAA,MAAU,OAAO,IAAI,IAAI,GAAG,YAAAA,MAAU,SAAS,QAAQ,CAAC;AACtH;AAiBO,SAAS,kBAAkB,UAAkB,UAAgC;AAClF,QAAM,EAAE,MAAM,IAAI,UAAU,QAAQ;AACpC,QAAM,UAAU,SAAS,QAAQ,EAAE,OAAO,KAAK;AAC/C,gBAAc,OAAO;AACrB,SAAO;AACT;AAiBO,SAAS,kBAAkB,SAAqB,UAA4B;AACjF,gBAAc,OAAO;AACrB,QAAM,QAAQ,SAAS,QAAQ,EAAE,OAAO,OAAO;AAC/C,SAAO,MAAM,KAAK,WAAW,QAAQ,IAAI,WAAW,GAAG;AACzD;AAEA,IAAM,OAAO,CAAC,eAAuB,KAAK,WAAW,UAAU,EAAE;AAc1D,SAAS,eAAe,UAAkB,aAAa,IAAI;AAChE,aAAO,2BAAY,sBAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC/F;AAcO,SAAS,mBAAmB,UAAkB,aAAa,IAAI;AACpE,aAAO,sBAAO,sBAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC1F;","names":["czech","english","french","italian","japanese","korean","simplifiedChinese","spanish","traditionalChinese","assert","baseUtils"]}
+{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists/index.js'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":"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","names":["wordlists","czech","english","french","italian","japanese","korean","simplifiedChinese","spanish","traditionalChinese","isJapanese","wordlist","nfkd","str","TypeError","normalize","norm","words","split","includes","length","Error","assertEntropy","entropy","assert","bytes","calcChecksum","bitsLeft","Uint8Array","sha256","getCoder","Array","isArray","i","baseUtils","chain","checksum","radix2","alphabet","mnemonicToEntropy","mnemonic","decode","entropyToMnemonic","encode","join","salt","passphrase","mnemonicToSeed","pbkdf2Async","sha512","c","dkLen","mnemonicToSeedSync","pbkdf2"]}

package/dist/node/index.d.cts

@@ -1,4 +1,4 @@
-export * from './wordlists';
+export * from './wordlists/index.js';
 export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
 export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
 export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;

package/dist/node/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,aAAa,CAAA;AAwD3B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,sBAAsB,CAAA;AAwDpC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}

package/dist/node/index.d.mts

@@ -1,4 +1,4 @@
-export * from './wordlists';
+export * from './wordlists/index.js';
 export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
 export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
 export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;

package/dist/node/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,aAAa,CAAA;AAwD3B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,sBAAsB,CAAA;AAwDpC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}

package/dist/node/index.d.ts

@@ -1,4 +1,4 @@
-export * from './wordlists';
+export * from './wordlists/index.js';
 export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
 export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
 export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;

package/dist/node/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,aAAa,CAAA;AAwD3B,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,sBAAsB,CAAA;AAwDpC,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,UAAU,CAKlF;AAiBD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAIjF;AAgBD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,uBAE/D;AAcD,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAK,cAEnE"}

package/dist/node/index.js

@@ -1,3 +1,6 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/index.ts
 import assert from "@noble/hashes/_assert";
 import { pbkdf2, pbkdf2Async } from "@noble/hashes/pbkdf2";
@@ -28,50 +31,74 @@ var wordlists = {
 };
 
 // src/index.ts
-var isJapanese = (wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093";
+var isJapanese = /* @__PURE__ */ __name((wordlist) => wordlist[0] === "\u3042\u3044\u3053\u304F\u3057\u3093", "isJapanese");
 function nfkd(str) {
   if (typeof str !== "string") throw new TypeError(`Invalid mnemonic type: ${typeof str}`);
   return str.normalize("NFKD");
 }
+__name(nfkd, "nfkd");
 function normalize(str) {
   const norm = nfkd(str);
   const words = norm.split(" ");
-  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error("Invalid mnemonic");
-  return { nfkd: norm, words };
+  if (![
+    12,
+    15,
+    18,
+    21,
+    24
+  ].includes(words.length)) throw new Error("Invalid mnemonic");
+  return {
+    nfkd: norm,
+    words
+  };
 }
+__name(normalize, "normalize");
 function assertEntropy(entropy) {
   assert.bytes(entropy, 16, 20, 24, 28, 32);
 }
-var calcChecksum = (entropy) => {
+__name(assertEntropy, "assertEntropy");
+var calcChecksum = /* @__PURE__ */ __name((entropy) => {
   const bitsLeft = 8 - entropy.length / 4;
-  return new Uint8Array([sha256(entropy)[0] >> bitsLeft << bitsLeft]);
-};
+  return new Uint8Array([
+    sha256(entropy)[0] >> bitsLeft << bitsLeft
+  ]);
+}, "calcChecksum");
 function getCoder(wordlist) {
-  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string")
-    throw new Error("Worlist: expected array of 2048 strings");
+  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string") throw new Error("Worlist: expected array of 2048 strings");
   for (const i of wordlist) {
     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(wordlist));
 }
+__name(getCoder, "getCoder");
 function mnemonicToEntropy(mnemonic, wordlist) {
   const { words } = normalize(mnemonic);
   const entropy = getCoder(wordlist).decode(words);
   assertEntropy(entropy);
   return entropy;
 }
+__name(mnemonicToEntropy, "mnemonicToEntropy");
 function entropyToMnemonic(entropy, wordlist) {
   assertEntropy(entropy);
   const words = getCoder(wordlist).encode(entropy);
   return words.join(isJapanese(wordlist) ? "\u3000" : " ");
 }
-var salt = (passphrase) => nfkd(`mnemonic${passphrase}`);
+__name(entropyToMnemonic, "entropyToMnemonic");
+var salt = /* @__PURE__ */ __name((passphrase) => nfkd(`mnemonic${passphrase}`), "salt");
 function mnemonicToSeed(mnemonic, passphrase = "") {
-  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), {
+    c: 2048,
+    dkLen: 64
+  });
 }
+__name(mnemonicToSeed, "mnemonicToSeed");
 function mnemonicToSeedSync(mnemonic, passphrase = "") {
-  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), {
+    c: 2048,
+    dkLen: 64
+  });
 }
+__name(mnemonicToSeedSync, "mnemonicToSeedSync");
 export {
   entropyToMnemonic,
   mnemonicToEntropy,

package/dist/node/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":";AAEA,OAAO,YAAY;AACnB,SAAS,QAAQ,mBAAmB;AACpC,SAAS,cAAc;AACvB,SAAS,cAAc;AACvB,SAAS,SAAS,iBAAiB;;;ACLnC,OAAO,WAAW;AAClB,OAAO,aAAa;AACpB,OAAO,YAAY;AACnB,OAAO,aAAa;AACpB,OAAO,cAAc;AACrB,OAAO,YAAY;AACnB,OAAO,uBAAuB;AAC9B,OAAO,aAAa;AACpB,OAAO,wBAAwB;AAGxB,IAAM,YAAY;AAAA,EACvB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;;;ADXA,IAAM,aAAa,CAAC,aAAuB,SAAS,CAAC,MAAM;AAK3D,SAAS,KAAK,KAAa;AACzB,MAAI,OAAO,QAAQ,SAAU,OAAM,IAAI,UAAU,0BAA0B,OAAO,GAAG,EAAE;AACvF,SAAO,IAAI,UAAU,MAAM;AAC7B;AAEA,SAAS,UAAU,KAAa;AAC9B,QAAM,OAAO,KAAK,GAAG;AACrB,QAAM,QAAQ,KAAK,MAAM,GAAG;AAC5B,MAAI,CAAC,CAAC,IAAI,IAAI,IAAI,IAAI,EAAE,EAAE,SAAS,MAAM,MAAM,EAAG,OAAM,IAAI,MAAM,kBAAkB;AACpF,SAAO,EAAE,MAAM,MAAM,MAAM;AAC7B;AAEA,SAAS,cAAc,SAAqB;AAC1C,SAAO,MAAM,SAAS,IAAI,IAAI,IAAI,IAAI,EAAE;AAC1C;AAEA,IAAM,eAAe,CAAC,YAAwB;AAE5C,QAAM,WAAW,IAAI,QAAQ,SAAS;AAGtC,SAAO,IAAI,WAAW,CAAE,OAAO,OAAO,EAAE,CAAC,KAAK,YAAa,QAAQ,CAAC;AACtE;AAEA,SAAS,SAAS,UAAoB;AACpC,MAAI,CAAC,MAAM,QAAQ,QAAQ,KAAK,SAAS,WAAW,QAAQ,OAAO,SAAS,CAAC,MAAM;AACjF,UAAM,IAAI,MAAM,yCAAyC;AAC3D,aAAW,KAAK,UAAU;AACxB,QAAI,OAAO,MAAM,SAAU,OAAM,IAAI,MAAM,iCAAiC,CAAC,EAAE;AAAA,EACjF;AACA,SAAO,UAAU,MAAM,UAAU,SAAS,GAAG,YAAY,GAAG,UAAU,OAAO,IAAI,IAAI,GAAG,UAAU,SAAS,QAAQ,CAAC;AACtH;AAiBO,SAAS,kBAAkB,UAAkB,UAAgC;AAClF,QAAM,EAAE,MAAM,IAAI,UAAU,QAAQ;AACpC,QAAM,UAAU,SAAS,QAAQ,EAAE,OAAO,KAAK;AAC/C,gBAAc,OAAO;AACrB,SAAO;AACT;AAiBO,SAAS,kBAAkB,SAAqB,UAA4B;AACjF,gBAAc,OAAO;AACrB,QAAM,QAAQ,SAAS,QAAQ,EAAE,OAAO,OAAO;AAC/C,SAAO,MAAM,KAAK,WAAW,QAAQ,IAAI,WAAW,GAAG;AACzD;AAEA,IAAM,OAAO,CAAC,eAAuB,KAAK,WAAW,UAAU,EAAE;AAc1D,SAAS,eAAe,UAAkB,aAAa,IAAI;AAChE,SAAO,YAAY,QAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC/F;AAcO,SAAS,mBAAmB,UAAkB,aAAa,IAAI;AACpE,SAAO,OAAO,QAAQ,UAAU,QAAQ,EAAE,MAAM,KAAK,UAAU,GAAG,EAAE,GAAG,MAAM,OAAO,GAAG,CAAC;AAC1F;","names":[]}
+{"version":3,"sources":["../../src/index.ts","../../src/wordlists/index.ts"],"sourcesContent":["/* eslint-disable import/no-internal-modules */\n/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */\nimport assert from '@noble/hashes/_assert'\nimport { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2'\nimport { sha256 } from '@noble/hashes/sha256'\nimport { sha512 } from '@noble/hashes/sha512'\nimport { utils as baseUtils } from '@scure/base'\n\nexport * from './wordlists/index.js'\n\n// Japanese wordlist\nconst isJapanese = (wordlist: string[]) => wordlist[0] === '\\u3042\\u3044\\u3053\\u304F\\u3057\\u3093'\n\n// Normalization replaces equivalent sequences of characters\n// so that any two texts that are equivalent will be reduced\n// to the same sequence of code points, called the normal form of the original text.\nfunction nfkd(str: string) {\n  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`)\n  return str.normalize('NFKD')\n}\n\nfunction normalize(str: string) {\n  const norm = nfkd(str)\n  const words = norm.split(' ')\n  if (![12, 15, 18, 21, 24].includes(words.length)) throw new Error('Invalid mnemonic')\n  return { nfkd: norm, words }\n}\n\nfunction assertEntropy(entropy: Uint8Array) {\n  assert.bytes(entropy, 16, 20, 24, 28, 32)\n}\n\nconst calcChecksum = (entropy: Uint8Array) => {\n  // Checksum is ent.length/4 bits long\n  const bitsLeft = 8 - entropy.length / 4\n  // Zero rightmost \"bitsLeft\" bits in byte\n  // For example: bitsLeft=4 val=10111101 -> 10110000\n  return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft])\n}\n\nfunction getCoder(wordlist: string[]) {\n  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')\n    throw new Error('Worlist: expected array of 2048 strings')\n  for (const i of wordlist) {\n    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`)\n  }\n  return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist))\n}\n\n/**\n * Reversible: Converts mnemonic string to raw entropy in form of byte array.\n * @param mnemonic 12-24 words\n * @param wordlist imported wordlist for specific language\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToEntropy(mnem, wordlist)\n * // Produces\n * new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {\n  const { words } = normalize(mnemonic)\n  const entropy = getCoder(wordlist).decode(words)\n  assertEntropy(entropy)\n  return entropy\n}\n\n/**\n * Reversible: Converts raw entropy in form of byte array to mnemonic string.\n * @param entropy byte array\n * @param wordlist imported wordlist for specific language\n * @returns 12-24 words\n * @example\n * const ent = new Uint8Array([\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,\n *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f\n * ]);\n * entropyToMnemonic(ent, wordlist);\n * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {\n  assertEntropy(entropy)\n  const words = getCoder(wordlist).encode(entropy)\n  return words.join(isJapanese(wordlist) ? '\\u3000' : ' ')\n}\n\nconst salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`)\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * await mnemonicToSeed(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeed(mnemonic: string, passphrase = '') {\n  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n\n/**\n * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.\n * @param mnemonic 12-24 words\n * @param passphrase string that will additionally protect the key\n * @returns 64 bytes of key data\n * @example\n * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';\n * mnemonicToSeedSync(mnem, 'password');\n * // new Uint8Array([...64 bytes])\n */\n\n/** @deprecated use @scure/bip39 instead */\nexport function mnemonicToSeedSync(mnemonic: string, passphrase = '') {\n  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 })\n}\n","/* eslint-disable import/no-internal-modules */\nimport czech from '@scure/bip39/wordlists/czech'\nimport english from '@scure/bip39/wordlists/english'\nimport french from '@scure/bip39/wordlists/french'\nimport italian from '@scure/bip39/wordlists/italian'\nimport japanese from '@scure/bip39/wordlists/japanese'\nimport korean from '@scure/bip39/wordlists/korean'\nimport simplifiedChinese from '@scure/bip39/wordlists/simplified-chinese'\nimport spanish from '@scure/bip39/wordlists/spanish'\nimport traditionalChinese from '@scure/bip39/wordlists/traditional-chinese'\n\n/** @deprecated use @scure/bip39 instead */\nexport const wordlists = {\n  czech,\n  english,\n  french,\n  italian,\n  japanese,\n  korean,\n  simplifiedChinese,\n  spanish,\n  traditionalChinese,\n}\n"],"mappings":"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","names":["assert","pbkdf2","pbkdf2Async","sha256","sha512","utils","baseUtils","czech","english","french","italian","japanese","korean","simplifiedChinese","spanish","traditionalChinese","wordlists","isJapanese","wordlist","nfkd","str","TypeError","normalize","norm","words","split","includes","length","Error","assertEntropy","entropy","assert","bytes","calcChecksum","bitsLeft","Uint8Array","sha256","getCoder","Array","isArray","i","baseUtils","chain","checksum","radix2","alphabet","mnemonicToEntropy","mnemonic","decode","entropyToMnemonic","encode","join","salt","passphrase","mnemonicToSeed","pbkdf2Async","sha512","c","dkLen","mnemonicToSeedSync","pbkdf2"]}

package/package.json

@@ -58,6 +58,6 @@
     "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js.git"
   },
   "sideEffects": false,
-  "version": "2.109.0",
+  "version": "2.110.0",
   "type": "module"
 }

package/src/index.ts

@@ -6,7 +6,7 @@ import { sha256 } from '@noble/hashes/sha256'
 import { sha512 } from '@noble/hashes/sha512'
 import { utils as baseUtils } from '@scure/base'
 
-export * from './wordlists'
+export * from './wordlists/index.js'
 
 // Japanese wordlist
 const isJapanese = (wordlist: string[]) => wordlist[0] === '\u3042\u3044\u3053\u304F\u3057\u3093'