@pezkuwi/util-crypto 14.0.13 → 14.0.14

package/build-deno/hmac/shaAsU8a.ts

@@ -1,46 +0,0 @@
-
-import { hmac } from 'https://esm.sh/@noble/hashes@1.3.3/hmac.js';
-import { sha256 } from 'https://esm.sh/@noble/hashes@1.3.3/sha256.js';
-import { sha512 } from 'https://esm.sh/@noble/hashes@1.3.3/sha512.js';
-
-import { hasBigInt, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { hmacSha256, hmacSha512, isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-const JS_HASH = {
-  256: sha256,
-  512: sha512
-};
-
-const WA_MHAC = {
-  256: hmacSha256,
-  512: hmacSha512
-};
-
-function createSha (bitLength: 256 | 512): (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean) => Uint8Array {
-  return (key: Uint8Array | string, data: Uint8Array, onlyJs?: boolean): Uint8Array =>
-    hmacShaAsU8a(key, data, bitLength, onlyJs);
-}
-
-/**
- * @name hmacShaAsU8a
- * @description creates a Hmac Sha (256/512) Uint8Array from the key & data
- */
-export function hmacShaAsU8a (key: Uint8Array | string, data: Uint8Array, bitLength: 256 | 512 = 256, onlyJs?: boolean): Uint8Array {
-  const u8aKey = u8aToU8a(key);
-
-  return !hasBigInt || (!onlyJs && isReady())
-    ? WA_MHAC[bitLength](u8aKey, data)
-    : hmac(JS_HASH[bitLength], u8aKey, data);
-}
-
-/**
- * @name hmacSha256AsU8a
- * @description creates a Hmac Sha256 Uint8Array from the key & data
- */
-export const hmacSha256AsU8a = /*#__PURE__*/ createSha(256);
-
-/**
- * @name hmacSha512AsU8a
- * @description creates a Hmac Sha512 Uint8Array from the key & data
- */
-export const hmacSha512AsU8a = /*#__PURE__*/ createSha(512);

package/build-deno/index.ts

@@ -1,4 +0,0 @@
-
-import './packageDetect.ts';
-
-export * from './bundle.ts';

package/build-deno/json/constants.ts

@@ -1,9 +0,0 @@
-
-import type { EncryptedJsonEncoding, EncryptedJsonVersion } from './types.ts';
-
-export const ENCODING: EncryptedJsonEncoding[] = ['scrypt', 'xsalsa20-poly1305'];
-export const ENCODING_NONE: EncryptedJsonEncoding[] = ['none'];
-export const ENCODING_VERSION: EncryptedJsonVersion = '3';
-
-export const NONCE_LENGTH = 24;
-export const SCRYPT_LENGTH = 32 + (3 * 4);

package/build-deno/json/decrypt.ts

@@ -1,23 +0,0 @@
-
-import type { EncryptedJson } from './types.ts';
-
-import { hexToU8a, isHex } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { base64Decode } from '../base64/index.ts';
-import { jsonDecryptData } from './decryptData.ts';
-
-export function jsonDecrypt ({ encoded, encoding }: EncryptedJson, passphrase?: string | null): Uint8Array {
-  if (!encoded) {
-    throw new Error('No encrypted data available to decode');
-  }
-
-  return jsonDecryptData(
-    isHex(encoded)
-      ? hexToU8a(encoded)
-      : base64Decode(encoded),
-    passphrase,
-    Array.isArray(encoding.type)
-      ? encoding.type
-      : [encoding.type]
-  );
-}

package/build-deno/json/decryptData.ts

@@ -1,43 +0,0 @@
-
-import type { EncryptedJsonEncoding } from './types.ts';
-
-import { stringToU8a, u8aFixLength } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { naclDecrypt } from '../nacl/index.ts';
-import { scryptEncode, scryptFromU8a } from '../scrypt/index.ts';
-import { ENCODING, NONCE_LENGTH, SCRYPT_LENGTH } from './constants.ts';
-
-export function jsonDecryptData (encrypted?: Uint8Array | null, passphrase?: string | null, encType: EncryptedJsonEncoding[] = ENCODING): Uint8Array {
-  if (!encrypted) {
-    throw new Error('No encrypted data available to decode');
-  } else if (encType.includes('xsalsa20-poly1305') && !passphrase) {
-    throw new Error('Password required to decode encrypted data');
-  }
-
-  let encoded: Uint8Array | null = encrypted;
-
-  if (passphrase) {
-    let password: Uint8Array;
-
-    if (encType.includes('scrypt')) {
-      const { params, salt } = scryptFromU8a(encrypted);
-
-      password = scryptEncode(passphrase, salt, params).password;
-      encrypted = encrypted.subarray(SCRYPT_LENGTH);
-    } else {
-      password = stringToU8a(passphrase);
-    }
-
-    encoded = naclDecrypt(
-      encrypted.subarray(NONCE_LENGTH),
-      encrypted.subarray(0, NONCE_LENGTH),
-      u8aFixLength(password, 256, true)
-    );
-  }
-
-  if (!encoded) {
-    throw new Error('Unable to decode using the supplied passphrase');
-  }
-
-  return encoded;
-}

package/build-deno/json/encrypt.ts

@@ -1,23 +0,0 @@
-
-import type { EncryptedJson } from './types.ts';
-
-import { u8aConcat } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { naclEncrypt } from '../nacl/index.ts';
-import { scryptEncode, scryptToU8a } from '../scrypt/index.ts';
-import { jsonEncryptFormat } from './encryptFormat.ts';
-
-export function jsonEncrypt (data: Uint8Array, contentType: string[], passphrase?: string | null): EncryptedJson {
-  let isEncrypted = false;
-  let encoded = data;
-
-  if (passphrase) {
-    const { params, password, salt } = scryptEncode(passphrase);
-    const { encrypted, nonce } = naclEncrypt(encoded, password.subarray(0, 32));
-
-    isEncrypted = true;
-    encoded = u8aConcat(scryptToU8a(salt, params), nonce, encrypted);
-  }
-
-  return jsonEncryptFormat(encoded, contentType, isEncrypted);
-}

package/build-deno/json/encryptFormat.ts

@@ -1,18 +0,0 @@
-
-import type { EncryptedJson } from './types.ts';
-
-import { base64Encode } from '../base64/index.ts';
-import { ENCODING, ENCODING_NONE, ENCODING_VERSION } from './constants.ts';
-
-export function jsonEncryptFormat (encoded: Uint8Array, contentType: string[], isEncrypted: boolean): EncryptedJson {
-  return {
-    encoded: base64Encode(encoded),
-    encoding: {
-      content: contentType,
-      type: isEncrypted
-        ? ENCODING
-        : ENCODING_NONE,
-      version: ENCODING_VERSION
-    }
-  };
-}

package/build-deno/json/index.ts

@@ -1,5 +0,0 @@
-
-export { jsonDecrypt } from './decrypt.ts';
-export { jsonDecryptData } from './decryptData.ts';
-export { jsonEncrypt } from './encrypt.ts';
-export { jsonEncryptFormat } from './encryptFormat.ts';

package/build-deno/json/types.ts

@@ -1,20 +0,0 @@
-
-export type EncryptedJsonVersion = '0' | '1' | '2' | '3';
-
-export type EncryptedJsonEncoding = 'none' | 'scrypt' | 'xsalsa20-poly1305';
-
-export interface EncryptedJsonDescriptor {
-  /** Descriptor for the content */
-  content: string[];
-  /** The encoding (in current/latest versions this is always an array) */
-  type: EncryptedJsonEncoding | EncryptedJsonEncoding[];
-  /** The version of encoding applied */
-  version: EncryptedJsonVersion;
-}
-
-export interface EncryptedJson {
-  /** The encoded string */
-  encoded: string;
-  /** The encoding used */
-  encoding: EncryptedJsonDescriptor;
-}

package/build-deno/keccak/asU8a.ts

@@ -1,45 +0,0 @@
-import { Buffer } from 'node:buffer';
-
-
-import { keccak_256 as keccak256Js, keccak_512 as keccak512Js } from 'https://esm.sh/@noble/hashes@1.3.3/sha3.js';
-
-import { keccak256, keccak512 } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { createAsHex, createBitHasher, createDualHasher } from '../helpers.ts';
-
-/**
- * @name keccakAsU8a
- * @summary Creates a keccak Uint8Array from the input.
- * @description
- * From either a `string` or a `Buffer` input, create the keccak and return the result as a `Uint8Array`.
- * @example
- * <BR>
- *
- * ```javascript
- * import { keccakAsU8a } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * keccakAsU8a('123'); // => Uint8Array
- * ```
- */
-export const keccakAsU8a = /*#__PURE__*/ createDualHasher(
-  { 256: keccak256, 512: keccak512 },
-  { 256: keccak256Js, 512: keccak512Js }
-);
-
-/**
- * @name keccak256AsU8a
- * @description Creates a keccak256 Uint8Array from the input.
- */
-export const keccak256AsU8a = /*#__PURE__*/ createBitHasher(256, keccakAsU8a);
-
-/**
- * @name keccak512AsU8a
- * @description Creates a keccak512 Uint8Array from the input.
- */
-export const keccak512AsU8a = /*#__PURE__*/ createBitHasher(512, keccakAsU8a);
-
-/**
- * @name keccakAsHex
- * @description Creates a keccak hex string from the input.
- */
-export const keccakAsHex = /*#__PURE__*/ createAsHex(keccakAsU8a);

package/build-deno/keccak/index.ts

@@ -1,6 +0,0 @@
-
-/**
- * @summary Create Keccak256/512 values as hex & Uint8Array output
- */
-
-export { keccak256AsU8a, keccak512AsU8a, keccakAsHex, keccakAsU8a } from './asU8a.ts';

package/build-deno/key/DeriveJunction.ts

@@ -1,77 +0,0 @@
-
-import { BN, bnToU8a, compactAddLength, hexToU8a, isBigInt, isBn, isHex, isNumber, isString, stringToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { blake2AsU8a } from '../blake2/asU8a.ts';
-import { BN_LE_256_OPTS } from '../bn.ts';
-
-const RE_NUMBER = /^\d+$/;
-
-const JUNCTION_ID_LEN = 32;
-
-export class DeriveJunction {
-  readonly #chainCode: Uint8Array = new Uint8Array(32);
-
-  #isHard = false;
-
-  public static from (value: string): DeriveJunction {
-    const result = new DeriveJunction();
-    const [code, isHard] = value.startsWith('/')
-      ? [value.substring(1), true]
-      : [value, false];
-
-    result.soft(
-      RE_NUMBER.test(code)
-        ? new BN(code, 10)
-        : code
-    );
-
-    return isHard
-      ? result.harden()
-      : result;
-  }
-
-  public get chainCode (): Uint8Array {
-    return this.#chainCode;
-  }
-
-  public get isHard (): boolean {
-    return this.#isHard;
-  }
-
-  public get isSoft (): boolean {
-    return !this.#isHard;
-  }
-
-  public hard (value: number | string | bigint | BN | Uint8Array): DeriveJunction {
-    return this.soft(value).harden();
-  }
-
-  public harden (): DeriveJunction {
-    this.#isHard = true;
-
-    return this;
-  }
-
-  public soft (value: number | string | bigint | BN | Uint8Array): DeriveJunction {
-    if (isNumber(value) || isBn(value) || isBigInt(value)) {
-      return this.soft(bnToU8a(value, BN_LE_256_OPTS));
-    } else if (isHex(value)) {
-      return this.soft(hexToU8a(value));
-    } else if (isString(value)) {
-      return this.soft(compactAddLength(stringToU8a(value)));
-    } else if (value.length > JUNCTION_ID_LEN) {
-      return this.soft(blake2AsU8a(value));
-    }
-
-    this.#chainCode.fill(0);
-    this.#chainCode.set(value, 0);
-
-    return this;
-  }
-
-  public soften (): DeriveJunction {
-    this.#isHard = false;
-
-    return this;
-  }
-}

package/build-deno/key/extractPath.ts

@@ -1,35 +0,0 @@
-
-import { DeriveJunction } from './DeriveJunction.ts';
-
-const RE_JUNCTION = /\/(\/?)([^/]+)/g;
-
-export interface ExtractResult {
-  parts: string[] | null;
-  path: DeriveJunction[];
-}
-
-/**
- * @description Extract derivation junctions from the supplied path
- */
-export function keyExtractPath (derivePath: string): ExtractResult {
-  const parts = derivePath.match(RE_JUNCTION);
-  const path: DeriveJunction[] = [];
-  let constructed = '';
-
-  if (parts) {
-    constructed = parts.join('');
-
-    for (const p of parts) {
-      path.push(DeriveJunction.from(p.substring(1)));
-    }
-  }
-
-  if (constructed !== derivePath) {
-    throw new Error(`Re-constructed path "${constructed}" does not match input`);
-  }
-
-  return {
-    parts,
-    path
-  };
-}

package/build-deno/key/extractSuri.ts

@@ -1,38 +0,0 @@
-
-import type { DeriveJunction } from './DeriveJunction.ts';
-
-import { keyExtractPath } from './extractPath.ts';
-
-export interface ExtractResult {
-  derivePath: string,
-  password?: string;
-  path: DeriveJunction[];
-  phrase: string;
-}
-
-const RE_CAPTURE = /^((0x[a-fA-F0-9]+|[\p{L}\d]+(?: [\p{L}\d]+)*))((\/\/?[^/]+)*)(\/\/\/(.*))?$/u;
-
-/**
- * @description Extracts the phrase, path and password from a SURI format for specifying secret keys `<secret>/<soft-key>//<hard-key>///<password>` (the `///password` may be omitted, and `/<soft-key>` and `//<hard-key>` maybe repeated and mixed).
- */
-export function keyExtractSuri (suri: string): ExtractResult {
-  // Normalize Unicode to NFC to avoid accent-related mismatches
-  const normalizedSuri = suri.normalize('NFC');
-
-  // eslint-disable-next-line @typescript-eslint/prefer-regexp-exec
-  const matches = normalizedSuri.match(RE_CAPTURE);
-
-  if (matches === null) {
-    throw new Error('Unable to match provided value to a secret URI');
-  }
-
-  const [, phrase, , derivePath, , , password] = matches;
-  const { path } = keyExtractPath(derivePath);
-
-  return {
-    derivePath,
-    password,
-    path,
-    phrase
-  };
-}

package/build-deno/key/fromPath.ts

@@ -1,26 +0,0 @@
-
-import type { Keypair, KeypairType } from '../types.ts';
-import type { DeriveJunction } from './DeriveJunction.ts';
-
-import { keyHdkdEcdsa } from './hdkdEcdsa.ts';
-import { keyHdkdEd25519 } from './hdkdEd25519.ts';
-import { keyHdkdSr25519 } from './hdkdSr25519.ts';
-
-const generators = {
-  ecdsa: keyHdkdEcdsa,
-  ed25519: keyHdkdEd25519,
-  // FIXME This is Substrate-compatible, not Ethereum-compatible
-  ethereum: keyHdkdEcdsa,
-  sr25519: keyHdkdSr25519
-};
-
-export function keyFromPath (pair: Keypair, path: DeriveJunction[], type: KeypairType): Keypair {
-  const keyHdkd = generators[type];
-  let result = pair;
-
-  for (const junction of path) {
-    result = keyHdkd(result, junction);
-  }
-
-  return result;
-}

package/build-deno/key/hdkdDerive.ts

@@ -1,15 +0,0 @@
-
-import type { Keypair } from '../types.ts';
-import type { DeriveJunction } from './DeriveJunction.ts';
-
-export function createSeedDeriveFn (fromSeed: (seed: Uint8Array) => Keypair, derive: (seed: Uint8Array, chainCode: Uint8Array) => Uint8Array): (keypair: Keypair, junction: DeriveJunction) => Keypair {
-  return (keypair: Keypair, { chainCode, isHard }: DeriveJunction): Keypair => {
-    if (!isHard) {
-      throw new Error('A soft key was found in the path and is not supported');
-    }
-
-    return fromSeed(
-      derive(keypair.secretKey.subarray(0, 32), chainCode)
-    );
-  };
-}

package/build-deno/key/hdkdEcdsa.ts

@@ -1,6 +0,0 @@
-
-import { secp256k1DeriveHard } from '../secp256k1/deriveHard.ts';
-import { secp256k1PairFromSeed } from '../secp256k1/pair/fromSeed.ts';
-import { createSeedDeriveFn } from './hdkdDerive.ts';
-
-export const keyHdkdEcdsa = /*#__PURE__*/ createSeedDeriveFn(secp256k1PairFromSeed, secp256k1DeriveHard);

package/build-deno/key/hdkdEd25519.ts

@@ -1,5 +0,0 @@
-
-import { ed25519DeriveHard, ed25519PairFromSeed } from '../ed25519/index.ts';
-import { createSeedDeriveFn } from './hdkdDerive.ts';
-
-export const keyHdkdEd25519 = /*#__PURE__*/ createSeedDeriveFn(ed25519PairFromSeed, ed25519DeriveHard);

package/build-deno/key/hdkdSr25519.ts

@@ -1,12 +0,0 @@
-
-import type { Keypair } from '../types.ts';
-import type { DeriveJunction } from './DeriveJunction.ts';
-
-import { sr25519DeriveHard } from '../sr25519/deriveHard.ts';
-import { sr25519DeriveSoft } from '../sr25519/deriveSoft.ts';
-
-export function keyHdkdSr25519 (keypair: Keypair, { chainCode, isSoft }: DeriveJunction): Keypair {
-  return isSoft
-    ? sr25519DeriveSoft(keypair, chainCode)
-    : sr25519DeriveHard(keypair, chainCode);
-}

package/build-deno/key/index.ts

@@ -1,10 +0,0 @@
-
-/**
- * @summary Create keys from paths, seeds and password
- */
-export { keyExtractPath } from './extractPath.ts';
-export { keyExtractSuri } from './extractSuri.ts';
-export { keyFromPath } from './fromPath.ts';
-export { keyHdkdEcdsa } from './hdkdEcdsa.ts';
-export { keyHdkdEd25519 } from './hdkdEd25519.ts';
-export { keyHdkdSr25519 } from './hdkdSr25519.ts';

package/build-deno/mnemonic/bip39.ts

@@ -1,115 +0,0 @@
-import { Buffer } from 'node:buffer';
-
-
-
-import { stringToU8a, u8aToU8a } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-
-import { pbkdf2Encode } from '../pbkdf2/index.ts';
-import { randomAsU8a } from '../random/index.ts';
-import { sha256AsU8a } from '../sha/index.ts';
-import DEFAULT_WORDLIST from './wordlists/en.ts';
-
-const INVALID_MNEMONIC = 'Invalid mnemonic';
-const INVALID_ENTROPY = 'Invalid entropy';
-const INVALID_CHECKSUM = 'Invalid mnemonic checksum';
-
-/** @internal */
-function normalize (str?: string): string {
-  return (str || '').normalize('NFKD');
-}
-
-/** @internal */
-function binaryToByte (bin: string): number {
-  return parseInt(bin, 2);
-}
-
-/** @internal */
-function bytesToBinary (bytes: number[]): string {
-  return bytes.map((x) => x.toString(2).padStart(8, '0')).join('');
-}
-
-/** @internal */
-function deriveChecksumBits (entropyBuffer: Uint8Array): string {
-  return bytesToBinary(
-    Array.from(sha256AsU8a(entropyBuffer))
-  ).slice(0, (entropyBuffer.length * 8) / 32);
-}
-
-export function mnemonicToSeedSync (mnemonic: string, password?: string): Uint8Array {
-  return pbkdf2Encode(
-    stringToU8a(normalize(mnemonic)),
-    stringToU8a(`mnemonic${normalize(password)}`)
-  ).password;
-}
-
-export function mnemonicToEntropy (mnemonic: string, wordlist: string[] = DEFAULT_WORDLIST): Uint8Array {
-  const words = normalize(mnemonic).split(' ');
-
-  if (words.length % 3 !== 0) {
-    throw new Error(INVALID_MNEMONIC);
-  }
-
-  // convert word indices to 11 bit binary strings
-  const bits = words
-    .map((word): string => {
-      const index = wordlist.indexOf(word);
-
-      if (index === -1) {
-        throw new Error(INVALID_MNEMONIC);
-      }
-
-      return index.toString(2).padStart(11, '0');
-    })
-    .join('');
-
-  // split the binary string into ENT/CS
-  const dividerIndex = Math.floor(bits.length / 33) * 32;
-  const entropyBits = bits.slice(0, dividerIndex);
-  const checksumBits = bits.slice(dividerIndex);
-
-  // calculate the checksum and compare
-  const matched = entropyBits.match(/(.{1,8})/g);
-  const entropyBytes = matched?.map(binaryToByte);
-
-  if (!entropyBytes || (entropyBytes.length % 4 !== 0) || (entropyBytes.length < 16) || (entropyBytes.length > 32)) {
-    throw new Error(INVALID_ENTROPY);
-  }
-
-  const entropy = u8aToU8a(entropyBytes);
-
-  if (deriveChecksumBits(entropy) !== checksumBits) {
-    throw new Error(INVALID_CHECKSUM);
-  }
-
-  return entropy;
-}
-
-export function entropyToMnemonic (entropy: Uint8Array, wordlist: string[] = DEFAULT_WORDLIST): string {
-  // 128 <= ENT <= 256
-  if ((entropy.length % 4 !== 0) || (entropy.length < 16) || (entropy.length > 32)) {
-    throw new Error(INVALID_ENTROPY);
-  }
-
-  const matched = `${bytesToBinary(Array.from(entropy))}${deriveChecksumBits(entropy)}`.match(/(.{1,11})/g);
-  const mapped = matched?.map((b) => wordlist[binaryToByte(b)]);
-
-  if (!mapped || (mapped.length < 12)) {
-    throw new Error('Unable to map entropy to mnemonic');
-  }
-
-  return mapped.join(' ');
-}
-
-export function generateMnemonic (numWords: 12 | 15 | 18 | 21 | 24, wordlist?: string[]): string {
-  return entropyToMnemonic(randomAsU8a((numWords / 3) * 4), wordlist);
-}
-
-export function validateMnemonic (mnemonic: string, wordlist?: string[]): boolean {
-  try {
-    mnemonicToEntropy(mnemonic, wordlist);
-  } catch {
-    return false;
-  }
-
-  return true;
-}

package/build-deno/mnemonic/generate.ts

@@ -1,23 +0,0 @@
-
-import { hasBigInt } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { bip39Generate, isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { generateMnemonic } from './bip39.ts';
-
-/**
- * @name mnemonicGenerate
- * @summary Creates a valid mnemonic string using using [BIP39](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
- * @example
- * <BR>
- *
- * ```javascript
- * import { mnemonicGenerate } from 'https://deno.land/x/pezkuwi/util-crypto/mod.ts';
- *
- * const mnemonic = mnemonicGenerate(); // => string
- * ```
- */
-export function mnemonicGenerate (numWords: 12 | 15 | 18 | 21 | 24 = 12, wordlist?: string[], onlyJs?: boolean): string {
-  return !hasBigInt || (!wordlist && !onlyJs && isReady())
-    ? bip39Generate(numWords)
-    : generateMnemonic(numWords, wordlist);
-}

package/build-deno/mnemonic/index.ts

@@ -1,9 +0,0 @@
-
-/**
- * @summary Create valid mnemonic strings, validate them using BIP39, and convert them to valid seeds
- */
-export { mnemonicGenerate } from './generate.ts';
-export { mnemonicToEntropy } from './toEntropy.ts';
-export { mnemonicToLegacySeed } from './toLegacySeed.ts';
-export { mnemonicToMiniSecret } from './toMiniSecret.ts';
-export { mnemonicValidate } from './validate.ts';

package/build-deno/mnemonic/toEntropy.ts

@@ -1,11 +0,0 @@
-
-import { hasBigInt } from 'https://deno.land/x/pezkuwi/util/mod.ts';
-import { bip39ToEntropy, isReady } from 'https://deno.land/x/pezkuwi/wasm-crypto/mod.ts';
-
-import { mnemonicToEntropy as jsToEntropy } from './bip39.ts';
-
-export function mnemonicToEntropy (mnemonic: string, wordlist?: string[], onlyJs?: boolean): Uint8Array {
-  return !hasBigInt || (!wordlist && !onlyJs && isReady())
-    ? bip39ToEntropy(mnemonic)
-    : jsToEntropy(mnemonic, wordlist);
-}