mailschema 0.2.2 → 0.3.0

package/dist/core/implementation.d.ts

@@ -0,0 +1,32 @@
+export interface ImplementationRecord {
+    service: string;
+    maintainer: {
+        name: string;
+        url: string;
+    };
+    type: {
+        id: string;
+        version: string;
+        contractDigest: string;
+    };
+    operations: string[];
+    binding: string;
+    artifact?: {
+        url: string;
+        digest: string;
+        digestMode: 'canonical-json' | 'bytes';
+    };
+    format?: string;
+    status: 'Draft' | 'Experimental' | 'Stable' | 'Deprecated' | 'Superseded';
+    documentation: string;
+    evidence: {
+        kind: 'declaration' | 'test-report';
+        url: string;
+        summary: string;
+    }[];
+    successor?: string;
+}
+/** Why the value is not an implementation record, or no reasons. */
+export declare function implementationErrors(value: unknown): string[];
+/** The record in the bytes or text, or InvalidDocument with every reason it is not one. */
+export declare function parseImplementation(input: string | Uint8Array): ImplementationRecord;

package/dist/core/implementation.js

@@ -0,0 +1,25 @@
+// An implementation record: a Registry declaration or report of a service's support for exact
+// contract versions.
+import { CONTRACT_MAX_BYTES, createValidator, implementationSchema, schemaErrors, } from "./artifacts.js";
+import { InvalidDocument, parse } from "./json.js";
+const validate = createValidator().compile(implementationSchema);
+/** Why the value is not an implementation record, or no reasons. */
+export function implementationErrors(value) {
+    if (!validate(value))
+        return schemaErrors(validate.errors);
+    const errors = [];
+    const { origin } = new URL(value.service);
+    if (value.service !== origin && value.service !== `${origin}/`)
+        errors.push('/service: must be an HTTPS origin, not an operation path');
+    if (new Set(value.operations).size !== value.operations.length)
+        errors.push('/operations: identifiers must be unique');
+    return errors;
+}
+/** The record in the bytes or text, or InvalidDocument with every reason it is not one. */
+export function parseImplementation(input) {
+    const value = parse(input, CONTRACT_MAX_BYTES);
+    const errors = implementationErrors(value);
+    if (errors.length)
+        throw new InvalidDocument('The value is not an implementation record.', errors);
+    return value;
+}

package/dist/core/index.d.ts

@@ -1,6 +1,7 @@
-export { MAP_PROFILE, CORE_SCHEMA, FORMS_SCHEMA, CONTRACT_FORMAT, CONTEXT, mapErrors, descriptionErrors, requestErrors, resultErrors, problemErrors, isRequestId, reached, } from './artifacts.ts';
-export { InvalidDocument, parse, canonicalize, digest } from './document.ts';
-export { APPROVAL_REASONS, Contract, InvalidContract, type RequestProblem } from './contract.ts';
-export { PROBLEM_STATUS, type ProblemCode, result, transition, problem, resultStatus, retainUntil, settle, } from './documents.ts';
-export { DESCRIPTION_MEDIA_TYPE, isDescriptionPart, capability, writtenPath, isJsonRequest, resultUrl, } from './binding.ts';
-export type { Authority, Consequence, ContractOperation, InputError, JsonObject, MapDescription, MapProblem, MapRequest, MapResult, ResultState, SchemaReference, Target, TypeContract, TypeReference, } from './types.ts';
+export { PROFILE, CONTEXT, DESCRIPTION_MEDIA_TYPE, DESCRIPTION_MAX_BYTES, CONTRACT_MAX_BYTES, EFFECTS, FORMATS, coreSchema, contractSchema, implementationSchema, } from './artifacts.ts';
+export { InvalidDocument, MAX_DEPTH, decodeUtf8, parse, canonicalize, digest } from './json.ts';
+export { sha256 } from './sha256.ts';
+export { descriptionErrors, parseDescription, type Description } from './description.ts';
+export { CAPABILITY_KINDS, Contract, contractErrors, type CapabilityKind, type ContractDocument, type Operation, } from './contract.ts';
+export { implementationErrors, parseImplementation, type ImplementationRecord, } from './implementation.ts';
+export { unportablePattern } from './patterns.ts';

package/dist/core/index.js

@@ -1,9 +1,9 @@
-// Mail Action Protocol 0.2 processing. It parses, canonicalizes, digests and validates MAP
-// documents, checks the type contracts an implementation vendors, and builds results and
-// problems. It does not establish endpoint trust, verify email authentication, grant
-// authority or send email.
-export { MAP_PROFILE, CORE_SCHEMA, FORMS_SCHEMA, CONTRACT_FORMAT, CONTEXT, mapErrors, descriptionErrors, requestErrors, resultErrors, problemErrors, isRequestId, reached, } from "./artifacts.js";
-export { InvalidDocument, parse, canonicalize, digest } from "./document.js";
-export { APPROVAL_REASONS, Contract, InvalidContract } from "./contract.js";
-export { PROBLEM_STATUS, result, transition, problem, resultStatus, retainUntil, settle, } from "./documents.js";
-export { DESCRIPTION_MEDIA_TYPE, isDescriptionPart, capability, writtenPath, isJsonRequest, resultUrl, } from "./binding.js";
+// Mail Action Protocol 0.3 processing: one implementation, run unchanged by the repository's
+// site and checks and shipped as the npm package.
+export { PROFILE, CONTEXT, DESCRIPTION_MEDIA_TYPE, DESCRIPTION_MAX_BYTES, CONTRACT_MAX_BYTES, EFFECTS, FORMATS, coreSchema, contractSchema, implementationSchema, } from "./artifacts.js";
+export { InvalidDocument, MAX_DEPTH, decodeUtf8, parse, canonicalize, digest } from "./json.js";
+export { sha256 } from "./sha256.js";
+export { descriptionErrors, parseDescription } from "./description.js";
+export { CAPABILITY_KINDS, Contract, contractErrors, } from "./contract.js";
+export { implementationErrors, parseImplementation, } from "./implementation.js";
+export { unportablePattern } from "./patterns.js";

package/dist/core/json.d.ts

@@ -0,0 +1,23 @@
+/** A document that is not MAP JSON, or not the document it claims to be. */
+export declare class InvalidDocument extends Error {
+    readonly errors: string[];
+    constructor(message: string, errors?: string[]);
+}
+export declare const MAX_DEPTH = 32;
+/** The bytes as text, refusing anything but well-formed UTF-8. */
+export declare function decodeUtf8(input: Uint8Array): string;
+/**
+ * Parse MAP JSON from its original text: UTF-8 I-JSON (RFC 7493) of at most `maxBytes`, with
+ * no byte order mark, duplicate member names, lone surrogates, noncharacters or U+0000, no
+ * container deeper than 32 counting the root as 1, and every number a finite token of at most
+ * 64 characters within ±(2^53−1) that does not underflow to zero. These rules apply to the
+ * original tokens, before a general parser could erase them.
+ */
+export declare function parse(input: string | Uint8Array, maxBytes: number): unknown;
+/**
+ * The RFC 8785 canonical form of a JSON value: members sorted by their UTF-16 code units,
+ * ECMAScript's minimal string escapes and its number format.
+ */
+export declare function canonicalize(value: unknown): string;
+/** `sha-256:` and the SHA-256 of the value's RFC 8785 form, as MAP identifies contracts. */
+export declare const digest: (value: unknown) => string;

package/dist/core/{document.js → json.js}

@@ -1,38 +1,46 @@
-// Parsing MAP documents as I-JSON within the core limits.
-import { createHash } from 'node:crypto';
-/** A MAP document that is not I-JSON within the core limits. */
+// MAP JSON: I-JSON parsed from its original text, and the RFC 8785 digests that identify
+// contracts and descriptions.
+import { sha256 } from "./sha256.js";
+/** A document that is not MAP JSON, or not the document it claims to be. */
 export class InvalidDocument extends Error {
+    errors;
+    constructor(message, errors = [message]) {
+        super(message);
+        this.errors = errors;
+    }
 }
-export const MAX_BYTES = 64 * 1024;
 export const MAX_DEPTH = 32;
+const MAX_NUMBER_TOKEN = 64;
 const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
-// Unicode's noncharacters: U+FDD0 to U+FDEF, and the last two code points of every plane.
-const NONCHARACTER = new RegExp(`[\\u{FDD0}-\\u{FDEF}${Array.from({ length: 17 }, (_, plane) => `\\u{${(plane * 0x10000 + 0xfffe).toString(16)}}\\u{${(plane * 0x10000 + 0xffff).toString(16)}}`).join('')}]`, 'u');
+const NUMBER = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/;
+const ZERO = /^-?0(?:\.0+)?(?:[eE][+-]?[0-9]+)?$/;
+const forbidden = (point) => point === 0 || (point >= 0xfdd0 && point <= 0xfdef) || (point & 0xfffe) === 0xfffe;
+/** The bytes as text, refusing anything but well-formed UTF-8. */
+export function decodeUtf8(input) {
+    try {
+        // The byte order mark is kept, so parsing refuses it.
+        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(input);
+    }
+    catch {
+        throw new InvalidDocument('The JSON is not valid UTF-8.');
+    }
+}
 /**
- * Parse a MAP document as I-JSON (RFC 7493) within the core limits: valid UTF-8 with no
- * byte order mark, at most 64 KiB, no duplicate member names, no lone surrogates,
- * noncharacters or U+0000 in any string, every number within ±(2^53−1), and arrays and
- * objects nested at most 32 deep, the outermost counting as one. Text is measured in its
- * UTF-8 bytes; bytes must be strict UTF-8.
+ * Parse MAP JSON from its original text: UTF-8 I-JSON (RFC 7493) of at most `maxBytes`, with
+ * no byte order mark, duplicate member names, lone surrogates, noncharacters or U+0000, no
+ * container deeper than 32 counting the root as 1, and every number a finite token of at most
+ * 64 characters within ±(2^53−1) that does not underflow to zero. These rules apply to the
+ * original tokens, before a general parser could erase them.
  */
-export function parse(input) {
-    let text;
-    if (typeof input === 'string')
-        text = input;
-    else {
-        try {
-            // The byte order mark is kept, so the parser refuses it.
-            text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(input);
-        }
-        catch {
-            throw new InvalidDocument('The MAP document is not valid UTF-8.');
-        }
-    }
-    if (new TextEncoder().encode(text).length > MAX_BYTES)
-        throw new InvalidDocument(`The MAP document exceeds ${MAX_BYTES} bytes.`);
+export function parse(input, maxBytes) {
+    const text = typeof input === 'string' ? input : decodeUtf8(input);
+    if (text.charCodeAt(0) === 0xfeff)
+        throw new InvalidDocument('A byte order mark is not allowed.');
+    if (new TextEncoder().encode(text).length > maxBytes)
+        throw new InvalidDocument(`The JSON exceeds ${maxBytes} bytes.`);
     let index = 0;
-    const fail = (message) => {
-        throw new InvalidDocument(`Invalid MAP JSON at offset ${index}: ${message}`);
+    const fail = (reason) => {
+        throw new InvalidDocument(`Invalid MAP JSON at offset ${index}: ${reason}.`);
     };
     const space = () => {
         while (' \t\n\r'.includes(text[index] ?? '-'))
@@ -55,13 +63,12 @@ export function parse(input) {
         }
         if (LONE_SURROGATE.test(value))
             fail('lone surrogate');
-        if (value.includes('\u0000'))
-            fail('U+0000 in a string');
-        if (NONCHARACTER.test(value))
-            fail('a noncharacter in a string');
+        for (const character of value)
+            if (forbidden(character.codePointAt(0)))
+                fail('U+0000 or a noncharacter');
         return value;
     };
-    // `depth` counts the arrays and objects enclosing the value.
+    // `depth` counts the containers enclosing the value.
     const value = (depth) => {
         space();
         const next = text[index];
@@ -131,15 +138,23 @@ export function parse(input) {
         }
         if (next === '"')
             return string();
-        const literal = /^(?:true|false|null|-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?)/.exec(text.slice(index));
-        if (!literal)
-            fail('unexpected token');
-        index += literal[0].length;
-        const parsed = JSON.parse(literal[0]);
-        if (typeof parsed === 'number' &&
-            (!Number.isFinite(parsed) || Math.abs(parsed) > Number.MAX_SAFE_INTEGER))
-            fail('number outside the I-JSON range');
-        return parsed;
+        for (const literal of ['true', 'false', 'null'])
+            if (text.startsWith(literal, index)) {
+                index += literal.length;
+                return JSON.parse(literal);
+            }
+        const token = NUMBER.exec(text.slice(index))?.[0];
+        if (token === undefined)
+            return fail('unexpected token');
+        index += token.length;
+        if (token.length > MAX_NUMBER_TOKEN)
+            fail(`a number token longer than ${MAX_NUMBER_TOKEN} characters`);
+        const number = Number(token);
+        if (!Number.isFinite(number) || Math.abs(number) > Number.MAX_SAFE_INTEGER)
+            fail('a number outside the I-JSON range');
+        if (number === 0 && !ZERO.test(token))
+            fail('a number that underflows to zero');
+        return number;
     };
     const result = value(0);
     space();
@@ -158,8 +173,7 @@ const ESCAPES = {
 };
 /**
  * The RFC 8785 canonical form of a JSON value: members sorted by their UTF-16 code units,
- * ECMAScript's minimal string escapes and its number format. An undefined member is
- * left out and an undefined array item is null, as JSON.stringify writes them.
+ * ECMAScript's minimal string escapes and its number format.
  */
 export function canonicalize(value) {
     if (value === null || typeof value === 'boolean')
@@ -172,19 +186,15 @@ export function canonicalize(value) {
     if (typeof value === 'string')
         return `"${value.replace(/["\\\u0000-\u001f]/g, (char) => ESCAPES[char] ?? `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`)}"`;
     if (Array.isArray(value))
-        return `[${value.map((item) => (item === undefined ? 'null' : canonicalize(item))).join(',')}]`;
+        return `[${value.map(canonicalize).join(',')}]`;
     if (typeof value === 'object') {
         const members = value;
         return `{${Object.keys(members)
-            .filter((name) => members[name] !== undefined)
             .sort()
             .map((name) => `${canonicalize(name)}:${canonicalize(members[name])}`)
             .join(',')}}`;
     }
     throw new TypeError(`${typeof value} is not a JSON value.`);
 }
-/**
- * `sha-256:` and the SHA-256 of the RFC 8785 canonical form: the digest MAP uses for
- * descriptions, contracts and pinned schemas.
- */
-export const digest = (value) => `sha-256:${createHash('sha256').update(canonicalize(value)).digest('hex')}`;
+/** `sha-256:` and the SHA-256 of the value's RFC 8785 form, as MAP identifies contracts. */
+export const digest = (value) => `sha-256:${sha256(canonicalize(value))}`;

package/dist/core/patterns.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Why a pattern is outside the portable subset, or undefined. The subset is printable ASCII
+ * text, with any other code point written as \uXXXX. It has literal characters and escaped
+ * syntax characters; \t, \n, \f, \r and \d, the ASCII digits; non-empty classes of literal or
+ * escaped members and ranges, with a literal hyphen only first or last; (?: groups;
+ * alternation; ^ and $; and one *, +, ?, {n}, {n,} or {n,m} after an atom. Other class
+ * escapes and the dot match different characters in different engines, and brackets, && or a
+ * stray brace inside a class, or a quantifier on a quantifier, are read differently or refused
+ * by one of them. ^ and $ anchor the whole value, as in ECMA-262; an engine whose anchors also
+ * match at line breaks must read them so.
+ */
+export declare function unportablePattern(pattern: string): string | undefined;

package/dist/core/patterns.js

@@ -0,0 +1,165 @@
+// The regular expressions a contract's schemas may use: the subset that ECMA-262 (with the
+// u flag) and other engines read alike, so every implementation enforces the same contract.
+const SYNTAX_CHARACTERS = '^$\\.*+?()[]{}|/';
+const CONTROL_ESCAPES = { t: 0x09, n: 0x0a, f: 0x0c, r: 0x0d };
+const QUANTIFIERS = '*+?{';
+/**
+ * Why a pattern is outside the portable subset, or undefined. The subset is printable ASCII
+ * text, with any other code point written as \uXXXX. It has literal characters and escaped
+ * syntax characters; \t, \n, \f, \r and \d, the ASCII digits; non-empty classes of literal or
+ * escaped members and ranges, with a literal hyphen only first or last; (?: groups;
+ * alternation; ^ and $; and one *, +, ?, {n}, {n,} or {n,m} after an atom. Other class
+ * escapes and the dot match different characters in different engines, and brackets, && or a
+ * stray brace inside a class, or a quantifier on a quantifier, are read differently or refused
+ * by one of them. ^ and $ anchor the whole value, as in ECMA-262; an engine whose anchors also
+ * match at line breaks must read them so.
+ */
+export function unportablePattern(pattern) {
+    if (!/^[\x20-\x7e]*$/.test(pattern))
+        return 'a character outside printable ASCII';
+    let at = 0;
+    // One escaped code point, the digit class outside a class, or a problem.
+    const escape = (inClass) => {
+        const next = pattern[at + 1];
+        if (next === undefined)
+            return 'a trailing backslash';
+        if (next === 'u') {
+            const digits = pattern.slice(at + 2, at + 6);
+            if (!/^[0-9a-fA-F]{4}$/.test(digits))
+                return 'a malformed \\u escape';
+            const code = parseInt(digits, 16);
+            if (code >= 0xd800 && code <= 0xdfff)
+                return 'a surrogate \\u escape';
+            at += 6;
+            return code;
+        }
+        at += 2;
+        if (next === 'd' && !inClass)
+            return -1;
+        if (Object.hasOwn(CONTROL_ESCAPES, next))
+            return CONTROL_ESCAPES[next];
+        if (SYNTAX_CHARACTERS.includes(next) || (inClass && next === '-'))
+            return next.charCodeAt(0);
+        return `the escape \\${next}`;
+    };
+    const characterClass = () => {
+        at += pattern[at + 1] === '^' ? 2 : 1;
+        // Each member's code point, or null for an unescaped hyphen.
+        const members = [];
+        while (pattern[at] !== ']') {
+            const char = pattern[at];
+            if (char === undefined)
+                return 'an unclosed character class';
+            if (char === '[')
+                return 'a bracket inside a class';
+            if (char === '&' && pattern[at + 1] === '&')
+                return '&& inside a class';
+            if (char === '\\') {
+                const code = escape(true);
+                if (typeof code === 'string')
+                    return code;
+                members.push(code);
+            }
+            else {
+                members.push(char === '-' ? null : char.charCodeAt(0));
+                at += 1;
+            }
+        }
+        at += 1;
+        if (!members.length)
+            return 'an empty character class';
+        for (let index = 0; index < members.length; index += 1) {
+            const low = members[index];
+            if (low === null) {
+                if (index !== 0 && index !== members.length - 1)
+                    return 'an ambiguous hyphen in a class';
+                continue;
+            }
+            if (members[index + 1] !== null || index + 2 >= members.length)
+                continue;
+            const high = members[index + 2];
+            if (high === null)
+                return 'an ambiguous hyphen in a class';
+            if (high < low)
+                return 'a class range out of order';
+            index += 2;
+            if (members[index + 1] === null && index + 1 !== members.length - 1)
+                return 'an ambiguous hyphen in a class';
+        }
+    };
+    const quantifier = () => {
+        if (pattern[at] === '{') {
+            const bounds = /^\{([0-9]{1,4})(?:(,)([0-9]{1,4})?)?\}/.exec(pattern.slice(at));
+            if (!bounds)
+                return 'a malformed {n,m} quantifier';
+            if (bounds[3] !== undefined && Number(bounds[3]) < Number(bounds[1]))
+                return 'a {n,m} quantifier with m below n';
+            at += bounds[0].length;
+        }
+        else
+            at += 1;
+        const next = pattern[at];
+        if (next !== undefined && QUANTIFIERS.includes(next))
+            return 'a quantifier on a quantifier';
+    };
+    const disjunction = (depth) => {
+        let quantifiable = false;
+        while (at < pattern.length) {
+            const char = pattern[at];
+            if (char === '|') {
+                at += 1;
+                quantifiable = false;
+            }
+            else if (char === ')') {
+                if (depth === 0)
+                    return 'an unmatched )';
+                return;
+            }
+            else if (char === '^' || char === '$') {
+                at += 1;
+                quantifiable = false;
+            }
+            else if (QUANTIFIERS.includes(char)) {
+                if (!quantifiable)
+                    return char === '{' ? 'an unescaped {' : 'a quantifier with nothing to repeat';
+                const problem = quantifier();
+                if (problem)
+                    return problem;
+                quantifiable = false;
+            }
+            else if (char === '(') {
+                if (!pattern.startsWith('(?:', at))
+                    return 'a group other than (?:';
+                at += 3;
+                const problem = disjunction(depth + 1);
+                if (problem)
+                    return problem;
+                if (pattern[at] !== ')')
+                    return 'an unclosed group';
+                at += 1;
+                quantifiable = true;
+            }
+            else if (char === '[') {
+                const problem = characterClass();
+                if (problem)
+                    return problem;
+                quantifiable = true;
+            }
+            else if (char === '\\') {
+                const code = escape(false);
+                if (typeof code === 'string')
+                    return code;
+                quantifiable = true;
+            }
+            else if (char === '.')
+                return 'an unescaped dot';
+            else if (char === ']' || char === '}')
+                return `an unescaped ${char}`;
+            else {
+                at += 1;
+                quantifiable = true;
+            }
+        }
+    };
+    return disjunction(0);
+}

package/dist/core/sha256.d.ts

@@ -0,0 +1,2 @@
+/** The lowercase hexadecimal SHA-256 of the bytes, or of the text's UTF-8 encoding. */
+export declare function sha256(input: string | Uint8Array): string;

package/dist/core/sha256.js

@@ -0,0 +1,59 @@
+// SHA-256 (FIPS 180-4) over bytes, so the core needs no platform crypto and runs the same
+// in Node, browsers and workers.
+const K = Uint32Array.from([
+    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,
+]);
+const rotate = (value, bits) => (value >>> bits) | (value << (32 - bits));
+/** The lowercase hexadecimal SHA-256 of the bytes, or of the text's UTF-8 encoding. */
+export function sha256(input) {
+    const bytes = typeof input === 'string' ? new TextEncoder().encode(input) : input;
+    // The message, a 1 bit, zeros, and its length in bits as a 64-bit big-endian integer.
+    const padded = new Uint8Array(Math.ceil((bytes.length + 9) / 64) * 64);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(bytes.length / 0x20000000));
+    view.setUint32(padded.length - 4, (bytes.length * 8) >>> 0);
+    const hash = Uint32Array.from([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const w = new Uint32Array(64);
+    for (let block = 0; block < padded.length; block += 64) {
+        for (let t = 0; t < 16; t += 1)
+            w[t] = view.getUint32(block + t * 4);
+        for (let t = 16; t < 64; t += 1) {
+            const s0 = rotate(w[t - 15], 7) ^ rotate(w[t - 15], 18) ^ (w[t - 15] >>> 3);
+            const s1 = rotate(w[t - 2], 17) ^ rotate(w[t - 2], 19) ^ (w[t - 2] >>> 10);
+            w[t] = w[t - 16] + s0 + w[t - 7] + s1;
+        }
+        let [a, b, c, d, e, f, g, h] = hash;
+        for (let t = 0; t < 64; t += 1) {
+            const t1 = h + (rotate(e, 6) ^ rotate(e, 11) ^ rotate(e, 25)) + ((e & f) ^ (~e & g)) + K[t] + w[t];
+            const t2 = (rotate(a, 2) ^ rotate(a, 13) ^ rotate(a, 22)) + ((a & b) ^ (a & c) ^ (b & c));
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        hash[0] += a;
+        hash[1] += b;
+        hash[2] += c;
+        hash[3] += d;
+        hash[4] += e;
+        hash[5] += f;
+        hash[6] += g;
+        hash[7] += h;
+    }
+    return Array.from(hash, (word) => word.toString(16).padStart(8, '0')).join('');
+}