text: import {
    WordArray,
    Hasher,
  } from './core.js';
  
  // Initialization and round constants tables
  const H = [];
  const K = [];
  
  // Compute constants
  const isPrime = (n) => {
    const sqrtN = Math.sqrt(n);
    for (let factor = 2; factor <= sqrtN; factor += 1) {
      if (!(n % factor)) {
        return false;
      }
    }
  
    return true;
  };
  
  const getFractionalBits = n => ((n - (n | 0)) * 0x100000000) | 0;
  
  let n = 2;
  let nPrime = 0;
  while (nPrime < 64) {
    if (isPrime(n)) {
      if (nPrime < 8) {
        H[nPrime] = getFractionalBits(n ** (1 / 2));
      }
      K[nPrime] = getFractionalBits(n ** (1 / 3));
  
      nPrime += 1;
    }
  
    n += 1;
  }
  
  // Reusable object
  const W = [];
  
  /**
   * SHA-256 hash algorithm.
   */
  export class SHA256Algo extends Hasher {
    _doReset() {
      this._hash = new WordArray(H.slice(0));
    }
  
    _doProcessBlock(M, offset) {
      // Shortcut
      const _H = this._hash.words;
  
      // Working variables
      let a = _H[0];
      let b = _H[1];
      let c = _H[2];
      let d = _H[3];
      let e = _H[4];
      let f = _H[5];
      let g = _H[6];
      let h = _H[7];
  
      // Computation
      for (let i = 0; i < 64; i += 1) {
        if (i < 16) {
          W[i] = M[offset + i] | 0;
        } else {
          const gamma0x = W[i - 15];
          const gamma0 = ((gamma0x << 25) | (gamma0x >>> 7))
            ^ ((gamma0x << 14) | (gamma0x >>> 18))
            ^ (gamma0x >>> 3);
  
          const gamma1x = W[i - 2];
          const gamma1 = ((gamma1x << 15) | (gamma1x >>> 17))
            ^ ((gamma1x << 13) | (gamma1x >>> 19))
            ^ (gamma1x >>> 10);
  
          W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
        }
  
        const ch = (e & f) ^ (~e & g);
        const maj = (a & b) ^ (a & c) ^ (b & c);
  
        const sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));
        const sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25));
  
        const t1 = h + sigma1 + ch + K[i] + W[i];
        const t2 = sigma0 + maj;
  
        h = g;
        g = f;
        f = e;
        e = (d + t1) | 0;
        d = c;
        c = b;
        b = a;
        a = (t1 + t2) | 0;
      }
  
      // Intermediate hash value
      _H[0] = (_H[0] + a) | 0;
      _H[1] = (_H[1] + b) | 0;
      _H[2] = (_H[2] + c) | 0;
      _H[3] = (_H[3] + d) | 0;
      _H[4] = (_H[4] + e) | 0;
      _H[5] = (_H[5] + f) | 0;
      _H[6] = (_H[6] + g) | 0;
      _H[7] = (_H[7] + h) | 0;
    }
  
    _doFinalize() {
      // Shortcuts
      const data = this._data;
      const dataWords = data.words;
  
      const nBitsTotal = this._nDataBytes * 8;
      const nBitsLeft = data.sigBytes * 8;
  
      // Add padding
      dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - (nBitsLeft % 32));
      dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
      dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
      data.sigBytes = dataWords.length * 4;
  
      // Hash final blocks
      this._process();
  
      // Return final computed hash
      return this._hash;
    }
  
    clone() {
      const clone = super.clone.call(this);
      clone._hash = this._hash.clone();
  
      return clone;
    }
  }
  
  /**
   * Shortcut function to the hasher's object interface.
   *
   * @param {WordArray|string} message The message to hash.
   *
   * @return {WordArray} The hash.
   *
   * @static
   *
   * @example
   *
   *     var hash = CryptoJS.SHA256('message');
   *     var hash = CryptoJS.SHA256(wordArray);
   */
  export const SHA256 = Hasher._createHelper(SHA256Algo);
  
  /**
   * Shortcut function to the HMAC's object interface.
   *
   * @param {WordArray|string} message The message to hash.
   * @param {WordArray|string} key The secret key.
   *
   * @return {WordArray} The HMAC.
   *
   * @static
   *
   * @example
   *
   *     var hmac = CryptoJS.HmacSHA256(message, key);
   */
  export const HmacSHA256 = Hasher._createHmacHelper(SHA256Algo);
  