update ci.yml

Co-authored-by: zerenzhang <zerenzhang@trip.com>

.covignore

@@ -1,2 +0,0 @@
-/node_modules/
-/tests/

.github/workflows/ci.yml

@@ -0,0 +1,44 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+      branches:
+        - master
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [16.x, 18.x, 20.x, 22.x]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Node ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        if: matrix.node-version == '22.x'
+        run: npm run build
+
+      - name: Run tests
+        run: npm test
+
+      - name: Generate coverage report
+        if: matrix.node-version == '22.x'
+        run: npm run coverage
+
+      - name: Upload to coveralls
+        if: matrix.node-version == '22.x'
+        uses: coverallsapp/github-action@v2
+        with:
+          file: ./coverage.lcov

.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24.x
+          registry-url: https://registry.npmjs.org
+          package-manager-cache: false
+
+      - run: npm ci
+
+      - name: Verify release version
+        run: |
+          PACKAGE_VERSION=$(node -p "require('./package.json').version")
+          test "$GITHUB_REF_NAME" = "v$PACKAGE_VERSION"
+
+      - run: npm run build
+      - run: npm test
+      - run: npm publish

.gitignore

@@ -1,2 +1,4 @@
 /node_modules/
-/covreporter/
+/coverage/
+/.nyc_output/
+/coverage.lcov

.npmignore

@@ -0,0 +1,8 @@
+/node_modules/
+/coverage/
+/.nyc_output/
+/tests/
+.covignore
+.travis.yml
+.npmignore
+bower.json

.travis.yml

@@ -1,11 +0,0 @@
-language: node_js
-node_js:
-  - "6.11.4"
-  - "8.6.0"
-before_install:
-  - npm install coveralls
-  - npm install mocha-lcov-reporter
-script: npm run-script coveralls
-branches:
-  only:
-    - master

CHANGELOG.md

@@ -1,5 +1,55 @@
 # Change Log
 
+## v0.12.0 / 2026-07-18
+### Added
+- support ESM #44
+- Set up GitHub release action / provenance #46
+
+### Fixed
+- Fix uploading coverage to coveralls #52
+- fix recognize environment is node when use browserfs #53
+
+## v0.11.1 / 2025-05-24
+### Fixed
+- Fix NodeJS check for electron renderer #49
+
+## v0.11.0 / 2024-01-24
+### Fixed
+- Generates incorrect hash in some cases #43
+- dependencies and security issues. #41
+
+## v0.10.1 / 2023-08-31
+### Added
+- Disable webpack polyfill.
+
+## v0.10.0 / 2023-08-30
+### Fixed
+- Chrome bug by workaround. #40
+- deprecated `new Buffer`, replace with `Buffer.from`. #34
+- dependencies and security issues. #32, #36
+
+### Changed
+- TypeScript interface, secretKey can be bytes like message. #23, #25
+- remove `eval` and use `require` directly. #18, #26
+
+## v0.9.0 / 2017-12-18
+### Fixed
+- incorrect result when first bit is 1 of bytes.
+
+### Changed
+- throw error by Error oject. #13
+
+### Added
+- TypeScript interfaces. #12
+
+## v0.8.0 / 2017-11-19
+### Added
+- support for web worker.
+- typescript types. #10
+
+### Changed
+- prevent webpack to require dependencies.
+
 ## v0.7.1 / 2017-10-31
 ### Improved
 - performance of hBytes increment.

LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2017 Chen, Yi-Cyuan
+Copyright (c) 2014-2026 Chen, Yi-Cyuan
 
 MIT License
 

README.md

@@ -1,13 +1,15 @@
 # js-sha256
-[![Build Status](https://travis-ci.org/emn178/js-sha256.svg?branch=master)](https://travis-ci.org/emn178/js-sha256)
+[![CI](https://github.com/emn178/js-sha256/actions/workflows/ci.yml/badge.svg)](https://github.com/emn178/js-sha256/actions/workflows/ci.yml)
 [![Coverage Status](https://coveralls.io/repos/emn178/js-sha256/badge.svg?branch=master)](https://coveralls.io/r/emn178/js-sha256?branch=master)
 [![CDNJS](https://img.shields.io/cdnjs/v/js-sha256.svg)](https://cdnjs.com/libraries/js-sha256/)  
 [![NPM](https://nodei.co/npm/js-sha256.png?stars&downloads)](https://nodei.co/npm/js-sha256/)  
 A simple SHA-256 / SHA-224 hash function for JavaScript supports UTF-8 encoding.
 
 ## Demo
-[SHA256 Online](http://emn178.github.io/online-tools/sha256.html)  
-[SHA224 Online](http://emn178.github.io/online-tools/sha224.html)  
+[SHA256 Online](https://emn178.github.io/online-tools/sha256.html)  
+[SHA224 Online](https://emn178.github.io/online-tools/sha224.html)  
+[SHA256 File Online](https://emn178.github.io/online-tools/sha256_checksum.html)  
+[SHA225 File Online](https://emn178.github.io/online-tools/sha224_checksum.html)  
 
 ## Download
 [Compress](https://raw.github.com/emn178/js-sha256/master/build/sha256.min.js)  
@@ -48,6 +50,8 @@ var hash2 = sha256.hmac.update('key', 'Message to hash');
 hash2.update('Message2 to hash');
 hash2.array();
 ```
+
+### Node.js
 If you use node.js, you should require the module first:
 ```JavaScript
 var sha256 = require('js-sha256');
@@ -57,6 +61,16 @@ or
 var sha256 = require('js-sha256').sha256;
 var sha224 = require('js-sha256').sha224;
 ```
+or
+```JavaScript
+const { sha256, sha224 } = require('js-sha256');
+```
+### TypeScript
+If you use TypeScript, you can import like this:
+```TypeScript
+import { sha256, sha224 } from 'js-sha256';
+```
+### RequireJS
 It supports AMD:
 ```JavaScript
 require(['your/path/sha256.js'], function(sha256) {
@@ -88,8 +102,11 @@ sha256.digest(''); // [227, 176, 196, 66, 152, 252, 28, 20, 154, 251, 244, 200,
 sha256.arrayBuffer(''); // ArrayBuffer
 ```
 
+## Benchmark
+[jsPerf Benchmark](https://jsperf.app/cidole/2)
+
 ## License
-The project is released under the [MIT license](http://www.opensource.org/licenses/MIT).
+The project is released under the [MIT license](https://opensource.org/license/mit/).
 
 ## Contact
 The project's website is located at https://github.com/emn178/js-sha256  

bower.json

@@ -1,6 +1,6 @@
 {
   "name": "js-sha256",
-  "version": "0.7.1",
+  "version": "0.12.0",
   "main": ["src/sha256.js"],
   "ignore": [
     "samples",

build/sha256.mjs

@@ -0,0 +1,497 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var sha256$1 = {exports: {}};
+
+/**
+ * [js-sha256]{@link https://github.com/emn178/js-sha256}
+ *
+ * @version 0.12.0
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
+ * @copyright Chen, Yi-Cyuan 2014-2026
+ * @license MIT
+ */
+
+(function (module) {
+	/*jslint bitwise: true */
+	(function () {
+
+	  var ERROR = 'input is invalid type';
+	  var WINDOW = typeof window === 'object';
+	  var root = WINDOW ? window : {};
+	  if (root.JS_SHA256_NO_WINDOW) {
+	    WINDOW = false;
+	  }
+	  var WEB_WORKER = !WINDOW && typeof self === 'object';
+	  if (WEB_WORKER) {
+	    root = self;
+	  }
+	  var COMMON_JS = !root.JS_SHA256_NO_COMMON_JS && 'object' === 'object' && module.exports;
+	  var ARRAY_BUFFER = !root.JS_SHA256_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined';
+	  var HEX_CHARS = '0123456789abcdef'.split('');
+	  var EXTRA = [-2147483648, 8388608, 32768, 128];
+	  var SHIFT = [24, 16, 8, 0];
+	  var K = [
+	    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+	    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+	    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+	    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+	    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+	    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+	    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+	    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+	  ];
+	  var OUTPUT_TYPES = ['hex', 'array', 'digest', 'arrayBuffer'];
+
+	  var blocks = [];
+
+	  if (root.JS_SHA256_NO_NODE_JS || !Array.isArray) {
+	    Array.isArray = function (obj) {
+	      return Object.prototype.toString.call(obj) === '[object Array]';
+	    };
+	  }
+
+	  if (ARRAY_BUFFER && (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {
+	    ArrayBuffer.isView = function (obj) {
+	      return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer;
+	    };
+	  }
+
+	  var createOutputMethod = function (outputType, is224) {
+	    return function (message) {
+	      return new Sha256(is224, true).update(message)[outputType]();
+	    };
+	  };
+
+	  var createMethod = function (is224) {
+	    var method = createOutputMethod('hex', is224);
+	    method.create = function () {
+	      return new Sha256(is224);
+	    };
+	    method.update = function (message) {
+	      return method.create().update(message);
+	    };
+	    for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
+	      var type = OUTPUT_TYPES[i];
+	      method[type] = createOutputMethod(type, is224);
+	    }
+	    return method;
+	  };
+
+	  var createHmacOutputMethod = function (outputType, is224) {
+	    return function (key, message) {
+	      return new HmacSha256(key, is224, true).update(message)[outputType]();
+	    };
+	  };
+
+	  var createHmacMethod = function (is224) {
+	    var method = createHmacOutputMethod('hex', is224);
+	    method.create = function (key) {
+	      return new HmacSha256(key, is224);
+	    };
+	    method.update = function (key, message) {
+	      return method.create(key).update(message);
+	    };
+	    for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
+	      var type = OUTPUT_TYPES[i];
+	      method[type] = createHmacOutputMethod(type, is224);
+	    }
+	    return method;
+	  };
+
+	  function Sha256(is224, sharedMemory) {
+	    if (sharedMemory) {
+	      blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+	        blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+	        blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+	        blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+	      this.blocks = blocks;
+	    } else {
+	      this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+	    }
+
+	    if (is224) {
+	      this.h0 = 0xc1059ed8;
+	      this.h1 = 0x367cd507;
+	      this.h2 = 0x3070dd17;
+	      this.h3 = 0xf70e5939;
+	      this.h4 = 0xffc00b31;
+	      this.h5 = 0x68581511;
+	      this.h6 = 0x64f98fa7;
+	      this.h7 = 0xbefa4fa4;
+	    } else { // 256
+	      this.h0 = 0x6a09e667;
+	      this.h1 = 0xbb67ae85;
+	      this.h2 = 0x3c6ef372;
+	      this.h3 = 0xa54ff53a;
+	      this.h4 = 0x510e527f;
+	      this.h5 = 0x9b05688c;
+	      this.h6 = 0x1f83d9ab;
+	      this.h7 = 0x5be0cd19;
+	    }
+
+	    this.block = this.start = this.bytes = this.hBytes = 0;
+	    this.finalized = this.hashed = false;
+	    this.first = true;
+	    this.is224 = is224;
+	  }
+
+	  Sha256.prototype.update = function (message) {
+	    if (this.finalized) {
+	      return;
+	    }
+	    var notString, type = typeof message;
+	    if (type !== 'string') {
+	      if (type === 'object') {
+	        if (message === null) {
+	          throw new Error(ERROR);
+	        } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
+	          message = new Uint8Array(message);
+	        } else if (!Array.isArray(message)) {
+	          if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {
+	            throw new Error(ERROR);
+	          }
+	        }
+	      } else {
+	        throw new Error(ERROR);
+	      }
+	      notString = true;
+	    }
+	    var code, index = 0, i, length = message.length, blocks = this.blocks;
+	    while (index < length) {
+	      if (this.hashed) {
+	        this.hashed = false;
+	        blocks[0] = this.block;
+	        this.block = blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+	          blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+	          blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+	          blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+	      }
+
+	      if (notString) {
+	        for (i = this.start; index < length && i < 64; ++index) {
+	          blocks[i >>> 2] |= message[index] << SHIFT[i++ & 3];
+	        }
+	      } else {
+	        for (i = this.start; index < length && i < 64; ++index) {
+	          code = message.charCodeAt(index);
+	          if (code < 0x80) {
+	            blocks[i >>> 2] |= code << SHIFT[i++ & 3];
+	          } else if (code < 0x800) {
+	            blocks[i >>> 2] |= (0xc0 | (code >>> 6)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+	          } else if (code < 0xd800 || code >= 0xe000) {
+	            blocks[i >>> 2] |= (0xe0 | (code >>> 12)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | ((code >>> 6) & 0x3f)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+	          } else {
+	            code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
+	            blocks[i >>> 2] |= (0xf0 | (code >>> 18)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | ((code >>> 12) & 0x3f)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | ((code >>> 6) & 0x3f)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+	          }
+	        }
+	      }
+
+	      this.lastByteIndex = i;
+	      this.bytes += i - this.start;
+	      if (i >= 64) {
+	        this.block = blocks[16];
+	        this.start = i - 64;
+	        this.hash();
+	        this.hashed = true;
+	      } else {
+	        this.start = i;
+	      }
+	    }
+	    if (this.bytes > 4294967295) {
+	      this.hBytes += this.bytes / 4294967296 << 0;
+	      this.bytes = this.bytes % 4294967296;
+	    }
+	    return this;
+	  };
+
+	  Sha256.prototype.finalize = function () {
+	    if (this.finalized) {
+	      return;
+	    }
+	    this.finalized = true;
+	    var blocks = this.blocks, i = this.lastByteIndex;
+	    blocks[16] = this.block;
+	    blocks[i >>> 2] |= EXTRA[i & 3];
+	    this.block = blocks[16];
+	    if (i >= 56) {
+	      if (!this.hashed) {
+	        this.hash();
+	      }
+	      blocks[0] = this.block;
+	      blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+	        blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+	        blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+	        blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+	    }
+	    blocks[14] = this.hBytes << 3 | this.bytes >>> 29;
+	    blocks[15] = this.bytes << 3;
+	    this.hash();
+	  };
+
+	  Sha256.prototype.hash = function () {
+	    var a = this.h0, b = this.h1, c = this.h2, d = this.h3, e = this.h4, f = this.h5, g = this.h6,
+	      h = this.h7, blocks = this.blocks, j, s0, s1, maj, t1, t2, ch, ab, da, cd, bc;
+
+	    for (j = 16; j < 64; ++j) {
+	      // rightrotate
+	      t1 = blocks[j - 15];
+	      s0 = ((t1 >>> 7) | (t1 << 25)) ^ ((t1 >>> 18) | (t1 << 14)) ^ (t1 >>> 3);
+	      t1 = blocks[j - 2];
+	      s1 = ((t1 >>> 17) | (t1 << 15)) ^ ((t1 >>> 19) | (t1 << 13)) ^ (t1 >>> 10);
+	      blocks[j] = blocks[j - 16] + s0 + blocks[j - 7] + s1 << 0;
+	    }
+
+	    bc = b & c;
+	    for (j = 0; j < 64; j += 4) {
+	      if (this.first) {
+	        if (this.is224) {
+	          ab = 300032;
+	          t1 = blocks[0] - 1413257819;
+	          h = t1 - 150054599 << 0;
+	          d = t1 + 24177077 << 0;
+	        } else {
+	          ab = 704751109;
+	          t1 = blocks[0] - 210244248;
+	          h = t1 - 1521486534 << 0;
+	          d = t1 + 143694565 << 0;
+	        }
+	        this.first = false;
+	      } else {
+	        s0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+	        s1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+	        ab = a & b;
+	        maj = ab ^ (a & c) ^ bc;
+	        ch = (e & f) ^ (~e & g);
+	        t1 = h + s1 + ch + K[j] + blocks[j];
+	        t2 = s0 + maj;
+	        h = d + t1 << 0;
+	        d = t1 + t2 << 0;
+	      }
+	      s0 = ((d >>> 2) | (d << 30)) ^ ((d >>> 13) | (d << 19)) ^ ((d >>> 22) | (d << 10));
+	      s1 = ((h >>> 6) | (h << 26)) ^ ((h >>> 11) | (h << 21)) ^ ((h >>> 25) | (h << 7));
+	      da = d & a;
+	      maj = da ^ (d & b) ^ ab;
+	      ch = (h & e) ^ (~h & f);
+	      t1 = g + s1 + ch + K[j + 1] + blocks[j + 1];
+	      t2 = s0 + maj;
+	      g = c + t1 << 0;
+	      c = t1 + t2 << 0;
+	      s0 = ((c >>> 2) | (c << 30)) ^ ((c >>> 13) | (c << 19)) ^ ((c >>> 22) | (c << 10));
+	      s1 = ((g >>> 6) | (g << 26)) ^ ((g >>> 11) | (g << 21)) ^ ((g >>> 25) | (g << 7));
+	      cd = c & d;
+	      maj = cd ^ (c & a) ^ da;
+	      ch = (g & h) ^ (~g & e);
+	      t1 = f + s1 + ch + K[j + 2] + blocks[j + 2];
+	      t2 = s0 + maj;
+	      f = b + t1 << 0;
+	      b = t1 + t2 << 0;
+	      s0 = ((b >>> 2) | (b << 30)) ^ ((b >>> 13) | (b << 19)) ^ ((b >>> 22) | (b << 10));
+	      s1 = ((f >>> 6) | (f << 26)) ^ ((f >>> 11) | (f << 21)) ^ ((f >>> 25) | (f << 7));
+	      bc = b & c;
+	      maj = bc ^ (b & d) ^ cd;
+	      ch = (f & g) ^ (~f & h);
+	      t1 = e + s1 + ch + K[j + 3] + blocks[j + 3];
+	      t2 = s0 + maj;
+	      e = a + t1 << 0;
+	      a = t1 + t2 << 0;
+	      this.chromeBugWorkAround = true;
+	    }
+
+	    this.h0 = this.h0 + a << 0;
+	    this.h1 = this.h1 + b << 0;
+	    this.h2 = this.h2 + c << 0;
+	    this.h3 = this.h3 + d << 0;
+	    this.h4 = this.h4 + e << 0;
+	    this.h5 = this.h5 + f << 0;
+	    this.h6 = this.h6 + g << 0;
+	    this.h7 = this.h7 + h << 0;
+	  };
+
+	  Sha256.prototype.hex = function () {
+	    this.finalize();
+
+	    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,
+	      h6 = this.h6, h7 = this.h7;
+
+	    var hex = HEX_CHARS[(h0 >>> 28) & 0x0F] + HEX_CHARS[(h0 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h0 >>> 20) & 0x0F] + HEX_CHARS[(h0 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h0 >>> 12) & 0x0F] + HEX_CHARS[(h0 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h0 >>> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] +
+	      HEX_CHARS[(h1 >>> 28) & 0x0F] + HEX_CHARS[(h1 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h1 >>> 20) & 0x0F] + HEX_CHARS[(h1 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h1 >>> 12) & 0x0F] + HEX_CHARS[(h1 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h1 >>> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] +
+	      HEX_CHARS[(h2 >>> 28) & 0x0F] + HEX_CHARS[(h2 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h2 >>> 20) & 0x0F] + HEX_CHARS[(h2 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h2 >>> 12) & 0x0F] + HEX_CHARS[(h2 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h2 >>> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] +
+	      HEX_CHARS[(h3 >>> 28) & 0x0F] + HEX_CHARS[(h3 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h3 >>> 20) & 0x0F] + HEX_CHARS[(h3 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h3 >>> 12) & 0x0F] + HEX_CHARS[(h3 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h3 >>> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] +
+	      HEX_CHARS[(h4 >>> 28) & 0x0F] + HEX_CHARS[(h4 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h4 >>> 20) & 0x0F] + HEX_CHARS[(h4 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h4 >>> 12) & 0x0F] + HEX_CHARS[(h4 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h4 >>> 4) & 0x0F] + HEX_CHARS[h4 & 0x0F] +
+	      HEX_CHARS[(h5 >>> 28) & 0x0F] + HEX_CHARS[(h5 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h5 >>> 20) & 0x0F] + HEX_CHARS[(h5 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h5 >>> 12) & 0x0F] + HEX_CHARS[(h5 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h5 >>> 4) & 0x0F] + HEX_CHARS[h5 & 0x0F] +
+	      HEX_CHARS[(h6 >>> 28) & 0x0F] + HEX_CHARS[(h6 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h6 >>> 20) & 0x0F] + HEX_CHARS[(h6 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h6 >>> 12) & 0x0F] + HEX_CHARS[(h6 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h6 >>> 4) & 0x0F] + HEX_CHARS[h6 & 0x0F];
+	    if (!this.is224) {
+	      hex += HEX_CHARS[(h7 >>> 28) & 0x0F] + HEX_CHARS[(h7 >>> 24) & 0x0F] +
+	        HEX_CHARS[(h7 >>> 20) & 0x0F] + HEX_CHARS[(h7 >>> 16) & 0x0F] +
+	        HEX_CHARS[(h7 >>> 12) & 0x0F] + HEX_CHARS[(h7 >>> 8) & 0x0F] +
+	        HEX_CHARS[(h7 >>> 4) & 0x0F] + HEX_CHARS[h7 & 0x0F];
+	    }
+	    return hex;
+	  };
+
+	  Sha256.prototype.toString = Sha256.prototype.hex;
+
+	  Sha256.prototype.digest = function () {
+	    this.finalize();
+
+	    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,
+	      h6 = this.h6, h7 = this.h7;
+
+	    var arr = [
+	      (h0 >>> 24) & 0xFF, (h0 >>> 16) & 0xFF, (h0 >>> 8) & 0xFF, h0 & 0xFF,
+	      (h1 >>> 24) & 0xFF, (h1 >>> 16) & 0xFF, (h1 >>> 8) & 0xFF, h1 & 0xFF,
+	      (h2 >>> 24) & 0xFF, (h2 >>> 16) & 0xFF, (h2 >>> 8) & 0xFF, h2 & 0xFF,
+	      (h3 >>> 24) & 0xFF, (h3 >>> 16) & 0xFF, (h3 >>> 8) & 0xFF, h3 & 0xFF,
+	      (h4 >>> 24) & 0xFF, (h4 >>> 16) & 0xFF, (h4 >>> 8) & 0xFF, h4 & 0xFF,
+	      (h5 >>> 24) & 0xFF, (h5 >>> 16) & 0xFF, (h5 >>> 8) & 0xFF, h5 & 0xFF,
+	      (h6 >>> 24) & 0xFF, (h6 >>> 16) & 0xFF, (h6 >>> 8) & 0xFF, h6 & 0xFF
+	    ];
+	    if (!this.is224) {
+	      arr.push((h7 >>> 24) & 0xFF, (h7 >>> 16) & 0xFF, (h7 >>> 8) & 0xFF, h7 & 0xFF);
+	    }
+	    return arr;
+	  };
+
+	  Sha256.prototype.array = Sha256.prototype.digest;
+
+	  Sha256.prototype.arrayBuffer = function () {
+	    this.finalize();
+
+	    var buffer = new ArrayBuffer(this.is224 ? 28 : 32);
+	    var dataView = new DataView(buffer);
+	    dataView.setUint32(0, this.h0);
+	    dataView.setUint32(4, this.h1);
+	    dataView.setUint32(8, this.h2);
+	    dataView.setUint32(12, this.h3);
+	    dataView.setUint32(16, this.h4);
+	    dataView.setUint32(20, this.h5);
+	    dataView.setUint32(24, this.h6);
+	    if (!this.is224) {
+	      dataView.setUint32(28, this.h7);
+	    }
+	    return buffer;
+	  };
+
+	  function HmacSha256(key, is224, sharedMemory) {
+	    var i, type = typeof key;
+	    if (type === 'string') {
+	      var bytes = [], length = key.length, index = 0, code;
+	      for (i = 0; i < length; ++i) {
+	        code = key.charCodeAt(i);
+	        if (code < 0x80) {
+	          bytes[index++] = code;
+	        } else if (code < 0x800) {
+	          bytes[index++] = (0xc0 | (code >>> 6));
+	          bytes[index++] = (0x80 | (code & 0x3f));
+	        } else if (code < 0xd800 || code >= 0xe000) {
+	          bytes[index++] = (0xe0 | (code >>> 12));
+	          bytes[index++] = (0x80 | ((code >>> 6) & 0x3f));
+	          bytes[index++] = (0x80 | (code & 0x3f));
+	        } else {
+	          code = 0x10000 + (((code & 0x3ff) << 10) | (key.charCodeAt(++i) & 0x3ff));
+	          bytes[index++] = (0xf0 | (code >>> 18));
+	          bytes[index++] = (0x80 | ((code >>> 12) & 0x3f));
+	          bytes[index++] = (0x80 | ((code >>> 6) & 0x3f));
+	          bytes[index++] = (0x80 | (code & 0x3f));
+	        }
+	      }
+	      key = bytes;
+	    } else {
+	      if (type === 'object') {
+	        if (key === null) {
+	          throw new Error(ERROR);
+	        } else if (ARRAY_BUFFER && key.constructor === ArrayBuffer) {
+	          key = new Uint8Array(key);
+	        } else if (!Array.isArray(key)) {
+	          if (!ARRAY_BUFFER || !ArrayBuffer.isView(key)) {
+	            throw new Error(ERROR);
+	          }
+	        }
+	      } else {
+	        throw new Error(ERROR);
+	      }
+	    }
+
+	    if (key.length > 64) {
+	      key = (new Sha256(is224, true)).update(key).array();
+	    }
+
+	    var oKeyPad = [], iKeyPad = [];
+	    for (i = 0; i < 64; ++i) {
+	      var b = key[i] || 0;
+	      oKeyPad[i] = 0x5c ^ b;
+	      iKeyPad[i] = 0x36 ^ b;
+	    }
+
+	    Sha256.call(this, is224, sharedMemory);
+
+	    this.update(iKeyPad);
+	    this.oKeyPad = oKeyPad;
+	    this.inner = true;
+	    this.sharedMemory = sharedMemory;
+	  }
+	  HmacSha256.prototype = new Sha256();
+
+	  HmacSha256.prototype.finalize = function () {
+	    Sha256.prototype.finalize.call(this);
+	    if (this.inner) {
+	      this.inner = false;
+	      var innerHash = this.array();
+	      Sha256.call(this, this.is224, this.sharedMemory);
+	      this.update(this.oKeyPad);
+	      this.update(innerHash);
+	      Sha256.prototype.finalize.call(this);
+	    }
+	  };
+
+	  var exports = createMethod();
+	  exports.sha256 = exports;
+	  exports.sha224 = createMethod(true);
+	  exports.sha256.hmac = createHmacMethod();
+	  exports.sha224.hmac = createHmacMethod(true);
+
+	  if (COMMON_JS) {
+	    module.exports = exports;
+	  } else {
+	    root.sha256 = exports.sha256;
+	    root.sha224 = exports.sha224;
+	  }
+	})(); 
+} (sha256$1));
+
+var sha256Exports = sha256$1.exports;
+var sha256 = /*@__PURE__*/getDefaultExportFromCjs(sha256Exports);
+
+const { sha224 } = sha256;
+
+export { sha256 as default, sha224, sha256 };

build/sha256.node.mjs

@@ -0,0 +1,540 @@
+import require$$0 from 'crypto';
+import require$$1 from 'buffer';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var sha256$1 = {exports: {}};
+
+/**
+ * [js-sha256]{@link https://github.com/emn178/js-sha256}
+ *
+ * @version 0.12.0
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
+ * @copyright Chen, Yi-Cyuan 2014-2026
+ * @license MIT
+ */
+
+(function (module) {
+	/*jslint bitwise: true */
+	(function () {
+
+	  var ERROR = 'input is invalid type';
+	  var WINDOW = typeof window === 'object';
+	  var root = WINDOW ? window : {};
+	  if (root.JS_SHA256_NO_WINDOW) {
+	    WINDOW = false;
+	  }
+	  var WEB_WORKER = !WINDOW && typeof self === 'object';
+	  var NODE_JS = !root.JS_SHA256_NO_NODE_JS && !WINDOW && typeof process === 'object' && process.versions && process.versions.node && process.type != 'renderer';
+	  if (NODE_JS) {
+	    root = commonjsGlobal;
+	  } else if (WEB_WORKER) {
+	    root = self;
+	  }
+	  var COMMON_JS = !root.JS_SHA256_NO_COMMON_JS && 'object' === 'object' && module.exports;
+	  var ARRAY_BUFFER = !root.JS_SHA256_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined';
+	  var HEX_CHARS = '0123456789abcdef'.split('');
+	  var EXTRA = [-2147483648, 8388608, 32768, 128];
+	  var SHIFT = [24, 16, 8, 0];
+	  var K = [
+	    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+	    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+	    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+	    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+	    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+	    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+	    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+	    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+	  ];
+	  var OUTPUT_TYPES = ['hex', 'array', 'digest', 'arrayBuffer'];
+
+	  var blocks = [];
+
+	  if (root.JS_SHA256_NO_NODE_JS || !Array.isArray) {
+	    Array.isArray = function (obj) {
+	      return Object.prototype.toString.call(obj) === '[object Array]';
+	    };
+	  }
+
+	  if (ARRAY_BUFFER && (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {
+	    ArrayBuffer.isView = function (obj) {
+	      return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer;
+	    };
+	  }
+
+	  var createOutputMethod = function (outputType, is224) {
+	    return function (message) {
+	      return new Sha256(is224, true).update(message)[outputType]();
+	    };
+	  };
+
+	  var createMethod = function (is224) {
+	    var method = createOutputMethod('hex', is224);
+	    if (NODE_JS) {
+	      method = nodeWrap(method, is224);
+	    }
+	    method.create = function () {
+	      return new Sha256(is224);
+	    };
+	    method.update = function (message) {
+	      return method.create().update(message);
+	    };
+	    for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
+	      var type = OUTPUT_TYPES[i];
+	      method[type] = createOutputMethod(type, is224);
+	    }
+	    return method;
+	  };
+
+	  var nodeWrap = function (method, is224) {
+	    var crypto = require$$0;
+	    var Buffer = require$$1.Buffer;
+	    var algorithm = is224 ? 'sha224' : 'sha256';
+	    var bufferFrom;
+	    if (Buffer.from && !root.JS_SHA256_NO_BUFFER_FROM) {
+	      bufferFrom = Buffer.from;
+	    } else {
+	      bufferFrom = function (message) {
+	        return new Buffer(message);
+	      };
+	    }
+	    var nodeMethod = function (message) {
+	      if (typeof message === 'string') {
+	        return crypto.createHash(algorithm).update(message, 'utf8').digest('hex');
+	      } else {
+	        if (message === null || message === undefined) {
+	          throw new Error(ERROR);
+	        } else if (message.constructor === ArrayBuffer) {
+	          message = new Uint8Array(message);
+	        }
+	      }
+	      if (Array.isArray(message) || ArrayBuffer.isView(message) ||
+	        message.constructor === Buffer) {
+	        return crypto.createHash(algorithm).update(bufferFrom(message)).digest('hex');
+	      } else {
+	        return method(message);
+	      }
+	    };
+	    return nodeMethod;
+	  };
+
+	  var createHmacOutputMethod = function (outputType, is224) {
+	    return function (key, message) {
+	      return new HmacSha256(key, is224, true).update(message)[outputType]();
+	    };
+	  };
+
+	  var createHmacMethod = function (is224) {
+	    var method = createHmacOutputMethod('hex', is224);
+	    method.create = function (key) {
+	      return new HmacSha256(key, is224);
+	    };
+	    method.update = function (key, message) {
+	      return method.create(key).update(message);
+	    };
+	    for (var i = 0; i < OUTPUT_TYPES.length; ++i) {
+	      var type = OUTPUT_TYPES[i];
+	      method[type] = createHmacOutputMethod(type, is224);
+	    }
+	    return method;
+	  };
+
+	  function Sha256(is224, sharedMemory) {
+	    if (sharedMemory) {
+	      blocks[0] = blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+	        blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+	        blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+	        blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+	      this.blocks = blocks;
+	    } else {
+	      this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+	    }
+
+	    if (is224) {
+	      this.h0 = 0xc1059ed8;
+	      this.h1 = 0x367cd507;
+	      this.h2 = 0x3070dd17;
+	      this.h3 = 0xf70e5939;
+	      this.h4 = 0xffc00b31;
+	      this.h5 = 0x68581511;
+	      this.h6 = 0x64f98fa7;
+	      this.h7 = 0xbefa4fa4;
+	    } else { // 256
+	      this.h0 = 0x6a09e667;
+	      this.h1 = 0xbb67ae85;
+	      this.h2 = 0x3c6ef372;
+	      this.h3 = 0xa54ff53a;
+	      this.h4 = 0x510e527f;
+	      this.h5 = 0x9b05688c;
+	      this.h6 = 0x1f83d9ab;
+	      this.h7 = 0x5be0cd19;
+	    }
+
+	    this.block = this.start = this.bytes = this.hBytes = 0;
+	    this.finalized = this.hashed = false;
+	    this.first = true;
+	    this.is224 = is224;
+	  }
+
+	  Sha256.prototype.update = function (message) {
+	    if (this.finalized) {
+	      return;
+	    }
+	    var notString, type = typeof message;
+	    if (type !== 'string') {
+	      if (type === 'object') {
+	        if (message === null) {
+	          throw new Error(ERROR);
+	        } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
+	          message = new Uint8Array(message);
+	        } else if (!Array.isArray(message)) {
+	          if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {
+	            throw new Error(ERROR);
+	          }
+	        }
+	      } else {
+	        throw new Error(ERROR);
+	      }
+	      notString = true;
+	    }
+	    var code, index = 0, i, length = message.length, blocks = this.blocks;
+	    while (index < length) {
+	      if (this.hashed) {
+	        this.hashed = false;
+	        blocks[0] = this.block;
+	        this.block = blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+	          blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+	          blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+	          blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+	      }
+
+	      if (notString) {
+	        for (i = this.start; index < length && i < 64; ++index) {
+	          blocks[i >>> 2] |= message[index] << SHIFT[i++ & 3];
+	        }
+	      } else {
+	        for (i = this.start; index < length && i < 64; ++index) {
+	          code = message.charCodeAt(index);
+	          if (code < 0x80) {
+	            blocks[i >>> 2] |= code << SHIFT[i++ & 3];
+	          } else if (code < 0x800) {
+	            blocks[i >>> 2] |= (0xc0 | (code >>> 6)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+	          } else if (code < 0xd800 || code >= 0xe000) {
+	            blocks[i >>> 2] |= (0xe0 | (code >>> 12)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | ((code >>> 6) & 0x3f)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+	          } else {
+	            code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
+	            blocks[i >>> 2] |= (0xf0 | (code >>> 18)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | ((code >>> 12) & 0x3f)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | ((code >>> 6) & 0x3f)) << SHIFT[i++ & 3];
+	            blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+	          }
+	        }
+	      }
+
+	      this.lastByteIndex = i;
+	      this.bytes += i - this.start;
+	      if (i >= 64) {
+	        this.block = blocks[16];
+	        this.start = i - 64;
+	        this.hash();
+	        this.hashed = true;
+	      } else {
+	        this.start = i;
+	      }
+	    }
+	    if (this.bytes > 4294967295) {
+	      this.hBytes += this.bytes / 4294967296 << 0;
+	      this.bytes = this.bytes % 4294967296;
+	    }
+	    return this;
+	  };
+
+	  Sha256.prototype.finalize = function () {
+	    if (this.finalized) {
+	      return;
+	    }
+	    this.finalized = true;
+	    var blocks = this.blocks, i = this.lastByteIndex;
+	    blocks[16] = this.block;
+	    blocks[i >>> 2] |= EXTRA[i & 3];
+	    this.block = blocks[16];
+	    if (i >= 56) {
+	      if (!this.hashed) {
+	        this.hash();
+	      }
+	      blocks[0] = this.block;
+	      blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+	        blocks[4] = blocks[5] = blocks[6] = blocks[7] =
+	        blocks[8] = blocks[9] = blocks[10] = blocks[11] =
+	        blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
+	    }
+	    blocks[14] = this.hBytes << 3 | this.bytes >>> 29;
+	    blocks[15] = this.bytes << 3;
+	    this.hash();
+	  };
+
+	  Sha256.prototype.hash = function () {
+	    var a = this.h0, b = this.h1, c = this.h2, d = this.h3, e = this.h4, f = this.h5, g = this.h6,
+	      h = this.h7, blocks = this.blocks, j, s0, s1, maj, t1, t2, ch, ab, da, cd, bc;
+
+	    for (j = 16; j < 64; ++j) {
+	      // rightrotate
+	      t1 = blocks[j - 15];
+	      s0 = ((t1 >>> 7) | (t1 << 25)) ^ ((t1 >>> 18) | (t1 << 14)) ^ (t1 >>> 3);
+	      t1 = blocks[j - 2];
+	      s1 = ((t1 >>> 17) | (t1 << 15)) ^ ((t1 >>> 19) | (t1 << 13)) ^ (t1 >>> 10);
+	      blocks[j] = blocks[j - 16] + s0 + blocks[j - 7] + s1 << 0;
+	    }
+
+	    bc = b & c;
+	    for (j = 0; j < 64; j += 4) {
+	      if (this.first) {
+	        if (this.is224) {
+	          ab = 300032;
+	          t1 = blocks[0] - 1413257819;
+	          h = t1 - 150054599 << 0;
+	          d = t1 + 24177077 << 0;
+	        } else {
+	          ab = 704751109;
+	          t1 = blocks[0] - 210244248;
+	          h = t1 - 1521486534 << 0;
+	          d = t1 + 143694565 << 0;
+	        }
+	        this.first = false;
+	      } else {
+	        s0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+	        s1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+	        ab = a & b;
+	        maj = ab ^ (a & c) ^ bc;
+	        ch = (e & f) ^ (~e & g);
+	        t1 = h + s1 + ch + K[j] + blocks[j];
+	        t2 = s0 + maj;
+	        h = d + t1 << 0;
+	        d = t1 + t2 << 0;
+	      }
+	      s0 = ((d >>> 2) | (d << 30)) ^ ((d >>> 13) | (d << 19)) ^ ((d >>> 22) | (d << 10));
+	      s1 = ((h >>> 6) | (h << 26)) ^ ((h >>> 11) | (h << 21)) ^ ((h >>> 25) | (h << 7));
+	      da = d & a;
+	      maj = da ^ (d & b) ^ ab;
+	      ch = (h & e) ^ (~h & f);
+	      t1 = g + s1 + ch + K[j + 1] + blocks[j + 1];
+	      t2 = s0 + maj;
+	      g = c + t1 << 0;
+	      c = t1 + t2 << 0;
+	      s0 = ((c >>> 2) | (c << 30)) ^ ((c >>> 13) | (c << 19)) ^ ((c >>> 22) | (c << 10));
+	      s1 = ((g >>> 6) | (g << 26)) ^ ((g >>> 11) | (g << 21)) ^ ((g >>> 25) | (g << 7));
+	      cd = c & d;
+	      maj = cd ^ (c & a) ^ da;
+	      ch = (g & h) ^ (~g & e);
+	      t1 = f + s1 + ch + K[j + 2] + blocks[j + 2];
+	      t2 = s0 + maj;
+	      f = b + t1 << 0;
+	      b = t1 + t2 << 0;
+	      s0 = ((b >>> 2) | (b << 30)) ^ ((b >>> 13) | (b << 19)) ^ ((b >>> 22) | (b << 10));
+	      s1 = ((f >>> 6) | (f << 26)) ^ ((f >>> 11) | (f << 21)) ^ ((f >>> 25) | (f << 7));
+	      bc = b & c;
+	      maj = bc ^ (b & d) ^ cd;
+	      ch = (f & g) ^ (~f & h);
+	      t1 = e + s1 + ch + K[j + 3] + blocks[j + 3];
+	      t2 = s0 + maj;
+	      e = a + t1 << 0;
+	      a = t1 + t2 << 0;
+	      this.chromeBugWorkAround = true;
+	    }
+
+	    this.h0 = this.h0 + a << 0;
+	    this.h1 = this.h1 + b << 0;
+	    this.h2 = this.h2 + c << 0;
+	    this.h3 = this.h3 + d << 0;
+	    this.h4 = this.h4 + e << 0;
+	    this.h5 = this.h5 + f << 0;
+	    this.h6 = this.h6 + g << 0;
+	    this.h7 = this.h7 + h << 0;
+	  };
+
+	  Sha256.prototype.hex = function () {
+	    this.finalize();
+
+	    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,
+	      h6 = this.h6, h7 = this.h7;
+
+	    var hex = HEX_CHARS[(h0 >>> 28) & 0x0F] + HEX_CHARS[(h0 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h0 >>> 20) & 0x0F] + HEX_CHARS[(h0 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h0 >>> 12) & 0x0F] + HEX_CHARS[(h0 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h0 >>> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] +
+	      HEX_CHARS[(h1 >>> 28) & 0x0F] + HEX_CHARS[(h1 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h1 >>> 20) & 0x0F] + HEX_CHARS[(h1 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h1 >>> 12) & 0x0F] + HEX_CHARS[(h1 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h1 >>> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] +
+	      HEX_CHARS[(h2 >>> 28) & 0x0F] + HEX_CHARS[(h2 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h2 >>> 20) & 0x0F] + HEX_CHARS[(h2 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h2 >>> 12) & 0x0F] + HEX_CHARS[(h2 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h2 >>> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] +
+	      HEX_CHARS[(h3 >>> 28) & 0x0F] + HEX_CHARS[(h3 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h3 >>> 20) & 0x0F] + HEX_CHARS[(h3 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h3 >>> 12) & 0x0F] + HEX_CHARS[(h3 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h3 >>> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] +
+	      HEX_CHARS[(h4 >>> 28) & 0x0F] + HEX_CHARS[(h4 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h4 >>> 20) & 0x0F] + HEX_CHARS[(h4 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h4 >>> 12) & 0x0F] + HEX_CHARS[(h4 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h4 >>> 4) & 0x0F] + HEX_CHARS[h4 & 0x0F] +
+	      HEX_CHARS[(h5 >>> 28) & 0x0F] + HEX_CHARS[(h5 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h5 >>> 20) & 0x0F] + HEX_CHARS[(h5 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h5 >>> 12) & 0x0F] + HEX_CHARS[(h5 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h5 >>> 4) & 0x0F] + HEX_CHARS[h5 & 0x0F] +
+	      HEX_CHARS[(h6 >>> 28) & 0x0F] + HEX_CHARS[(h6 >>> 24) & 0x0F] +
+	      HEX_CHARS[(h6 >>> 20) & 0x0F] + HEX_CHARS[(h6 >>> 16) & 0x0F] +
+	      HEX_CHARS[(h6 >>> 12) & 0x0F] + HEX_CHARS[(h6 >>> 8) & 0x0F] +
+	      HEX_CHARS[(h6 >>> 4) & 0x0F] + HEX_CHARS[h6 & 0x0F];
+	    if (!this.is224) {
+	      hex += HEX_CHARS[(h7 >>> 28) & 0x0F] + HEX_CHARS[(h7 >>> 24) & 0x0F] +
+	        HEX_CHARS[(h7 >>> 20) & 0x0F] + HEX_CHARS[(h7 >>> 16) & 0x0F] +
+	        HEX_CHARS[(h7 >>> 12) & 0x0F] + HEX_CHARS[(h7 >>> 8) & 0x0F] +
+	        HEX_CHARS[(h7 >>> 4) & 0x0F] + HEX_CHARS[h7 & 0x0F];
+	    }
+	    return hex;
+	  };
+
+	  Sha256.prototype.toString = Sha256.prototype.hex;
+
+	  Sha256.prototype.digest = function () {
+	    this.finalize();
+
+	    var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,
+	      h6 = this.h6, h7 = this.h7;
+
+	    var arr = [
+	      (h0 >>> 24) & 0xFF, (h0 >>> 16) & 0xFF, (h0 >>> 8) & 0xFF, h0 & 0xFF,
+	      (h1 >>> 24) & 0xFF, (h1 >>> 16) & 0xFF, (h1 >>> 8) & 0xFF, h1 & 0xFF,
+	      (h2 >>> 24) & 0xFF, (h2 >>> 16) & 0xFF, (h2 >>> 8) & 0xFF, h2 & 0xFF,
+	      (h3 >>> 24) & 0xFF, (h3 >>> 16) & 0xFF, (h3 >>> 8) & 0xFF, h3 & 0xFF,
+	      (h4 >>> 24) & 0xFF, (h4 >>> 16) & 0xFF, (h4 >>> 8) & 0xFF, h4 & 0xFF,
+	      (h5 >>> 24) & 0xFF, (h5 >>> 16) & 0xFF, (h5 >>> 8) & 0xFF, h5 & 0xFF,
+	      (h6 >>> 24) & 0xFF, (h6 >>> 16) & 0xFF, (h6 >>> 8) & 0xFF, h6 & 0xFF
+	    ];
+	    if (!this.is224) {
+	      arr.push((h7 >>> 24) & 0xFF, (h7 >>> 16) & 0xFF, (h7 >>> 8) & 0xFF, h7 & 0xFF);
+	    }
+	    return arr;
+	  };
+
+	  Sha256.prototype.array = Sha256.prototype.digest;
+
+	  Sha256.prototype.arrayBuffer = function () {
+	    this.finalize();
+
+	    var buffer = new ArrayBuffer(this.is224 ? 28 : 32);
+	    var dataView = new DataView(buffer);
+	    dataView.setUint32(0, this.h0);
+	    dataView.setUint32(4, this.h1);
+	    dataView.setUint32(8, this.h2);
+	    dataView.setUint32(12, this.h3);
+	    dataView.setUint32(16, this.h4);
+	    dataView.setUint32(20, this.h5);
+	    dataView.setUint32(24, this.h6);
+	    if (!this.is224) {
+	      dataView.setUint32(28, this.h7);
+	    }
+	    return buffer;
+	  };
+
+	  function HmacSha256(key, is224, sharedMemory) {
+	    var i, type = typeof key;
+	    if (type === 'string') {
+	      var bytes = [], length = key.length, index = 0, code;
+	      for (i = 0; i < length; ++i) {
+	        code = key.charCodeAt(i);
+	        if (code < 0x80) {
+	          bytes[index++] = code;
+	        } else if (code < 0x800) {
+	          bytes[index++] = (0xc0 | (code >>> 6));
+	          bytes[index++] = (0x80 | (code & 0x3f));
+	        } else if (code < 0xd800 || code >= 0xe000) {
+	          bytes[index++] = (0xe0 | (code >>> 12));
+	          bytes[index++] = (0x80 | ((code >>> 6) & 0x3f));
+	          bytes[index++] = (0x80 | (code & 0x3f));
+	        } else {
+	          code = 0x10000 + (((code & 0x3ff) << 10) | (key.charCodeAt(++i) & 0x3ff));
+	          bytes[index++] = (0xf0 | (code >>> 18));
+	          bytes[index++] = (0x80 | ((code >>> 12) & 0x3f));
+	          bytes[index++] = (0x80 | ((code >>> 6) & 0x3f));
+	          bytes[index++] = (0x80 | (code & 0x3f));
+	        }
+	      }
+	      key = bytes;
+	    } else {
+	      if (type === 'object') {
+	        if (key === null) {
+	          throw new Error(ERROR);
+	        } else if (ARRAY_BUFFER && key.constructor === ArrayBuffer) {
+	          key = new Uint8Array(key);
+	        } else if (!Array.isArray(key)) {
+	          if (!ARRAY_BUFFER || !ArrayBuffer.isView(key)) {
+	            throw new Error(ERROR);
+	          }
+	        }
+	      } else {
+	        throw new Error(ERROR);
+	      }
+	    }
+
+	    if (key.length > 64) {
+	      key = (new Sha256(is224, true)).update(key).array();
+	    }
+
+	    var oKeyPad = [], iKeyPad = [];
+	    for (i = 0; i < 64; ++i) {
+	      var b = key[i] || 0;
+	      oKeyPad[i] = 0x5c ^ b;
+	      iKeyPad[i] = 0x36 ^ b;
+	    }
+
+	    Sha256.call(this, is224, sharedMemory);
+
+	    this.update(iKeyPad);
+	    this.oKeyPad = oKeyPad;
+	    this.inner = true;
+	    this.sharedMemory = sharedMemory;
+	  }
+	  HmacSha256.prototype = new Sha256();
+
+	  HmacSha256.prototype.finalize = function () {
+	    Sha256.prototype.finalize.call(this);
+	    if (this.inner) {
+	      this.inner = false;
+	      var innerHash = this.array();
+	      Sha256.call(this, this.is224, this.sharedMemory);
+	      this.update(this.oKeyPad);
+	      this.update(innerHash);
+	      Sha256.prototype.finalize.call(this);
+	    }
+	  };
+
+	  var exports = createMethod();
+	  exports.sha256 = exports;
+	  exports.sha224 = createMethod(true);
+	  exports.sha256.hmac = createHmacMethod();
+	  exports.sha224.hmac = createHmacMethod(true);
+
+	  if (COMMON_JS) {
+	    module.exports = exports;
+	  } else {
+	    root.sha256 = exports.sha256;
+	    root.sha224 = exports.sha224;
+	  }
+	})(); 
+} (sha256$1));
+
+var sha256Exports = sha256$1.exports;
+var sha256 = /*@__PURE__*/getDefaultExportFromCjs(sha256Exports);
+
+const { sha224 } = sha256;
+
+export { sha256 as default, sha224, sha256 };

index.d.ts

@@ -0,0 +1,149 @@
+type Message = string | number[] | ArrayBuffer | Uint8Array;
+
+interface Hasher {
+  /**
+   * Update hash
+   *
+   * @param message The message you want to hash.
+   */
+  update(message: Message): Hasher;
+
+  /**
+   * Return hash in hex string.
+   */
+  hex(): string;
+
+  /**
+   * Return hash in hex string.
+   */
+  toString(): string;
+
+  /**
+   * Return hash in ArrayBuffer.
+   */
+  arrayBuffer(): ArrayBuffer;
+
+  /**
+   * Return hash in integer array.
+   */
+  digest(): number[];
+
+  /**
+   * Return hash in integer array.
+   */
+  array(): number[];
+}
+
+interface Hmac {
+  /**
+   * Computes a Hash-based message authentication code (HMAC) using a secret key
+   *
+   * @param secretKey The Secret Key
+   * @param message The message you want to hash.
+   */
+  (secretKey: Message, message: Message): string;
+
+  /**
+   * Create a hash object using a secret key.
+   *
+   * @param secretKey The Secret Key
+   */
+  create(secretKey: Message): Hasher;
+
+  /**
+   * Create a hash object and hash message using a secret key
+   *
+   * @param secretKey The Secret Key
+   * @param message The message you want to hash.
+   */
+  update(secretKey: Message, message: Message): Hasher;
+
+  /**
+   * Return hash in hex string.
+   *
+   * @param secretKey The Secret Key
+   * @param message The message you want to hash.
+   */
+  hex(secretKey: Message, message: Message): string;
+
+  /**
+   * Return hash in ArrayBuffer.
+   *
+   * @param secretKey The Secret Key
+   * @param message The message you want to hash.
+   */
+  arrayBuffer(secretKey: Message, message: Message): ArrayBuffer;
+
+  /**
+   * Return hash in integer array.
+   *
+   * @param secretKey The Secret Key
+   * @param message The message you want to hash.
+   */
+  digest(secretKey: Message, message: Message): number[];
+
+  /**
+   * Return hash in integer array.
+   *
+   * @param secretKey The Secret Key
+   * @param message The message you want to hash.
+   */
+  array(secretKey: Message, message: Message): number[];
+}
+
+interface Hash {
+  /**
+   * Hash and return hex string.
+   *
+   * @param message The message you want to hash.
+   */
+  (message: Message): string;
+
+  /**
+   * Create a hash object.
+   */
+  create(): Hasher;
+
+  /**
+   * Create a hash object and hash message.
+   *
+   * @param message The message you want to hash.
+   */
+  update(message: Message): Hasher;
+
+  /**
+   * Return hash in hex string.
+   *
+   * @param message The message you want to hash.
+   */
+  hex(message: Message): string;
+
+  /**
+   * Return hash in ArrayBuffer.
+   *
+   * @param message The message you want to hash.
+   */
+  arrayBuffer(message: Message): ArrayBuffer;
+
+  /**
+   * Return hash in integer array.
+   *
+   * @param message The message you want to hash.
+   */
+  digest(message: Message): number[];
+
+  /**
+   * Return hash in integer array.
+   *
+   * @param message The message you want to hash.
+   */
+  array(message: Message): number[];
+
+  /**
+   * HMAC interface
+   */
+  hmac: Hmac;
+}
+
+export var sha256: Hash;
+export var sha224: Hash;

package.json

@@ -1,19 +1,43 @@
 {
   "name": "js-sha256",
-  "version": "0.7.1",
+  "version": "0.12.0",
   "description": "A simple SHA-256 / SHA-224 hash function for JavaScript supports UTF-8 encoding.",
   "main": "src/sha256.js",
+  "module": "build/sha256.mjs",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "node": {
+        "import": "./build/sha256.node.mjs",
+        "require": "./src/sha256.js"
+      },
+      "import": "./build/sha256.mjs",
+      "require": "./src/sha256.js",
+      "default": "./src/sha256.js"
+    },
+    "./src/sha256.js": "./src/sha256.js",
+    "./build/sha256.min.js": "./build/sha256.min.js",
+    "./build/sha256.mjs": "./build/sha256.mjs",
+    "./build/sha256.min.mjs": "./build/sha256.min.mjs",
+    "./build/sha256.node.mjs": "./build/sha256.node.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./index.d.ts",
   "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.5",
+    "@rollup/plugin-terser": "^1.0.0",
     "expect.js": "~0.3.1",
-    "jscoverage": "~0.5.9",
-    "mocha": "~2.3.4",
-    "uglifyjs": "~2.4.10"
+    "mocha": "~10.8.2",
+    "nyc": "^15.1.0",
+    "rollup": "^4.43.0",
+    "tiny-worker": "^2.3.0",
+    "uglify-js": "^3.1.9"
   },
   "scripts": {
-    "test": "mocha tests/node-test.js -r jscoverage",
-    "report": "mocha tests/node-test.js -r jscoverage --covout=html",
-    "coveralls": "mocha tests/node-test.js -R mocha-lcov-reporter -r jscoverage | coveralls",
-    "build": "uglifyjs src/sha256.js --compress --mangle --comments --output build/sha256.min.js"
+    "test": "nyc mocha tests/node-test.js && node tests/esm-test.mjs",
+    "report": "nyc --reporter=html --reporter=text mocha tests/node-test.js",
+    "coverage": "nyc report --reporter=text-lcov > coverage.lcov",
+    "build": "rollup -c && uglifyjs src/sha256.js -c -m eval --comments -o build/sha256.min.js"
   },
   "repository": {
     "type": "git",
@@ -34,5 +58,14 @@
   "homepage": "https://github.com/emn178/js-sha256",
   "bugs": {
     "url": "https://github.com/emn178/js-sha256/issues"
+  },
+  "nyc": {
+    "exclude": [
+      "tests"
+    ]
+  },
+  "browser": {
+    "crypto": false,
+    "buffer": false
   }
 }

rollup.config.mjs

@@ -0,0 +1,48 @@
+import commonjs from '@rollup/plugin-commonjs';
+import terser from '@rollup/plugin-terser';
+
+const disableNodeJs = {
+  name: 'disable-node-js',
+  transform(code, id) {
+    if (id.endsWith('/src/sha256.js')) {
+      const nodeJsDeclaration = /^\s*var NODE_JS = .*;$/m;
+      if (!nodeJsDeclaration.test(code)) {
+        this.error('Could not find the NODE_JS declaration');
+      }
+      return code.replace(nodeJsDeclaration, '  var NODE_JS = false;');
+    }
+  }
+};
+
+export default [
+  {
+    input: 'src/sha256.mjs',
+    external: ['crypto', 'buffer'],
+    output: {
+      file: 'build/sha256.node.mjs',
+      format: 'es'
+    },
+    plugins: [commonjs({
+      strictRequires: false
+    })]
+  },
+  {
+    input: 'src/sha256.mjs',
+    output: {
+      file: 'build/sha256.mjs',
+      format: 'es'
+    },
+    plugins: [disableNodeJs, commonjs({
+      strictRequires: false,
+      ignore: ['crypto', 'buffer']
+    })]
+  },
+  {
+    input: 'build/sha256.mjs',
+    output: {
+      file: 'build/sha256.min.mjs',
+      format: 'es'
+    },
+    plugins: [terser()]
+  }
+];

src/sha256.js

@@ -1,9 +1,9 @@
 /**
  * [js-sha256]{@link https://github.com/emn178/js-sha256}
  *
- * @version 0.7.1
+ * @version 0.12.0
  * @author Chen, Yi-Cyuan [emn178@gmail.com]
- * @copyright Chen, Yi-Cyuan 2014-2017
+ * @copyright Chen, Yi-Cyuan 2014-2026
  * @license MIT
  */
 /*jslint bitwise: true */
@@ -11,14 +11,21 @@
   'use strict';
 
   var ERROR = 'input is invalid type';
-  var root = typeof window === 'object' ? window : {};
-  var NODE_JS = !root.JS_SHA256_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;
+  var WINDOW = typeof window === 'object';
+  var root = WINDOW ? window : {};
+  if (root.JS_SHA256_NO_WINDOW) {
+    WINDOW = false;
+  }
+  var WEB_WORKER = !WINDOW && typeof self === 'object';
+  var NODE_JS = !root.JS_SHA256_NO_NODE_JS && !WINDOW && typeof process === 'object' && process.versions && process.versions.node && process.type != 'renderer';
   if (NODE_JS) {
     root = global;
+  } else if (WEB_WORKER) {
+    root = self;
   }
   var COMMON_JS = !root.JS_SHA256_NO_COMMON_JS && typeof module === 'object' && module.exports;
   var AMD = typeof define === 'function' && define.amd;
-  var ARRAY_BUFFER = typeof ArrayBuffer !== 'undefined';
+  var ARRAY_BUFFER = !root.JS_SHA256_NO_ARRAY_BUFFER && typeof ArrayBuffer !== 'undefined';
   var HEX_CHARS = '0123456789abcdef'.split('');
   var EXTRA = [-2147483648, 8388608, 32768, 128];
   var SHIFT = [24, 16, 8, 0];
@@ -42,6 +49,12 @@
     };
   }
 
+  if (ARRAY_BUFFER && (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView)) {
+    ArrayBuffer.isView = function (obj) {
+      return typeof obj === 'object' && obj.buffer && obj.buffer.constructor === ArrayBuffer;
+    };
+  }
+
   var createOutputMethod = function (outputType, is224) {
     return function (message) {
       return new Sha256(is224, true).update(message)[outputType]();
@@ -67,22 +80,30 @@
   };
 
   var nodeWrap = function (method, is224) {
-    var crypto = require('crypto');
+    var crypto = require('crypto')
     var Buffer = require('buffer').Buffer;
     var algorithm = is224 ? 'sha224' : 'sha256';
+    var bufferFrom;
+    if (Buffer.from && !root.JS_SHA256_NO_BUFFER_FROM) {
+      bufferFrom = Buffer.from;
+    } else {
+      bufferFrom = function (message) {
+        return new Buffer(message);
+      };
+    }
     var nodeMethod = function (message) {
       if (typeof message === 'string') {
         return crypto.createHash(algorithm).update(message, 'utf8').digest('hex');
       } else {
         if (message === null || message === undefined) {
-          throw ERROR;
+          throw new Error(ERROR);
         } else if (message.constructor === ArrayBuffer) {
           message = new Uint8Array(message);
         }
       }
       if (Array.isArray(message) || ArrayBuffer.isView(message) ||
         message.constructor === Buffer) {
-        return crypto.createHash(algorithm).update(new Buffer(message)).digest('hex');
+        return crypto.createHash(algorithm).update(bufferFrom(message)).digest('hex');
       } else {
         return method(message);
       }
@@ -152,29 +173,29 @@
     if (this.finalized) {
       return;
     }
-    var notString = typeof message !== 'string';
-    if (notString) {
-      if (message === null || message === undefined) {
-        throw ERROR;
-      } else if (message.constructor === root.ArrayBuffer) {
+    var notString, type = typeof message;
+    if (type !== 'string') {
+      if (type === 'object') {
+        if (message === null) {
+          throw new Error(ERROR);
+        } else if (ARRAY_BUFFER && message.constructor === ArrayBuffer) {
           message = new Uint8Array(message);
+        } else if (!Array.isArray(message)) {
+          if (!ARRAY_BUFFER || !ArrayBuffer.isView(message)) {
+            throw new Error(ERROR);
           }
         }
-    var length = message.length;
-    if (notString) {
-      if (typeof length !== 'number' ||
-        !Array.isArray(message) && 
-        !(ARRAY_BUFFER && ArrayBuffer.isView(message))) {
-        throw ERROR;
+      } else {
+        throw new Error(ERROR);
       }
+      notString = true;
     }
-    var code, index = 0, i, blocks = this.blocks;
-
+    var code, index = 0, i, length = message.length, blocks = this.blocks;
     while (index < length) {
       if (this.hashed) {
         this.hashed = false;
         blocks[0] = this.block;
-        blocks[16] = blocks[1] = blocks[2] = blocks[3] =
+        this.block = blocks[16] = blocks[1] = blocks[2] = blocks[3] =
           blocks[4] = blocks[5] = blocks[6] = blocks[7] =
           blocks[8] = blocks[9] = blocks[10] = blocks[11] =
           blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
@@ -182,26 +203,26 @@
 
       if (notString) {
         for (i = this.start; index < length && i < 64; ++index) {
-          blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
+          blocks[i >>> 2] |= message[index] << SHIFT[i++ & 3];
         }
       } else {
         for (i = this.start; index < length && i < 64; ++index) {
           code = message.charCodeAt(index);
           if (code < 0x80) {
-            blocks[i >> 2] |= code << SHIFT[i++ & 3];
+            blocks[i >>> 2] |= code << SHIFT[i++ & 3];
           } else if (code < 0x800) {
-            blocks[i >> 2] |= (0xc0 | (code >> 6)) << SHIFT[i++ & 3];
-            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >>> 2] |= (0xc0 | (code >>> 6)) << SHIFT[i++ & 3];
+            blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
           } else if (code < 0xd800 || code >= 0xe000) {
-            blocks[i >> 2] |= (0xe0 | (code >> 12)) << SHIFT[i++ & 3];
-            blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
-            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >>> 2] |= (0xe0 | (code >>> 12)) << SHIFT[i++ & 3];
+            blocks[i >>> 2] |= (0x80 | ((code >>> 6) & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
           } else {
             code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
-            blocks[i >> 2] |= (0xf0 | (code >> 18)) << SHIFT[i++ & 3];
-            blocks[i >> 2] |= (0x80 | ((code >> 12) & 0x3f)) << SHIFT[i++ & 3];
-            blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
-            blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >>> 2] |= (0xf0 | (code >>> 18)) << SHIFT[i++ & 3];
+            blocks[i >>> 2] |= (0x80 | ((code >>> 12) & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >>> 2] |= (0x80 | ((code >>> 6) & 0x3f)) << SHIFT[i++ & 3];
+            blocks[i >>> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
           }
         }
       }
@@ -231,7 +252,7 @@
     this.finalized = true;
     var blocks = this.blocks, i = this.lastByteIndex;
     blocks[16] = this.block;
-    blocks[i >> 2] |= EXTRA[i & 3];
+    blocks[i >>> 2] |= EXTRA[i & 3];
     this.block = blocks[16];
     if (i >= 56) {
       if (!this.hashed) {
@@ -243,7 +264,7 @@
         blocks[8] = blocks[9] = blocks[10] = blocks[11] =
         blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
     }
-    blocks[14] = this.hBytes << 3 | this.bytes >> 29;
+    blocks[14] = this.hBytes << 3 | this.bytes >>> 29;
     blocks[15] = this.bytes << 3;
     this.hash();
   };
@@ -314,6 +335,7 @@
       t2 = s0 + maj;
       e = a + t1 << 0;
       a = t1 + t2 << 0;
+      this.chromeBugWorkAround = true;
     }
 
     this.h0 = this.h0 + a << 0;
@@ -332,39 +354,39 @@
     var h0 = this.h0, h1 = this.h1, h2 = this.h2, h3 = this.h3, h4 = this.h4, h5 = this.h5,
       h6 = this.h6, h7 = this.h7;
 
-    var hex = HEX_CHARS[(h0 >> 28) & 0x0F] + HEX_CHARS[(h0 >> 24) & 0x0F] +
-      HEX_CHARS[(h0 >> 20) & 0x0F] + HEX_CHARS[(h0 >> 16) & 0x0F] +
-      HEX_CHARS[(h0 >> 12) & 0x0F] + HEX_CHARS[(h0 >> 8) & 0x0F] +
-      HEX_CHARS[(h0 >> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] +
-      HEX_CHARS[(h1 >> 28) & 0x0F] + HEX_CHARS[(h1 >> 24) & 0x0F] +
-      HEX_CHARS[(h1 >> 20) & 0x0F] + HEX_CHARS[(h1 >> 16) & 0x0F] +
-      HEX_CHARS[(h1 >> 12) & 0x0F] + HEX_CHARS[(h1 >> 8) & 0x0F] +
-      HEX_CHARS[(h1 >> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] +
-      HEX_CHARS[(h2 >> 28) & 0x0F] + HEX_CHARS[(h2 >> 24) & 0x0F] +
-      HEX_CHARS[(h2 >> 20) & 0x0F] + HEX_CHARS[(h2 >> 16) & 0x0F] +
-      HEX_CHARS[(h2 >> 12) & 0x0F] + HEX_CHARS[(h2 >> 8) & 0x0F] +
-      HEX_CHARS[(h2 >> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] +
-      HEX_CHARS[(h3 >> 28) & 0x0F] + HEX_CHARS[(h3 >> 24) & 0x0F] +
-      HEX_CHARS[(h3 >> 20) & 0x0F] + HEX_CHARS[(h3 >> 16) & 0x0F] +
-      HEX_CHARS[(h3 >> 12) & 0x0F] + HEX_CHARS[(h3 >> 8) & 0x0F] +
-      HEX_CHARS[(h3 >> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] +
-      HEX_CHARS[(h4 >> 28) & 0x0F] + HEX_CHARS[(h4 >> 24) & 0x0F] +
-      HEX_CHARS[(h4 >> 20) & 0x0F] + HEX_CHARS[(h4 >> 16) & 0x0F] +
-      HEX_CHARS[(h4 >> 12) & 0x0F] + HEX_CHARS[(h4 >> 8) & 0x0F] +
-      HEX_CHARS[(h4 >> 4) & 0x0F] + HEX_CHARS[h4 & 0x0F] +
-      HEX_CHARS[(h5 >> 28) & 0x0F] + HEX_CHARS[(h5 >> 24) & 0x0F] +
-      HEX_CHARS[(h5 >> 20) & 0x0F] + HEX_CHARS[(h5 >> 16) & 0x0F] +
-      HEX_CHARS[(h5 >> 12) & 0x0F] + HEX_CHARS[(h5 >> 8) & 0x0F] +
-      HEX_CHARS[(h5 >> 4) & 0x0F] + HEX_CHARS[h5 & 0x0F] +
-      HEX_CHARS[(h6 >> 28) & 0x0F] + HEX_CHARS[(h6 >> 24) & 0x0F] +
-      HEX_CHARS[(h6 >> 20) & 0x0F] + HEX_CHARS[(h6 >> 16) & 0x0F] +
-      HEX_CHARS[(h6 >> 12) & 0x0F] + HEX_CHARS[(h6 >> 8) & 0x0F] +
-      HEX_CHARS[(h6 >> 4) & 0x0F] + HEX_CHARS[h6 & 0x0F];
+    var hex = HEX_CHARS[(h0 >>> 28) & 0x0F] + HEX_CHARS[(h0 >>> 24) & 0x0F] +
+      HEX_CHARS[(h0 >>> 20) & 0x0F] + HEX_CHARS[(h0 >>> 16) & 0x0F] +
+      HEX_CHARS[(h0 >>> 12) & 0x0F] + HEX_CHARS[(h0 >>> 8) & 0x0F] +
+      HEX_CHARS[(h0 >>> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] +
+      HEX_CHARS[(h1 >>> 28) & 0x0F] + HEX_CHARS[(h1 >>> 24) & 0x0F] +
+      HEX_CHARS[(h1 >>> 20) & 0x0F] + HEX_CHARS[(h1 >>> 16) & 0x0F] +
+      HEX_CHARS[(h1 >>> 12) & 0x0F] + HEX_CHARS[(h1 >>> 8) & 0x0F] +
+      HEX_CHARS[(h1 >>> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] +
+      HEX_CHARS[(h2 >>> 28) & 0x0F] + HEX_CHARS[(h2 >>> 24) & 0x0F] +
+      HEX_CHARS[(h2 >>> 20) & 0x0F] + HEX_CHARS[(h2 >>> 16) & 0x0F] +
+      HEX_CHARS[(h2 >>> 12) & 0x0F] + HEX_CHARS[(h2 >>> 8) & 0x0F] +
+      HEX_CHARS[(h2 >>> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] +
+      HEX_CHARS[(h3 >>> 28) & 0x0F] + HEX_CHARS[(h3 >>> 24) & 0x0F] +
+      HEX_CHARS[(h3 >>> 20) & 0x0F] + HEX_CHARS[(h3 >>> 16) & 0x0F] +
+      HEX_CHARS[(h3 >>> 12) & 0x0F] + HEX_CHARS[(h3 >>> 8) & 0x0F] +
+      HEX_CHARS[(h3 >>> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] +
+      HEX_CHARS[(h4 >>> 28) & 0x0F] + HEX_CHARS[(h4 >>> 24) & 0x0F] +
+      HEX_CHARS[(h4 >>> 20) & 0x0F] + HEX_CHARS[(h4 >>> 16) & 0x0F] +
+      HEX_CHARS[(h4 >>> 12) & 0x0F] + HEX_CHARS[(h4 >>> 8) & 0x0F] +
+      HEX_CHARS[(h4 >>> 4) & 0x0F] + HEX_CHARS[h4 & 0x0F] +
+      HEX_CHARS[(h5 >>> 28) & 0x0F] + HEX_CHARS[(h5 >>> 24) & 0x0F] +
+      HEX_CHARS[(h5 >>> 20) & 0x0F] + HEX_CHARS[(h5 >>> 16) & 0x0F] +
+      HEX_CHARS[(h5 >>> 12) & 0x0F] + HEX_CHARS[(h5 >>> 8) & 0x0F] +
+      HEX_CHARS[(h5 >>> 4) & 0x0F] + HEX_CHARS[h5 & 0x0F] +
+      HEX_CHARS[(h6 >>> 28) & 0x0F] + HEX_CHARS[(h6 >>> 24) & 0x0F] +
+      HEX_CHARS[(h6 >>> 20) & 0x0F] + HEX_CHARS[(h6 >>> 16) & 0x0F] +
+      HEX_CHARS[(h6 >>> 12) & 0x0F] + HEX_CHARS[(h6 >>> 8) & 0x0F] +
+      HEX_CHARS[(h6 >>> 4) & 0x0F] + HEX_CHARS[h6 & 0x0F];
     if (!this.is224) {
-      hex += HEX_CHARS[(h7 >> 28) & 0x0F] + HEX_CHARS[(h7 >> 24) & 0x0F] +
-        HEX_CHARS[(h7 >> 20) & 0x0F] + HEX_CHARS[(h7 >> 16) & 0x0F] +
-        HEX_CHARS[(h7 >> 12) & 0x0F] + HEX_CHARS[(h7 >> 8) & 0x0F] +
-        HEX_CHARS[(h7 >> 4) & 0x0F] + HEX_CHARS[h7 & 0x0F];
+      hex += HEX_CHARS[(h7 >>> 28) & 0x0F] + HEX_CHARS[(h7 >>> 24) & 0x0F] +
+        HEX_CHARS[(h7 >>> 20) & 0x0F] + HEX_CHARS[(h7 >>> 16) & 0x0F] +
+        HEX_CHARS[(h7 >>> 12) & 0x0F] + HEX_CHARS[(h7 >>> 8) & 0x0F] +
+        HEX_CHARS[(h7 >>> 4) & 0x0F] + HEX_CHARS[h7 & 0x0F];
     }
     return hex;
   };
@@ -378,16 +400,16 @@
       h6 = this.h6, h7 = this.h7;
 
     var arr = [
-      (h0 >> 24) & 0xFF, (h0 >> 16) & 0xFF, (h0 >> 8) & 0xFF, h0 & 0xFF,
-      (h1 >> 24) & 0xFF, (h1 >> 16) & 0xFF, (h1 >> 8) & 0xFF, h1 & 0xFF,
-      (h2 >> 24) & 0xFF, (h2 >> 16) & 0xFF, (h2 >> 8) & 0xFF, h2 & 0xFF,
-      (h3 >> 24) & 0xFF, (h3 >> 16) & 0xFF, (h3 >> 8) & 0xFF, h3 & 0xFF,
-      (h4 >> 24) & 0xFF, (h4 >> 16) & 0xFF, (h4 >> 8) & 0xFF, h4 & 0xFF,
-      (h5 >> 24) & 0xFF, (h5 >> 16) & 0xFF, (h5 >> 8) & 0xFF, h5 & 0xFF,
-      (h6 >> 24) & 0xFF, (h6 >> 16) & 0xFF, (h6 >> 8) & 0xFF, h6 & 0xFF
+      (h0 >>> 24) & 0xFF, (h0 >>> 16) & 0xFF, (h0 >>> 8) & 0xFF, h0 & 0xFF,
+      (h1 >>> 24) & 0xFF, (h1 >>> 16) & 0xFF, (h1 >>> 8) & 0xFF, h1 & 0xFF,
+      (h2 >>> 24) & 0xFF, (h2 >>> 16) & 0xFF, (h2 >>> 8) & 0xFF, h2 & 0xFF,
+      (h3 >>> 24) & 0xFF, (h3 >>> 16) & 0xFF, (h3 >>> 8) & 0xFF, h3 & 0xFF,
+      (h4 >>> 24) & 0xFF, (h4 >>> 16) & 0xFF, (h4 >>> 8) & 0xFF, h4 & 0xFF,
+      (h5 >>> 24) & 0xFF, (h5 >>> 16) & 0xFF, (h5 >>> 8) & 0xFF, h5 & 0xFF,
+      (h6 >>> 24) & 0xFF, (h6 >>> 16) & 0xFF, (h6 >>> 8) & 0xFF, h6 & 0xFF
     ];
     if (!this.is224) {
-      arr.push((h7 >> 24) & 0xFF, (h7 >> 16) & 0xFF, (h7 >> 8) & 0xFF, h7 & 0xFF);
+      arr.push((h7 >>> 24) & 0xFF, (h7 >>> 16) & 0xFF, (h7 >>> 8) & 0xFF, h7 & 0xFF);
     }
     return arr;
   };
@@ -413,43 +435,43 @@
   };
 
   function HmacSha256(key, is224, sharedMemory) {
-    var notString = typeof key !== 'string';
-    if (notString) {
-      if (key === null || key === undefined) {
-        throw ERROR;
-      } else if (key.constructor === root.ArrayBuffer) {
-        key = new Uint8Array(key);
-      }
-    }
-    var length = key.length;
-    if (notString) {
-      if (typeof length !== 'number' ||
-        !Array.isArray(key) && 
-        !(ARRAY_BUFFER && ArrayBuffer.isView(key))) {
-        throw ERROR;
-      }
-    } else {
+    var i, type = typeof key;
+    if (type === 'string') {
       var bytes = [], length = key.length, index = 0, code;
-      for (var i = 0; i < length; ++i) {
+      for (i = 0; i < length; ++i) {
         code = key.charCodeAt(i);
         if (code < 0x80) {
           bytes[index++] = code;
         } else if (code < 0x800) {
-          bytes[index++] = (0xc0 | (code >> 6));
+          bytes[index++] = (0xc0 | (code >>> 6));
           bytes[index++] = (0x80 | (code & 0x3f));
         } else if (code < 0xd800 || code >= 0xe000) {
-          bytes[index++] = (0xe0 | (code >> 12));
-          bytes[index++] = (0x80 | ((code >> 6) & 0x3f));
+          bytes[index++] = (0xe0 | (code >>> 12));
+          bytes[index++] = (0x80 | ((code >>> 6) & 0x3f));
           bytes[index++] = (0x80 | (code & 0x3f));
         } else {
           code = 0x10000 + (((code & 0x3ff) << 10) | (key.charCodeAt(++i) & 0x3ff));
-          bytes[index++] = (0xf0 | (code >> 18));
-          bytes[index++] = (0x80 | ((code >> 12) & 0x3f));
-          bytes[index++] = (0x80 | ((code >> 6) & 0x3f));
+          bytes[index++] = (0xf0 | (code >>> 18));
+          bytes[index++] = (0x80 | ((code >>> 12) & 0x3f));
+          bytes[index++] = (0x80 | ((code >>> 6) & 0x3f));
           bytes[index++] = (0x80 | (code & 0x3f));
         }
       }
       key = bytes;
+    } else {
+      if (type === 'object') {
+        if (key === null) {
+          throw new Error(ERROR);
+        } else if (ARRAY_BUFFER && key.constructor === ArrayBuffer) {
+          key = new Uint8Array(key);
+        } else if (!Array.isArray(key)) {
+          if (!ARRAY_BUFFER || !ArrayBuffer.isView(key)) {
+            throw new Error(ERROR);
+          }
+        }
+      } else {
+        throw new Error(ERROR);
+      }
     }
 
     if (key.length > 64) {
@@ -457,7 +479,7 @@
     }
 
     var oKeyPad = [], iKeyPad = [];
-    for (var i = 0; i < 64; ++i) {
+    for (i = 0; i < 64; ++i) {
       var b = key[i] || 0;
       oKeyPad[i] = 0x5c ^ b;
       iKeyPad[i] = 0x36 ^ b;

src/sha256.mjs

@@ -0,0 +1,6 @@
+import sha256 from './sha256.js';
+
+const { sha224 } = sha256;
+
+export { sha256, sha224 };
+export default sha256;

tests/esm-test.mjs

@@ -0,0 +1,20 @@
+import sha256, { sha224, sha256 as namedSha256 } from 'js-sha256';
+import browserSha256, { sha224 as browserSha224 } from 'js-sha256/build/sha256.mjs';
+
+const SHA256_ABC = 'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad';
+const SHA224_ABC = '23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7';
+
+if (sha256('abc') !== SHA256_ABC || namedSha256('abc') !== SHA256_ABC) {
+  throw new Error('ESM SHA-256 import failed');
+}
+if (sha224('abc') !== SHA224_ABC) {
+  throw new Error('ESM SHA-224 import failed');
+}
+if (typeof sha256.hmac !== 'function' || typeof sha224.hmac !== 'function') {
+  throw new Error('ESM HMAC API is missing');
+}
+if (browserSha256('abc') !== SHA256_ABC || browserSha224('abc') !== SHA224_ABC) {
+  throw new Error('Browser ESM import failed');
+}
+
+console.log('ESM imports: PASS');

tests/hmac-test.js

@@ -41,12 +41,6 @@
         '865cc329d317f6d9fdbd183a3c5cc5fd4c370d11f98abbbb404bceb1e6392c7e': ['中文', '中文'],
         'efeef87be5731506b69bb64a9898a456dd12c94834c36a4d8ba99e3db79ad7ed': ['aécio', 'aécio'],
         '8a6e527049b9cfc7e1c84bcf356a1289c95da68a586c03de3327f3de0d3737fe': ['𠜎', '𠜎']
-      },
-      'ArrayBuffer': {
-        'e48411262715c8370cd5e7bf8e82bef53bd53712d007f3429351843b77c7bb9b': [
-          new ArrayBuffer(0),
-          'Hi There'
-        ]
       }
     },
     sha224_hmac: {
@@ -80,15 +74,36 @@
         'e2280928fe813aeb7fa59aa14dd5e589041bfdf91945d19d25b9f3db': ['中文', '中文'],
         '86c53dc054b16f6e006a254891bc9ff0da5df8e1a6faee3b0aaa732d': ['aécio', 'aécio'],
         'e9e5991bfb84506b105f800afac1599ff807bb8e20db8ffda48997b9': ['𠜎', '𠜎']
-      },
-      'ArrayBuffer': {
+      }
+    }
+  };
+
+  if (!(typeof JS_SHA256_NO_ARRAY_BUFFER === 'boolean' && JS_SHA256_NO_ARRAY_BUFFER)) {
+    testCases.sha256_hmac.Uint8Array = {
+      'e48411262715c8370cd5e7bf8e82bef53bd53712d007f3429351843b77c7bb9b': [
+        new Uint8Array(0),
+        'Hi There'
+      ]
+    };
+    testCases.sha256_hmac.ArrayBuffer = {
+      'e48411262715c8370cd5e7bf8e82bef53bd53712d007f3429351843b77c7bb9b': [
+        new ArrayBuffer(0),
+        'Hi There'
+      ]
+    };
+    testCases.sha224_hmac.Uint8Array = {
       'da8f94de91d62154b55ea4e8d6eb133f6d553bcd1f1ba205b9488945': [
         new ArrayBuffer(0),
         'Hi There'
       ]
-      }
-    }
     };
+    testCases.sha224_hmac.ArrayBuffer = {
+      'da8f94de91d62154b55ea4e8d6eb133f6d553bcd1f1ba205b9488945': [
+        new ArrayBuffer(0),
+        'Hi There'
+      ]
+    };
+  }
 
   var errorTestCases = [null, undefined, { length: 0 }, 0, 1, false, true, NaN, Infinity, function () {}];
 

tests/node-test.js

@@ -1,47 +1,95 @@
-// Node.js env
 expect = require('expect.js');
-sha256 = require('../src/sha256.js').sha256;
-sha224 = require('../src/sha256.js').sha224;
-require('./test.js');
-require('./hmac-test.js');
+Worker = require("tiny-worker");
 
-delete require.cache[require.resolve('../src/sha256.js')]
-delete require.cache[require.resolve('./test.js')]
-delete require.cache[require.resolve('./hmac-test.js')]
+function unset() {
+  delete require.cache[require.resolve('../src/sha256.js')];
+  delete require.cache[require.resolve('./test.js')];
+  delete require.cache[require.resolve('./hmac-test.js')];
   sha256 = null;
   sha224 = null;
+  BUFFER = undefined;
+  JS_SHA256_NO_WINDOW = undefined;
+  JS_SHA256_NO_NODE_JS = undefined;
+  JS_SHA256_NO_COMMON_JS = undefined;
+  JS_SHA256_NO_ARRAY_BUFFER = undefined;
+  JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW = undefined;
+  window = undefined;
+}
 
-// Webpack browser env
-JS_SHA256_NO_NODE_JS = true;
-window = global;
+function requireToGlobal() {
   sha256 = require('../src/sha256.js').sha256;
   sha224 = require('../src/sha256.js').sha224;
+}
+
+function runCommonJsTest() {
+  requireToGlobal();
   require('./test.js');
   require('./hmac-test.js');
+  unset();
+}
 
-delete require.cache[require.resolve('../src/sha256.js')]
-delete require.cache[require.resolve('./test.js')]
-delete require.cache[require.resolve('./hmac-test.js')]
-sha256 = null;
-sha224 = null;
-
-// browser env
-JS_SHA256_NO_NODE_JS = true;
-JS_SHA256_NO_COMMON_JS = true;
+function runWindowTest() {
   window = global;
   require('../src/sha256.js');
   require('./test.js');
   require('./hmac-test.js');
+  unset();
+}
 
-delete require.cache[require.resolve('../src/sha256.js')]
-delete require.cache[require.resolve('./test.js')]
-delete require.cache[require.resolve('./hmac-test.js')]
-sha256 = null;
-sha224 = null;
+function runBrowserWithProcessPolyfillTest() {
+  var Module = require('module');
+  var originalRequire = Module.prototype.require;
+  window = global;
+  Module.prototype.require = function (id) {
+    if (id === 'crypto' || id === 'buffer') {
+      throw new Error('Node.js module loaded in browser environment');
+    }
+    return originalRequire.apply(this, arguments);
+  };
+  try {
+    runCommonJsTest();
+  } finally {
+    Module.prototype.require = originalRequire;
+  }
+}
+
+// Node.js env
+BUFFER = true;
+runCommonJsTest();
+
+// Node.js env, no Buffer.from
+JS_SHA256_NO_BUFFER_FROM = true
+runCommonJsTest();
+
+// browser env with a Node.js process polyfill
+runBrowserWithProcessPolyfillTest();
+
+// Webpack browser env
+JS_SHA256_NO_NODE_JS = true;
+window = global;
+runCommonJsTest();
+
+// browser env
+JS_SHA256_NO_NODE_JS = true;
+JS_SHA256_NO_COMMON_JS = true;
+runWindowTest();
+
+// browser env and no array buffer
+JS_SHA256_NO_NODE_JS = true;
+JS_SHA256_NO_COMMON_JS = true;
+JS_SHA256_NO_ARRAY_BUFFER = true;
+runWindowTest();
+
+// browser env and no isView
+JS_SHA256_NO_NODE_JS = true;
+JS_SHA256_NO_COMMON_JS = true;
+JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW = true;
+runWindowTest();
 
 // browser AMD
 JS_SHA256_NO_NODE_JS = true;
 JS_SHA256_NO_COMMON_JS = true;
+JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW = false;
 window = global;
 define = function (func) {
   sha256 = func();
@@ -52,3 +100,38 @@ define = function (func) {
 define.amd = true;
 
 require('../src/sha256.js');
+unset();
+
+// webworker
+WORKER = 'tests/worker.js';
+SOURCE = 'src/sha256.js';
+
+require('./worker-test.js');
+
+delete require.cache[require.resolve('./worker-test.js')];
+
+// cover webworker
+JS_SHA256_NO_WINDOW = true;
+JS_SHA256_NO_NODE_JS = true;
+WORKER = './worker.js';
+SOURCE = '../src/sha256.js';
+window = global;
+self = global;
+
+Worker = function (file) {
+  require(file);
+  currentWorker = this;
+
+  this.postMessage = function (data) {
+    onmessage({data: data});
+  };
+}
+
+postMessage = function (data) {
+  currentWorker.onmessage({data: data});
+}
+
+importScripts = function () {};
+
+requireToGlobal();
+require('./worker-test.js');

tests/test.js

@@ -22,7 +22,8 @@
       'UTF8': {
         '72726d8818f693066ceb69afa364218b692e62ea92b385782363780f47529c21': '中文',
         '53196d1acfce0c4b264e01e8018c989d571351f59e33f055f76ff15b4f0516c6': 'aécio',
-        '8d10a48685dbc34484696de7ea7434d80a54c1d60100530faccf697463ef19c9': '𠜎'
+        '8d10a48685dbc34484696de7ea7434d80a54c1d60100530faccf697463ef19c9': '𠜎',
+        '2c731ad02e3d0e3c863bdbce4cce221e0be1d31efffdd8e1455a835e8287dc33': 'Tehtäväsi on muotoilla teksti, jossa käyttäjälle suositellaan hänen henkilökohtaisiin tietoihinsa perustuen avioehdon tekemistä. Suosittelemme nimenomaan tätä tuotetta käyttäjän henkilökohtaisista tiedoista johtuen. Tuottamasi tekstin tulee olla lyhyt, persoonallinen, ymmärrettävä ja todenmukainen. Suositus perustuu seuraaviin seikkoihin:\n\nSeikka 0: Avioehdon tekeminen on verohyötyjen vuoksi suositeltavaa, koska olet ilmaissut että haluat kuoleman tapauksessa turvata ensisijaisesti aviopuolisosi asemaa (ennemmin kuin lasten asemaa). Avioehdolla voit määrätä, että puolet kuolleen puolison omaisuudesta siirtyy verovapaasti leskelle.\n\nVoit halutessasi hyödyntää seuraavia tietoja tekstin muotoilussa persoonallisemmaksi: Käyttäjällä on kumppani nimeltä PARTNER_NAME. Käyttäjällä on suurperhe. Käyttäjällä on lapsiperhe.\n\nPuhuttele käyttäjää siihen sävyyn että tiedät jo mitä käyttäjä haluaa, koska hän on kertonut toiveistaan, ja niiden perusteella tehty suositus on ilmiselvä. Joten älä käytä epävarmoja ilmaisuja kuten "halutessasi", vaan kirjoita itsevarmoilla ilmaisuilla kuten "koska haluat". Älä tee oletuksia käyttäjän sukupuolesta, emme tiedä onko hän mies vai nainen. Älä käytä sanaa jälkikasvu, puhu ennemmin lapsesta tai lapsista riippuen onko lapsia yksi vai useampia. Älä puhuttele käyttäjää ensimmäisessä persoonassa, käytä ennemmin passiivimuotoa. Tekstin sävyn tulisi olla neutraalin asiallinen, ei melodramaattinen eikä leikkisä. Pysy totuudessa, älä keksi uusia seikkoja yllä listattujen lisäksi. Viittaa ihmisiin nimillä silloin kun se on mahdollista. Tekstin tulisi olla vain muutaman lauseen mittainen. Älä siis kirjoita pitkiä selityksiä äläkä kirjoita listoja. Tiivistä oleellinen tieto lyhyeksi ja persoonalliseksi tekstiksi.'
       },
       'UTF8 more than 64 bytes': {
         'd691014feebf35b3500ef6f6738d0094cac63628a7a018a980a40292a77703d1': '訊息摘要演算法第五版（英語：Message-Digest Algorithm 5，縮寫為MD5），是當前電腦領域用於確保資訊傳輸完整一致而廣泛使用的雜湊演算法之一',
@@ -40,18 +41,6 @@
         '182889f925ae4e5cc37118ded6ed87f7bdc7cab5ec5e78faef2e50048999473f': [211, 212],
         'd7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592': [84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103],
         '74b51c6911f9a8b5e7c499effe7604e43b672166818873c27752c248de434841': [48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55]
-      },
-
-      'Uint8Array': {
-        '182889f925ae4e5cc37118ded6ed87f7bdc7cab5ec5e78faef2e50048999473f': new Uint8Array([211, 212]),
-        'd7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592': new Uint8Array([84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103])
-      },
-      'Int8Array': {
-        'd7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592': new Int8Array([84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103])
-      },
-      'ArrayBuffer': {
-        'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855': new ArrayBuffer(0),
-        '6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d': new ArrayBuffer(1),
       }
     },
     sha224: {
@@ -66,7 +55,8 @@
       'UTF8': {
         'dfbab71afdf54388af4d55f8bd3de8c9b15e0eb916bf9125f4a959d4': '中文',
         'd12841cafd89c534924a839e62bf35a2b5f3717b7802eb19bd8d8e15': 'aécio',
-        'eaa0129b5509f5701db218fb7076b282e4409da52d06363aa3bdd63d': '𠜎'
+        'eaa0129b5509f5701db218fb7076b282e4409da52d06363aa3bdd63d': '𠜎',
+        'b19e948e39752eb064452abbaecac72e17ce2a028d640a8864e92c36': 'Tehtäväsi on muotoilla teksti, jossa käyttäjälle suositellaan hänen henkilökohtaisiin tietoihinsa perustuen avioehdon tekemistä. Suosittelemme nimenomaan tätä tuotetta käyttäjän henkilökohtaisista tiedoista johtuen. Tuottamasi tekstin tulee olla lyhyt, persoonallinen, ymmärrettävä ja todenmukainen. Suositus perustuu seuraaviin seikkoihin:\n\nSeikka 0: Avioehdon tekeminen on verohyötyjen vuoksi suositeltavaa, koska olet ilmaissut että haluat kuoleman tapauksessa turvata ensisijaisesti aviopuolisosi asemaa (ennemmin kuin lasten asemaa). Avioehdolla voit määrätä, että puolet kuolleen puolison omaisuudesta siirtyy verovapaasti leskelle.\n\nVoit halutessasi hyödyntää seuraavia tietoja tekstin muotoilussa persoonallisemmaksi: Käyttäjällä on kumppani nimeltä PARTNER_NAME. Käyttäjällä on suurperhe. Käyttäjällä on lapsiperhe.\n\nPuhuttele käyttäjää siihen sävyyn että tiedät jo mitä käyttäjä haluaa, koska hän on kertonut toiveistaan, ja niiden perusteella tehty suositus on ilmiselvä. Joten älä käytä epävarmoja ilmaisuja kuten "halutessasi", vaan kirjoita itsevarmoilla ilmaisuilla kuten "koska haluat". Älä tee oletuksia käyttäjän sukupuolesta, emme tiedä onko hän mies vai nainen. Älä käytä sanaa jälkikasvu, puhu ennemmin lapsesta tai lapsista riippuen onko lapsia yksi vai useampia. Älä puhuttele käyttäjää ensimmäisessä persoonassa, käytä ennemmin passiivimuotoa. Tekstin sävyn tulisi olla neutraalin asiallinen, ei melodramaattinen eikä leikkisä. Pysy totuudessa, älä keksi uusia seikkoja yllä listattujen lisäksi. Viittaa ihmisiin nimillä silloin kun se on mahdollista. Tekstin tulisi olla vain muutaman lauseen mittainen. Älä siis kirjoita pitkiä selityksiä äläkä kirjoita listoja. Tiivistä oleellinen tieto lyhyeksi ja persoonalliseksi tekstiksi.'
       },
       'UTF8 more than 64 bytes': {
         '0dda421f3f81272418e1313673e9d74b7f2d04efc9c52c69458e12c3': '訊息摘要演算法第五版（英語：Message-Digest Algorithm 5，縮寫為MD5），是當前電腦領域用於確保資訊傳輸完整一致而廣泛使用的雜湊演算法之一',
@@ -83,34 +73,48 @@
         'd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f': [],
         '730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525': [84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103],
         '16ee1b101fe0e0d8dd156d598931ec19d75b0f8dc0a0455733c168c8': [48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55, 56, 48, 49, 50, 51, 52, 53, 54, 55]
-      },
-      'Uint8Array': {
+      }
+    }
+  };
+
+  if (!(typeof JS_SHA256_NO_ARRAY_BUFFER === 'boolean' && JS_SHA256_NO_ARRAY_BUFFER)) {
+    testCases.sha256.Uint8Array = {
+      '182889f925ae4e5cc37118ded6ed87f7bdc7cab5ec5e78faef2e50048999473f': new Uint8Array([211, 212]),
+      'd7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592': new Uint8Array([84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103])
+    };
+    testCases.sha256.Int8Array = {
+      'd7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592': new Int8Array([84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103])
+    };
+    testCases.sha256.ArrayBuffer = {
+      'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855': new ArrayBuffer(0),
+      '6e340b9cffb37a989ca544e6bb780a2c78901d3fb33738768511a30617afa01d': new ArrayBuffer(1)
+    };
+    testCases.sha224.Uint8Array = {
       'e17541396a3ecd1cd5a2b968b84e597e8eae3b0ea3127963bf48dd3b': new Uint8Array([211, 212]),
       '730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525': new Uint8Array([84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103])    
-      },
-      'Int8Array': {
+    };
+    testCases.sha224.Int8Array = {
       '730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525': new Int8Array([84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103])
-      },
-      'ArrayBuffer': {
+    };
+    testCases.sha224.ArrayBuffer = {
       'd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f': new ArrayBuffer(0),
       'fff9292b4201617bdc4d3053fce02734166a683d7d858a7f5f59b073': new ArrayBuffer(1),
-      }
-    }
     };
+  }
+
+  if (typeof BUFFER === 'boolean' && BUFFER) {
+    testCases.sha256.Buffer = {
+      'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855': Buffer.from([]),
+      'd7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592': Buffer.from(new Uint8Array([84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103]))
+    };
+    testCases.sha224.Buffer = {
+      'd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f': Buffer.from([]),
+      '730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525': Buffer.from(new Uint8Array([84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103]))
+    };
+  }
 
   var errorTestCases = [null, undefined, { length: 0 }, 0, 1, false, true, NaN, Infinity, function () {}];
 
-  if (typeof process == 'object') {
-    testCases.sha256['Buffer'] = {
-      'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855': new Buffer(0),
-      'd7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592': new Buffer(new Uint8Array([84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103]))
-    };
-    testCases.sha224['Buffer'] = {
-      'd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f': new Buffer(0),
-      '730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525': new Buffer(new Uint8Array([84, 104, 101, 32, 113, 117, 105, 99, 107, 32, 98, 114, 111, 119, 110, 32, 102, 111, 120, 32, 106, 117, 109, 112, 115, 32, 111, 118, 101, 114, 32, 116, 104, 101, 32, 108, 97, 122, 121, 32, 100, 111, 103]))
-    };
-  }
-
   function runTestCases(name, algorithm) {
     var methods = [
       {

tests/worker-test.js

@@ -0,0 +1,24 @@
+(function (Worker, WORKER, SOURCE) {
+  var cases = {
+    'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855': '',
+    'd7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592': 'The quick brown fox jumps over the lazy dog',
+    'ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c': 'The quick brown fox jumps over the lazy dog.'
+  };
+
+  describe('#sha256', function () {
+    Object.keys(cases).forEach(function (hash) {
+      it('should be equal', function (done) {
+        var worker = new Worker(WORKER);
+        worker.onmessage = function(event) {
+          expect(event.data).to.be(hash);
+          if (worker.terminate) {
+            worker.terminate();
+          }
+          done();
+        };
+        worker.postMessage(SOURCE);
+        worker.postMessage(cases[hash]);
+      });
+    });
+  });
+})(Worker, WORKER, SOURCE);

tests/worker.html

@@ -0,0 +1,26 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>SHA256</title>
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/mocha/2.1.0/mocha.min.css">
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/2.1.0/mocha.min.js"></script>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/expect.js/0.2.0/expect.min.js"></script>
+  <script src="../src/sha256.js"></script>
+</head>
+<body>
+  <div id="mocha"></div>
+  <script>
+    WORKER = 'worker.js';
+    SOURCE = '../src/sha256.js';
+    mocha.setup('bdd');
+  </script>
+  <script src="worker-test.js"></script>
+  <script>
+    mocha.checkLeaks();
+    mocha.run();
+  </script>
+  <script>
+  </script>
+</body>
+</html>

tests/worker.js

@@ -0,0 +1,12 @@
+var imported = false;
+onmessage = function(e) {
+  if (imported) {
+    postMessage(sha256(e.data));
+    if (typeof exports !== 'undefined') {
+      imported = false;
+    }
+  } else {
+    imported = true;
+    importScripts(e.data);
+  }
+}