Initial commit: 11ty website with Fire/Frost branding

2026-04-02 18:39:00 -05:00
commit 40b45dff2e
1646 changed files with 329080 additions and 0 deletions
--- a/node_modules/@11ty/eleventy-utils/src/Buffer.js
+++ b/node_modules/@11ty/eleventy-utils/src/Buffer.js
@@ -0,0 +1,10 @@
+function isBuffer(inst) {
+	if(typeof Buffer !== "undefined") {
+		return Buffer.isBuffer(inst);
+	}
+	return inst instanceof Uint8Array;
+}
+
+module.exports = {
+	isBuffer
+}
--- a/node_modules/@11ty/eleventy-utils/src/CreateHash.js
+++ b/node_modules/@11ty/eleventy-utils/src/CreateHash.js
@@ -0,0 +1,27 @@
+
+const { Hash } = require("./HashTypes.js");
+
+// same output as node:crypto above (though now async).
+async function createHash(...content) {
+	return Hash.create().toBase64Url(...content);
+}
+
+async function createHashHex(...content) {
+	return Hash.create().toHex(...content);
+}
+
+// Slower, but this feature does not require WebCrypto
+function createHashSync(...content) {
+	return Hash.createSync().toBase64Url(...content);
+}
+
+function createHashHexSync(...content) {
+	return Hash.createSync().toHex(...content);
+}
+
+module.exports = {
+	createHash,
+	createHashSync,
+	createHashHex,
+	createHashHexSync,
+};
--- a/node_modules/@11ty/eleventy-utils/src/DateCompare.js
+++ b/node_modules/@11ty/eleventy-utils/src/DateCompare.js
@@ -0,0 +1,41 @@
+class DateCompare {
+	static isTimestampWithinDuration(timestamp, duration, compareDate = Date.now()) {
+		// the default duration is Infinity (also "*")
+		if (!duration || duration === "*" || duration === Infinity) {
+			return true;
+		}
+
+		let expiration = timestamp + this.getDurationMs(duration);
+
+		// still valid
+		if (expiration > compareDate) {
+			return true;
+		}
+
+		// expired
+		return false;
+	}
+
+	static getDurationMs(duration = "0s") {
+		let durationUnits = duration.slice(-1);
+		let durationMultiplier;
+		if (durationUnits === "s") {
+			durationMultiplier = 1;
+		} else if (durationUnits === "m") {
+			durationMultiplier = 60;
+		} else if (durationUnits === "h") {
+			durationMultiplier = 60 * 60;
+		} else if (durationUnits === "d") {
+			durationMultiplier = 60 * 60 * 24;
+		} else if (durationUnits === "w") {
+			durationMultiplier = 60 * 60 * 24 * 7;
+		} else if (durationUnits === "y") {
+			durationMultiplier = 60 * 60 * 24 * 365;
+		}
+
+		let durationValue = parseInt(duration.slice(0, duration.length - 1), 10);
+		return durationValue * durationMultiplier * 1000;
+	}
+}
+
+module.exports = DateCompare;
--- a/node_modules/@11ty/eleventy-utils/src/HashTypes.js
+++ b/node_modules/@11ty/eleventy-utils/src/HashTypes.js
@@ -0,0 +1,158 @@
+const { base64UrlSafe } = require("./Url.js");
+const { isBuffer } = require("./Buffer.js");
+const sha256 = require("./lib-sha256.js");
+
+function hasNodeCryptoModule() {
+	try {
+		require("node:crypto");
+		return true;
+	} catch(e) {
+		return false;
+	}
+}
+
+const HAS_NODE_CRYPTO = hasNodeCryptoModule();
+
+class Hash {
+	static create() {
+		if(typeof globalThis.crypto === "undefined") {
+			// Backwards compat with Node Crypto, since WebCrypto (crypto global) is Node 20+
+			if(HAS_NODE_CRYPTO) {
+				return NodeCryptoHash;
+			}
+			return ScriptHash;
+		}
+		return WebCryptoHash;
+	}
+
+	// Does not use WebCrypto (as WebCrypto is async-only)
+	static createSync() {
+		if(HAS_NODE_CRYPTO) {
+			return NodeCryptoHash;
+		}
+		return ScriptHash;
+	}
+
+	static toBase64(bytes) {
+		let str = Array.from(bytes, (b) => String.fromCodePoint(b)).join("");
+
+		// `btoa` Node 16+
+		return btoa(str);
+	}
+
+	// Thanks https://evanhahn.com/the-best-way-to-concatenate-uint8arrays/ (Public domain)
+	static mergeUint8Array(...arrays) {
+		let totalLength = arrays.reduce(
+			(total, uint8array) => total + uint8array.byteLength,
+			0
+		);
+
+		let result = new Uint8Array(totalLength);
+		let offset = 0;
+		arrays.forEach((uint8array) => {
+			result.set(uint8array, offset);
+			offset += uint8array.byteLength;
+		});
+
+		return result;
+	}
+
+	static bufferToBase64Url(hashBuffer) {
+		return base64UrlSafe(this.toBase64(new Uint8Array(hashBuffer)));
+	}
+
+	static bufferToHex(hashBuffer) {
+		return Array.from(new Uint8Array(hashBuffer))
+			.map((b) => b.toString(16).padStart(2, "0"))
+			.join("");
+	}
+}
+
+class WebCryptoHash extends Hash {
+	static async toHash(...content) {
+		let encoder = new TextEncoder();
+		let input = this.mergeUint8Array(...content.map(c => {
+			if(isBuffer(c)) {
+				return c;
+			}
+			return encoder.encode(c);
+		}));
+
+		// `crypto` is Node 20+
+		return crypto.subtle.digest("SHA-256", input);
+	}
+
+	static async toBase64Url(...content) {
+		return this.toHash(...content).then(hashBuffer => {
+			return this.bufferToBase64Url(hashBuffer);
+		});
+	}
+
+	static async toHex(...content) {
+		return this.toHash(...content).then(hashBuffer => {
+			return this.bufferToHex(hashBuffer);
+		});
+	}
+
+	static toBase64UrlSync() {
+		throw new Error("Synchronous methods are not available in the Web Crypto API.");
+	}
+
+	static toHexSync() {
+		throw new Error("Synchronous methods are not available in the Web Crypto API.");
+	}
+}
+
+class NodeCryptoHash extends Hash {
+	static toHash(...content) {
+		// This *needs* to be a dynamic require for proper bundling.
+		const { createHash } = require("node:crypto");
+		let hash = createHash("sha256");
+
+		for(let c of content) {
+			hash.update(c);
+		}
+
+		return hash;
+	}
+
+	static toBase64Url(...content) {
+		// Note that Node does include a `digest("base64url")` that is supposedly Node 14+ but curiously failed on Stackblitz’s Node 16.
+		let base64 = this.toHash(...content).digest("base64");
+		return base64UrlSafe(base64);
+	}
+
+	static toHex(...content) {
+		return this.toHash(...content).digest("hex");
+	}
+
+	// aliases
+	static toBase64UrlSync = this.toBase64Url;
+	static toHexSync = this.toHex;
+}
+
+class ScriptHash extends Hash {
+	static toHash(...content) {
+		let hash = sha256();
+		for(let c of content) {
+			hash.add(c);
+		}
+		return hash.digest();
+	}
+
+	static toBase64Url(...content) {
+		let hashBuffer = this.toHash(...content);
+		return this.bufferToBase64Url(hashBuffer);
+	}
+
+	static toHex(...content) {
+		let hashBuffer = this.toHash(...content);
+		return this.bufferToHex(hashBuffer);
+	}
+
+	// aliases
+	static toBase64UrlSync = this.toBase64Url;
+	static toHexSync = this.toHex;
+}
+
+module.exports = { Hash, NodeCryptoHash, ScriptHash, WebCryptoHash }
--- a/node_modules/@11ty/eleventy-utils/src/IsPlainObject.js
+++ b/node_modules/@11ty/eleventy-utils/src/IsPlainObject.js
@@ -0,0 +1,24 @@
+/* Prior art: this utility was created for https://github.com/11ty/eleventy/issues/2214
+
+ * Inspired by implementations from `is-what`, `typechecker`, `jQuery`, and `lodash`
+
+ * `is-what`
+ * More reading at https://www.npmjs.com/package/is-what#user-content-isplainobject-vs-isanyobject
+ * if (Object.prototype.toString.call(value).slice(8, -1) !== 'Object') return false;
+ * return value.constructor === Object && Object.getPrototypeOf(value) === Object.prototype;
+
+ * `typechecker`
+ * return value !== null && typeof value === 'object' && value.__proto__ === Object.prototype;
+
+ * Notably jQuery and lodash have very similar implementations.
+
+ * For later, remember the `value === Object(value)` trick
+ */
+
+module.exports = function (value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  let proto = Object.getPrototypeOf(value);
+  return !proto || proto === Object.prototype;
+};
--- a/node_modules/@11ty/eleventy-utils/src/Merge.js
+++ b/node_modules/@11ty/eleventy-utils/src/Merge.js
@@ -0,0 +1,84 @@
+"use strict";
+// above is required for Object.freeze to fail correctly.
+
+const isPlainObject = require("./IsPlainObject.js");
+
+const OVERRIDE_PREFIX = "override:";
+
+function cleanKey(key, prefix) {
+	if (prefix && key.startsWith(prefix)) {
+		return key.slice(prefix.length);
+	}
+	return key;
+}
+
+function getMergedItem(target, source, prefixes = {}) {
+	let { override } = prefixes;
+
+	// Shortcut for frozen source (if target does not exist)
+	if (!target && isPlainObject(source) && Object.isFrozen(source)) {
+		return source;
+	}
+
+	let sourcePlainObjectShortcut;
+	if (!target && isPlainObject(source)) {
+		// deep copy objects to avoid sharing and to effect key renaming
+		target = {};
+		sourcePlainObjectShortcut = true;
+	}
+
+	if (Array.isArray(target) && Array.isArray(source)) {
+		return target.concat(source);
+	} else if (isPlainObject(target)) {
+		if (sourcePlainObjectShortcut || isPlainObject(source)) {
+			for (let key in source) {
+				let overrideKey = cleanKey(key, override);
+
+				// An error happens here if the target is frozen
+				target[overrideKey] = getMergedItem(target[key], source[key], prefixes);
+			}
+		}
+		return target;
+	}
+	// number, string, class instance, etc
+	return source;
+}
+
+// The same as Merge but without override prefixes
+function DeepCopy(targetObject, ...sources) {
+	for (let source of sources) {
+		if (!source) {
+			continue;
+		}
+
+		targetObject = getMergedItem(targetObject, source);
+	}
+	return targetObject;
+}
+
+function Merge(target, ...sources) {
+	// Remove override prefixes from root target.
+	if (isPlainObject(target)) {
+		for (let key in target) {
+			if (key.indexOf(OVERRIDE_PREFIX) === 0) {
+				target[key.slice(OVERRIDE_PREFIX.length)] = target[key];
+				delete target[key];
+			}
+		}
+	}
+
+	for (let source of sources) {
+		if (!source) {
+			continue;
+		}
+
+		target = getMergedItem(target, source, {
+			override: OVERRIDE_PREFIX,
+		});
+	}
+
+	return target;
+}
+
+module.exports = Merge;
+module.exports.DeepCopy = DeepCopy;
--- a/node_modules/@11ty/eleventy-utils/src/TemplatePath.js
+++ b/node_modules/@11ty/eleventy-utils/src/TemplatePath.js
@@ -0,0 +1,373 @@
+const path = require("path");
+const fs = require("fs");
+
+function TemplatePath() {}
+
+/**
+ * @returns {String} the absolute path to Eleventy’s project directory.
+ */
+TemplatePath.getWorkingDir = function () {
+  return TemplatePath.normalize(path.resolve("."));
+};
+
+/**
+ * Returns the directory portion of a path.
+ * Works for directory and file paths and paths ending in a glob pattern.
+ *
+ * @param {String} path - A path
+ * @returns {String} the directory portion of a path.
+ */
+TemplatePath.getDir = function (path) {
+  if (TemplatePath.isDirectorySync(path)) {
+    return path;
+  }
+
+  return TemplatePath.getDirFromFilePath(path);
+};
+
+/**
+ * Returns the directory portion of a path that either points to a file
+ * or ends in a glob pattern. If `path` points to a directory,
+ * the returned value will have its last path segment stripped
+ * due to how [`path.parse`][1] works.
+ *
+ * [1]: https://nodejs.org/api/path.html#path_path_parse_path
+ *
+ * @returns {String} the directory portion of a path.
+ * @param {String} filePath - A path
+ */
+TemplatePath.getDirFromFilePath = function (filePath) {
+  return path.parse(filePath).dir || ".";
+};
+
+/**
+ * Returns the last path segment in a path (no leading/trailing slashes).
+ *
+ * Assumes [`path.parse`][1] was called on `path` before.
+ *
+ * [1]: https://nodejs.org/api/path.html#path_path_parse_path
+ *
+ * @param {String} path - A path
+ * @returns {String} the last path segment in a path
+ */
+TemplatePath.getLastPathSegment = function (path) {
+  if (!path.includes("/")) {
+    return path;
+  }
+
+  // Trim a trailing slash if there is one
+  path = path.replace(/\/$/, "");
+
+  return path.slice(path.lastIndexOf("/") + 1);
+};
+
+/**
+ * @param {String} path - A path
+ * @returns {String[]} an array of paths pointing to each path segment of the
+ * provided `path`.
+ */
+TemplatePath.getAllDirs = function (path) {
+  // Trim a trailing slash if there is one
+  path = path.replace(/\/$/, "");
+
+  if (!path.includes("/")) {
+    return [path];
+  }
+
+  return path
+    .split("/")
+    .map((segment, index, array) => array.slice(0, index + 1).join("/"))
+    .filter((path) => path !== ".")
+    .reverse();
+};
+
+/**
+ * Normalizes a path, resolving single-dot and double-dot segments.
+ *
+ * Node.js’ [`path.normalize`][1] is called to strip a possible leading `"./"` segment.
+ *
+ * [1]: https://nodejs.org/api/path.html#path_path_normalize_path
+ *
+ * @param {String} thePath - The path that should be normalized.
+ * @returns {String} the normalized path.
+ */
+TemplatePath.normalize = function (thePath) {
+  let filePath = path.normalize(thePath).split(path.sep).join("/");
+  if(filePath !== "/" && filePath.endsWith("/")) {
+    return filePath.slice(0, -1);
+  }
+  return filePath;
+};
+
+/**
+ * Joins all given path segments together.
+ *
+ * It uses Node.js’ [`path.join`][1] method.
+ *
+ * [1]: https://nodejs.org/api/path.html#path_path_join_paths
+ *
+ * @param {...String} paths - An arbitrary amount of path segments.
+ * @returns {String} the normalized and joined path.
+ */
+TemplatePath.join = function (...paths) {
+  return TemplatePath.normalize(path.join(...paths));
+};
+
+/**
+ * Joins the given URL path segments and normalizes the resulting path.
+ * Maintains a single trailing slash if the last URL path argument
+ * had at least one.
+ *
+ * @param {...String} urlPaths
+ * @returns {String} a normalized URL path described by the given URL path segments.
+ */
+TemplatePath.normalizeUrlPath = function (...urlPaths) {
+  const urlPath = path.posix.join(...urlPaths);
+  return urlPath.replace(/\/+$/, "/");
+};
+
+/**
+ * Joins the given path segments. Since the first path is absolute,
+ * the resulting path will be absolute as well.
+ *
+ * @param {...String} paths
+ * @returns {String} the absolute path described by the given path segments.
+ */
+TemplatePath.absolutePath = function (...paths) {
+  let i = 0;
+  // check all the paths before we short circuit from the first index
+  for (let p of paths) {
+    if (path.isAbsolute(p) && i > 0) {
+      throw new Error(
+        `Only the first parameter to Template.absolutePath can be an absolute path. Received: ${p} from ${paths}`
+      );
+    }
+    i++;
+  }
+
+  let j = 0;
+  for (let p of paths) {
+    if (j === 0 && path.isAbsolute(p)) {
+      return TemplatePath.join(...paths);
+    }
+    j++;
+  }
+
+  return TemplatePath.join(TemplatePath.getWorkingDir(), ...paths);
+};
+
+/**
+ * Turns an absolute path into a path relative to the project directory.
+ *
+ * @param {String} absolutePath
+ * @returns {String} the relative path.
+ */
+TemplatePath.relativePath = function (absolutePath) {
+  return TemplatePath.stripLeadingSubPath(
+    absolutePath,
+    TemplatePath.getWorkingDir()
+  );
+};
+
+/**
+ * Adds a leading dot-slash segment to each path in the `paths` array.
+ *
+ * @param {String[]} paths
+ * @returns {String[]}
+ */
+TemplatePath.addLeadingDotSlashArray = function (paths) {
+  return paths.map((path) => TemplatePath.addLeadingDotSlash(path));
+};
+
+/**
+ * Adds a leading dot-slash segment to `path`.
+ *
+ * @param {String} pathArg
+ * @returns {String}
+ */
+TemplatePath.addLeadingDotSlash = function (pathArg) {
+  if (pathArg === "." || pathArg === "..") {
+    return pathArg + "/";
+  }
+
+  if (
+    path.isAbsolute(pathArg) ||
+    pathArg.startsWith("./") ||
+    pathArg.startsWith("../")
+  ) {
+    return pathArg;
+  }
+
+  return "./" + pathArg;
+};
+
+/**
+ * Removes a leading dot-slash segment.
+ *
+ * @param {String} path
+ * @returns {String} the `path` without a leading dot-slash segment.
+ */
+TemplatePath.stripLeadingDotSlash = function (path) {
+  return typeof path === "string" ? path.replace(/^\.\//, "") : path;
+};
+
+/**
+ * Determines whether a path starts with a given sub path.
+ *
+ * @param {String} path - A path
+ * @param {String} subPath - A path
+ * @returns {Boolean} whether `path` starts with `subPath`.
+ */
+TemplatePath.startsWithSubPath = function (path, subPath) {
+  path = TemplatePath.normalize(path);
+  subPath = TemplatePath.normalize(subPath);
+
+  return path.startsWith(subPath);
+};
+
+/**
+ * Removes the `subPath` at the start of `path` if present
+ * and returns the remainding path.
+ *
+ * @param {String} path - A path
+ * @param {String} subPath - A path
+ * @returns {String} the `path` without `subPath` at the start of it.
+ */
+TemplatePath.stripLeadingSubPath = function (path, subPath) {
+  path = TemplatePath.normalize(path);
+  subPath = TemplatePath.normalize(subPath);
+
+  if (subPath !== "." && path.startsWith(subPath)) {
+    return path.slice(subPath.length + 1);
+  }
+
+  return path;
+};
+
+/**
+ * @param {String} path - A path
+ * @returns {Boolean} whether `path` points to an existing directory.
+ */
+TemplatePath.isDirectorySync = function (path) {
+  return fs.existsSync(path) && fs.statSync(path).isDirectory();
+};
+
+/**
+ * @param {String} path - A path
+ * @returns {Boolean} whether `path` points to an existing directory.
+ */
+TemplatePath.isDirectory = async function (path) {
+  return new Promise((resolve) => {
+    fs.stat(path, (err, stats) => {
+      if (stats) {
+        resolve(stats.isDirectory());
+      }
+      resolve(false);
+    });
+  });
+};
+
+/**
+ * Appends a recursive wildcard glob pattern to `path`
+ * unless `path` is not a directory; then, `path` is assumed to be a file path
+ * and is left unchaged.
+ *
+ * @param {String} path
+ * @returns {String}
+ */
+TemplatePath.convertToRecursiveGlobSync = function (path) {
+  if (path === "") {
+    return "./**";
+  }
+
+  path = TemplatePath.addLeadingDotSlash(path);
+
+  if (TemplatePath.isDirectorySync(path)) {
+    return path + (!path.endsWith("/") ? "/" : "") + "**";
+  }
+
+  return path;
+};
+
+/**
+ * Appends a recursive wildcard glob pattern to `path`
+ * unless `path` is not a directory; then, `path` is assumed to be a file path
+ * and is left unchaged.
+ *
+ * @param {String} path
+ * @returns {String}
+ */
+TemplatePath.convertToRecursiveGlob = async function (path) {
+  if (path === "") {
+    return "./**";
+  }
+
+  path = TemplatePath.addLeadingDotSlash(path);
+
+  if (await TemplatePath.isDirectory(path)) {
+    return path + (!path.endsWith("/") ? "/" : "") + "**";
+  }
+
+  return path;
+};
+
+/**
+ * Returns the extension of the path without the leading dot.
+ * If the path has no extensions, the empty string is returned.
+ *
+ * @param {String} thePath
+ * @returns {String} the path’s extension if it exists;
+ * otherwise, the empty string.
+ */
+TemplatePath.getExtension = function (thePath) {
+  return path.extname(thePath).replace(/^\./, "");
+};
+
+/**
+ * Removes the extension from a path.
+ *
+ * @param {String} path
+ * @param {String} [extension]
+ * @returns {String}
+ */
+TemplatePath.removeExtension = function (path, extension = undefined) {
+  if (extension === undefined) {
+    return path;
+  }
+
+  const pathExtension = TemplatePath.getExtension(path);
+  if (pathExtension !== "" && extension.endsWith(pathExtension)) {
+    return path.substring(0, path.lastIndexOf(pathExtension) - 1);
+  }
+
+  return path;
+};
+
+/**
+ * Accepts a relative file path that is using a standard directory separator and
+ * normalizes it using the local operating system separator.
+ * e.g. `./my/dir/` stays `./my/dir/` on *nix and becomes `.\\my\\dir\\` on Windows
+ *
+ * @param {String} filePath
+ * @param {String} [sep="/"]
+ * @returns {String} a file path with the correct local directory separator.
+ */
+TemplatePath.normalizeOperatingSystemFilePath = function (filePath, sep = "/") {
+  return filePath.split(sep).join(path.sep);
+};
+
+/**
+ * Accepts a relative file path with the local operating system directory separator and
+ * normalizes it using a forward slash directory separator. (Leaves trailing slash as-is)
+ * e.g. `./my/dir/` stays `./my/dir/` on *nix
+ * e.g. `.\\my\\dir\\` becomes `./my/dir/` on *nix and Windows
+ *
+ * @param {String} filePath
+ * @param {String} [sep="/"]
+ * @returns {String} a file path with the correct local directory separator.
+ */
+TemplatePath.standardizeFilePath = function (filePath, sep = "/") {
+  return TemplatePath.addLeadingDotSlash(filePath.split(path.sep).join(sep));
+};
+
+module.exports = TemplatePath;
--- a/node_modules/@11ty/eleventy-utils/src/Url.js
+++ b/node_modules/@11ty/eleventy-utils/src/Url.js
@@ -0,0 +1,13 @@
+function base64UrlSafe(hashString = "") {
+	return hashString.replace(/[=\+\/]/g, function(match) {
+		if(match === "=") {
+			return "";
+		}
+		if(match === "+") {
+			return "-";
+		}
+		return "_";
+	});
+}
+
+module.exports = { base64UrlSafe };
--- a/node_modules/@11ty/eleventy-utils/src/lib-sha256.js
+++ b/node_modules/@11ty/eleventy-utils/src/lib-sha256.js
@@ -0,0 +1,113 @@
+// https://github.com/6502/sha256
+
+/*
+Copyright 2022 Andrea Griffini
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+// sha256(data) returns the digest
+// sha256() returns an object you can call .add(data) zero or more time and .digest() at the end
+// digest is a 32-byte Uint8Array instance with an added .hex() function.
+// Input should be either a string (that will be encoded as UTF-8) or an array-like object with values 0..255.
+module.exports = function sha256(data) {
+    let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a,
+        h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19,
+        tsz = 0, bp = 0;
+    const 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],
+          rrot = (x, n) => (x >>> n) | (x << (32-n)),
+          w = new Uint32Array(64),
+          buf = new Uint8Array(64),
+          process = () => {
+              for (let j=0,r=0; j<16; j++,r+=4) {
+                  w[j] = (buf[r]<<24) | (buf[r+1]<<16) | (buf[r+2]<<8) | buf[r+3];
+              }
+              for (let j=16; j<64; j++) {
+                  let s0 = rrot(w[j-15], 7) ^ rrot(w[j-15], 18) ^ (w[j-15] >>> 3);
+                  let s1 = rrot(w[j-2], 17) ^ rrot(w[j-2], 19) ^ (w[j-2] >>> 10);
+                  w[j] = (w[j-16] + s0 + w[j-7] + s1) | 0;
+              }
+              let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7;
+              for (let j=0; j<64; j++) {
+                  let S1 = rrot(e, 6) ^ rrot(e, 11) ^ rrot(e, 25),
+                      ch = (e & f) ^ ((~e) & g),
+                      t1 = (h + S1 + ch + k[j] + w[j]) | 0,
+                      S0 = rrot(a, 2) ^ rrot(a, 13) ^ rrot(a, 22),
+                      maj = (a & b) ^ (a & c) ^ (b & c),
+                      t2 = (S0 + maj) | 0;
+                  h = g; g = f; f = e; e = (d + t1)|0; d = c; c = b; b = a; a = (t1 + t2)|0;
+              }
+              h0 = (h0 + a)|0; h1 = (h1 + b)|0; h2 = (h2 + c)|0; h3 = (h3 + d)|0;
+              h4 = (h4 + e)|0; h5 = (h5 + f)|0; h6 = (h6 + g)|0; h7 = (h7 + h)|0;
+              bp = 0;
+          },
+          add = data => {
+              if (typeof data === "string") {
+                  data = typeof TextEncoder === "undefined" ? Buffer.from(data) : (new TextEncoder).encode(data);
+              }
+              for (let i=0; i<data.length; i++) {
+                  buf[bp++] = data[i];
+                  if (bp === 64) process();
+              }
+              tsz += data.length;
+          },
+          digest = () => {
+              buf[bp++] = 0x80; if (bp == 64) process();
+              if (bp + 8 > 64) {
+                  while (bp < 64) buf[bp++] = 0x00;
+                  process();
+              }
+              while (bp < 58) buf[bp++] = 0x00;
+              // Max number of bytes is 35,184,372,088,831
+              let L = tsz * 8;
+              buf[bp++] = (L / 1099511627776.) & 255;
+              buf[bp++] = (L / 4294967296.) & 255;
+              buf[bp++] = L >>> 24;
+              buf[bp++] = (L >>> 16) & 255;
+              buf[bp++] = (L >>> 8) & 255;
+              buf[bp++] = L & 255;
+              process();
+              let reply = new Uint8Array(32);
+              reply[ 0] = h0 >>> 24; reply[ 1] = (h0 >>> 16) & 255; reply[ 2] = (h0 >>> 8) & 255; reply[ 3] = h0 & 255;
+              reply[ 4] = h1 >>> 24; reply[ 5] = (h1 >>> 16) & 255; reply[ 6] = (h1 >>> 8) & 255; reply[ 7] = h1 & 255;
+              reply[ 8] = h2 >>> 24; reply[ 9] = (h2 >>> 16) & 255; reply[10] = (h2 >>> 8) & 255; reply[11] = h2 & 255;
+              reply[12] = h3 >>> 24; reply[13] = (h3 >>> 16) & 255; reply[14] = (h3 >>> 8) & 255; reply[15] = h3 & 255;
+              reply[16] = h4 >>> 24; reply[17] = (h4 >>> 16) & 255; reply[18] = (h4 >>> 8) & 255; reply[19] = h4 & 255;
+              reply[20] = h5 >>> 24; reply[21] = (h5 >>> 16) & 255; reply[22] = (h5 >>> 8) & 255; reply[23] = h5 & 255;
+              reply[24] = h6 >>> 24; reply[25] = (h6 >>> 16) & 255; reply[26] = (h6 >>> 8) & 255; reply[27] = h6 & 255;
+              reply[28] = h7 >>> 24; reply[29] = (h7 >>> 16) & 255; reply[30] = (h7 >>> 8) & 255; reply[31] = h7 & 255;
+              reply.hex = () => {
+                  let res = "";
+                  reply.forEach(x => res += ("0" + x.toString(16)).slice(-2));
+                  return res;
+              };
+              return reply;
+          };
+    if (data === undefined) return {add, digest};
+    add(data);
+    return digest();
+}