@fireproof/core 0.3.22 → 0.4.0

package/dist/fireproof.js

@@ -0,0 +1,83 @@
+import randomBytes from 'randombytes';
+import { Database } from './database.js';
+import { Listener } from './listener.js';
+import { DbIndex as Index } from './db-index.js';
+import { CID } from 'multiformats';
+import { TransactionBlockstore } from './blockstore.js';
+import { localGet } from './utils.js';
+export { Index, Listener };
+const parseCID = cid => typeof cid === 'string' ? CID.parse(cid) : cid;
+class Fireproof {
+    /**
+     * @function storage
+     * @memberof Fireproof
+     * Creates a new Fireproof instance with default storage settings
+     * Most apps should use this and not worry about the details.
+     * @static
+     * @returns {Fireproof} - a new Fireproof instance
+     */
+    static storage = (name = null, opts = {}) => {
+        if (name) {
+            opts.name = name;
+            const existing = localGet('fp.' + name);
+            if (existing) {
+                const existingConfig = JSON.parse(existing);
+                const fp = new Database(new TransactionBlockstore(name, existingConfig.key), [], opts);
+                return this.fromJSON(existingConfig, fp);
+            }
+            else {
+                const instanceKey = randomBytes(32).toString('hex'); // pass null to disable encryption
+                return new Database(new TransactionBlockstore(name, instanceKey), [], opts);
+            }
+        }
+        else {
+            return new Database(new TransactionBlockstore(), [], opts);
+        }
+    };
+    static fromJSON(json, database) {
+        database.hydrate({ clock: json.clock.map(c => parseCID(c)), name: json.name, key: json.key });
+        if (json.indexes) {
+            for (const { name, code, clock: { byId, byKey, db } } of json.indexes) {
+                Index.fromJSON(database, {
+                    clock: {
+                        byId: byId ? parseCID(byId) : null,
+                        byKey: byKey ? parseCID(byKey) : null,
+                        db: db ? db.map(c => parseCID(c)) : null
+                    },
+                    code,
+                    name
+                });
+            }
+        }
+        return database;
+    }
+    static snapshot(database, clock) {
+        const definition = database.toJSON();
+        const withBlocks = new Database(database.blocks);
+        if (clock) {
+            definition.clock = clock.map(c => parseCID(c));
+            definition.indexes.forEach(index => {
+                index.clock.byId = null;
+                index.clock.byKey = null;
+                index.clock.db = null;
+            });
+        }
+        const snappedDb = this.fromJSON(definition, withBlocks);
+        ([...database.indexes.values()]).forEach(index => {
+            snappedDb.indexes.get(index.mapFnString).mapFn = index.mapFn;
+        });
+        return snappedDb;
+    }
+    static async zoom(database, clock) {
+        ;
+        ([...database.indexes.values()]).forEach(index => {
+            index.indexById = { root: null, cid: null };
+            index.indexByKey = { root: null, cid: null };
+            index.dbHead = null;
+        });
+        database.clock = clock.map(c => parseCID(c));
+        await database.notifyReset(); // hmm... indexes should listen to this? might be more complex than worth it. so far this is the only caller
+        return database;
+    }
+}
+export { Fireproof };

package/dist/hooks/use-fireproof.js

@@ -0,0 +1,100 @@
+// @ts-ignore
+import { useEffect, useState } from 'react';
+import { Fireproof, Listener } from '../src/fireproof.js';
+/**
+@typedef {Object} FireproofCtxValue
+@property {Function} addSubscriber - A function to add a subscriber with a label and function.
+@property {Fireproof} database - An instance of the Fireproof class.
+@property {boolean} ready - A boolean indicating whether the database is ready.
+@param {string} label - A label for the subscriber.
+@param {Function} fn - A function to be added as a subscriber.
+@returns {void}
+*/
+const inboundSubscriberQueue = new Map();
+let startedSetup = false;
+let database;
+let listener;
+const initializeDatabase = name => {
+    if (database)
+        return;
+    database = Fireproof.storage(name);
+    listener = new Listener(database);
+};
+/**
+
+@function useFireproof
+React hook to initialize a Fireproof database, automatically saving and loading the clock.
+You might need to import { nodePolyfills } from 'vite-plugin-node-polyfills' in your vite.config.ts
+@param {string} name - The path to the database file
+@param {function(database): void} [defineDatabaseFn] - Synchronous function that defines the database, run this before any async calls
+@param {function(database): Promise<void>} [setupDatabaseFn] - Asynchronous function that sets up the database, run this to load fixture data etc
+@returns {FireproofCtxValue} { addSubscriber, database, ready }
+*/
+export function useFireproof(name, defineDatabaseFn = () => { }, setupDatabaseFn = async () => { }) {
+    const [ready, setReady] = useState(false);
+    initializeDatabase(name || 'useFireproof');
+    const addSubscriber = (label, fn) => {
+        inboundSubscriberQueue.set(label, fn);
+    };
+    const listenerCallback = async (event) => {
+        if (event._external)
+            return;
+        for (const [, fn] of inboundSubscriberQueue)
+            fn();
+    };
+    useEffect(() => {
+        const doSetup = async () => {
+            if (ready)
+                return;
+            if (startedSetup)
+                return;
+            startedSetup = true;
+            defineDatabaseFn(database); // define indexes before querying them
+            if (database.clock.length === 0) {
+                await setupDatabaseFn(database);
+            }
+            setReady(true);
+            listener.on('*', listenerCallback); // hushed('*', listenerCallback, 250))
+        };
+        doSetup();
+    }, [ready]);
+    return {
+        addSubscriber,
+        database,
+        ready
+    };
+}
+// const husherMap = new Map()
+// const husher = (id, workFn, ms) => {
+//   if (!husherMap.has(id)) {
+//     const start = Date.now()
+//     husherMap.set(
+//       id,
+//       workFn().finally(() => setTimeout(() => husherMap.delete(id), ms - (Date.now() - start)))
+//     )
+//   }
+//   return husherMap.get(id)
+// }
+// const hushed =
+//   (id, workFn, ms) =>
+//     (...args) =>
+//       husher(id, () => workFn(...args), ms)
+// let storageSupported = false
+// try {
+//   storageSupported = window.localStorage && true
+// } catch (e) {}
+// export function localGet (key) {
+//   if (storageSupported) {
+//     return localStorage && localStorage.getItem(key)
+//   }
+// }
+// function localSet (key, value) {
+//   if (storageSupported) {
+//     return localStorage && localStorage.setItem(key, value)
+//   }
+// }
+// function localRemove(key) {
+//   if (storageSupported) {
+//     return localStorage && localStorage.removeItem(key)
+//   }
+// }

package/dist/listener.js

@@ -0,0 +1,110 @@
+/**
+ * A Fireproof database Listener allows you to react to events in the database.
+ *
+ * @class Listener
+ * @classdesc An listener attaches to a Fireproof database and runs a routing function on each change, sending the results to subscribers.
+ *
+ * @param {import('./database.js').Database} database - The Database database instance to index.
+ * @param {Function} routingFn - The routing function to apply to each entry in the database.
+ */
+// import { ChangeEvent } from './db-index'
+export class Listener {
+    subcribers = new Map();
+    doStopListening = null;
+    /**
+     * @param {import('./database.js').Database} database
+     * @param {(_: any, emit: any) => void} routingFn
+     */
+    constructor(database, routingFn) {
+        this.database = database;
+        this.doStopListening = database.registerListener((/** @type {any} */ changes) => this.onChanges(changes));
+        /**
+         * The map function to apply to each entry in the database.
+         * @type {Function}
+         */
+        this.routingFn =
+            routingFn ||
+                function (/** @type {any} */ _, /** @type {(arg0: string) => void} */ emit) {
+                    emit('*');
+                };
+        this.dbHead = null;
+    }
+    /**
+     * Subscribe to a topic emitted by the event function.
+     * @param {string} topic - The topic to subscribe to.
+     * @param {Function} subscriber - The function to call when the topic is emitted.
+     * @returns {Function} A function to unsubscribe from the topic.
+     * @memberof Listener
+     * @instance
+     * @param {any} since
+     */
+    on(topic, subscriber, since) {
+        const listOfTopicSubscribers = getTopicList(this.subcribers, topic);
+        listOfTopicSubscribers.push(subscriber);
+        if (typeof since !== 'undefined') {
+            this.database.changesSince(since).then(({ rows: changes }) => {
+                const keys = topicsForChanges(changes, this.routingFn).get(topic);
+                if (keys)
+                    keys.forEach((/** @type {any} */ key) => subscriber(key));
+            });
+        }
+        return () => {
+            const index = listOfTopicSubscribers.indexOf(subscriber);
+            if (index > -1)
+                listOfTopicSubscribers.splice(index, 1);
+        };
+    }
+    /**
+     * @typedef {import('./db-index').ChangeEvent} ChangeEvent
+     */
+    /**
+     * @param {ChangeEvent[]} changes
+     */
+    onChanges(changes) {
+        if (Array.isArray(changes)) {
+            const seenTopics = topicsForChanges(changes, this.routingFn);
+            for (const [topic, keys] of seenTopics) {
+                const listOfTopicSubscribers = getTopicList(this.subcribers, topic);
+                listOfTopicSubscribers.forEach((/** @type {(arg0: any) => any} */ subscriber) => keys.forEach((/** @type {any} */ key) => subscriber(key)));
+            }
+        }
+        else {
+            // non-arrays go to all subscribers
+            for (const [, listOfTopicSubscribers] of this.subcribers) {
+                listOfTopicSubscribers.forEach((/** @type {(arg0: any) => any} */ subscriber) => subscriber(changes));
+            }
+        }
+    }
+}
+/**
+ * @param {Map<any, any>} subscribersMap
+ * @param {string} name
+ */
+function getTopicList(subscribersMap, name) {
+    let topicList = subscribersMap.get(name);
+    if (!topicList) {
+        topicList = [];
+        subscribersMap.set(name, topicList);
+    }
+    return topicList;
+}
+/**
+ * Transforms a set of changes to events using an emitter function.
+ *
+ * @param {ChangeEvent[]} changes
+ * @param {Function} routingFn
+ * @returns {Map<string,string[]>} The topics emmitted by the event function.
+ * @private
+ */
+const topicsForChanges = (changes, routingFn) => {
+    const seenTopics = new Map();
+    changes.forEach(({ key, value, del }) => {
+        if (del || !value)
+            value = { _deleted: true };
+        routingFn({ _id: key, ...value }, (/** @type {any} */ t) => {
+            const topicList = getTopicList(seenTopics, t);
+            topicList.push(key);
+        });
+    });
+    return seenTopics;
+};

package/dist/prolly.js

@@ -0,0 +1,316 @@
+import { advance, EventFetcher, EventBlock, findCommonAncestorWithSortedEvents, findEventsToSync, vis as visClock } from './clock.js';
+// import { create, load } from '../../../../prolly-trees/src/map.js'
+// @ts-ignore
+import { create, load } from 'prolly-trees/map';
+// @ts-ignore
+import { nocache as cache } from 'prolly-trees/cache';
+// @ts-ignore
+import { CIDCounter, bf, simpleCompare as compare } from 'prolly-trees/utils';
+import * as codec from '@ipld/dag-cbor';
+import { sha256 as hasher } from 'multiformats/hashes/sha2';
+import { doTransaction } from './blockstore.js';
+import { create as createBlock } from 'multiformats/block';
+const blockOpts = { cache, chunker: bf(3), codec, hasher, compare };
+const withLog = async (label, fn) => {
+    const resp = await fn();
+    // console.log('withLog', label, !!resp)
+    return resp;
+};
+// should also return a CIDCounter
+export const makeGetBlock = (blocks) => {
+    // const cids = new CIDCounter() // this could be used for proofs of mutations
+    const getBlockFn = async (address) => {
+        const { cid, bytes } = await withLog(address, () => blocks.get(address));
+        // cids.add({ address: cid })
+        return createBlock({ cid, bytes, hasher, codec });
+    };
+    return {
+        // cids,
+        getBlock: getBlockFn
+    };
+};
+/**
+ *
+ * @param {*} param0
+ * @returns
+ */
+async function createAndSaveNewEvent({ inBlocks, bigPut, root, event: inEvent, head, additions, removals = [] }) {
+    let cids;
+    const { key, value, del } = inEvent;
+    const data = {
+        root: (root
+            ? {
+                cid: root.cid,
+                bytes: root.bytes,
+                value: root.value // can we remove this?
+            }
+            : null),
+        key
+    };
+    // import('./clock').EventLink<import('./clock').EventData>
+    if (del) {
+        data.value = null;
+        data.type = 'del';
+    }
+    else {
+        data.value = value;
+        data.type = 'put';
+    }
+    /** @type {import('./clock').EventData} */
+    // @ts-ignore
+    const event = await EventBlock.create(data, head);
+    bigPut(event);
+    ({ head, cids } = await advance(inBlocks, head, event.cid));
+    return {
+        root,
+        additions,
+        removals,
+        head,
+        clockCIDs: cids,
+        event
+    };
+}
+const makeGetAndPutBlock = (inBlocks) => {
+    // const mblocks = new MemoryBlockstore()
+    // const blocks = new MultiBlockFetcher(mblocks, inBlocks)
+    const { getBlock, cids } = makeGetBlock(inBlocks);
+    const put = inBlocks.put.bind(inBlocks);
+    const bigPut = async (block, additions) => {
+        // console.log('bigPut', block.cid.toString())
+        const { cid, bytes } = block;
+        put(cid, bytes);
+        // mblocks.putSync(cid, bytes)
+        if (additions) {
+            additions.set(cid.toString(), block);
+        }
+    };
+    return { getBlock, bigPut, blocks: inBlocks, cids };
+};
+const bulkFromEvents = (sorted, event) => {
+    if (event) {
+        const update = { value: { data: { key: event.key } } };
+        if (event.del) {
+            update.value.data.type = 'del';
+        }
+        else {
+            update.value.data.type = 'put';
+            update.value.data.value = event.value;
+        }
+        sorted.push(update);
+    }
+    const bulk = new Map();
+    for (const { value: event } of sorted) {
+        const { data: { type, value, key } } = event;
+        const bulkEvent = type === 'put' ? { key, value } : { key, del: true };
+        bulk.set(bulkEvent.key, bulkEvent); // last wins
+    }
+    return Array.from(bulk.values());
+};
+// Get the value of the root from the ancestor event
+/**
+ *
+ * @param {EventFetcher} events
+ * @param {import('./clock').EventLink<import('./clock').EventData>} ancestor
+ * @param {*} getBlock
+ * @returns
+ */
+const prollyRootFromAncestor = async (events, ancestor, getBlock) => {
+    // console.log('prollyRootFromAncestor', ancestor)
+    const event = await events.get(ancestor);
+    const { root } = event.value.data;
+    // console.log('prollyRootFromAncestor', root.cid, JSON.stringify(root.value))
+    if (root) {
+        return load({ cid: root.cid, get: getBlock, ...blockOpts });
+    }
+    else {
+        return null;
+    }
+};
+const doProllyBulk = async (inBlocks, head, event) => {
+    const { getBlock, blocks } = makeGetAndPutBlock(inBlocks);
+    let bulkSorted = [];
+    let prollyRootNode = null;
+    if (head.length) {
+        // Otherwise, we find the common ancestor and update the root and other blocks
+        const events = new EventFetcher(blocks);
+        // todo this is returning more events than necessary, lets define the desired semantics from the top down
+        // good semantics mean we can cache the results of this call
+        const { ancestor, sorted } = await findCommonAncestorWithSortedEvents(events, head);
+        bulkSorted = sorted;
+        // console.log('sorted', JSON.stringify(sorted.map(({ value: { data: { key, value } } }) => ({ key, value }))))
+        prollyRootNode = await prollyRootFromAncestor(events, ancestor, getBlock);
+        // console.log('event', event)
+    }
+    const bulkOperations = bulkFromEvents(bulkSorted, event);
+    // if prolly root node is null, we need to create a new one
+    if (!prollyRootNode) {
+        let root;
+        const newBlocks = [];
+        // if all operations are deletes, we can just return an empty root
+        if (bulkOperations.every((op) => op.del)) {
+            return { root: null, blocks: [] };
+        }
+        for await (const node of create({ get: getBlock, list: bulkOperations, ...blockOpts })) {
+            root = await node.block;
+            newBlocks.push(root);
+        }
+        return { root, blocks: newBlocks };
+    }
+    else {
+        return await prollyRootNode.bulk(bulkOperations); // { root: newProllyRootNode, blocks: newBlocks }
+    }
+};
+/**
+ * Put a value (a CID) for the given key. If the key exists it's value is overwritten.
+ *
+ * @param {import('./blockstore.js').Blockstore} inBlocks Bucket block storage.
+ * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
+* @param {{key: string, value: import('./clock').EventLink<import('./clock').EventData>}} event The key of the value to put.
+ * @param {object} [options]
+ * @returns {Promise<any>}
+ */
+export async function put(inBlocks, head, event, options) {
+    const { bigPut } = makeGetAndPutBlock(inBlocks);
+    // If the head is empty, we create a new event and return the root and addition blocks
+    if (!head.length) {
+        const additions = new Map();
+        const { root, blocks } = await doProllyBulk(inBlocks, head, event);
+        for (const b of blocks) {
+            bigPut(b, additions);
+        }
+        return createAndSaveNewEvent({ inBlocks, bigPut, root, event, head, additions: Array.from(additions.values()) });
+    }
+    const { root: newProllyRootNode, blocks: newBlocks } = await doProllyBulk(inBlocks, head, event);
+    if (!newProllyRootNode) {
+        return createAndSaveNewEvent({
+            inBlocks,
+            bigPut,
+            root: null,
+            event,
+            head,
+            additions: []
+        });
+    }
+    else {
+        const prollyRootBlock = await newProllyRootNode.block;
+        const additions = new Map(); // ; const removals = new Map()
+        bigPut(prollyRootBlock, additions);
+        for (const nb of newBlocks) {
+            bigPut(nb, additions);
+        }
+        // additions are new blocks
+        return createAndSaveNewEvent({
+            inBlocks,
+            bigPut,
+            root: prollyRootBlock,
+            event,
+            head,
+            additions: Array.from(additions.values()) /*, todo? Array.from(removals.values()) */
+        });
+    }
+}
+/**
+ * Determine the effective prolly root given the current merkle clock head.
+ *
+ * @param {import('./blockstore.js').TransactionBlockstore} inBlocks Bucket block storage.
+ * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
+ */
+export async function root(inBlocks, head) {
+    if (!head.length) {
+        throw new Error('no head');
+    }
+    const { root: newProllyRootNode, blocks: newBlocks, cids } = await doProllyBulk(inBlocks, head);
+    // todo maybe these should go to a temp blockstore?
+    await doTransaction('root', inBlocks, async (transactionBlockstore) => {
+        const { bigPut } = makeGetAndPutBlock(transactionBlockstore);
+        for (const nb of newBlocks) {
+            bigPut(nb);
+        }
+    });
+    return { cids, node: newProllyRootNode };
+}
+/**
+ * Get the list of events not known by the `since` event
+ * @param {import('./blockstore.js').TransactionBlockstore} blocks Bucket block storage.
+ * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
+ * @param {import('./clock').EventLink<import('./clock').EventData>} since Event to compare against.
+ * @returns {Promise<{clockCIDs: CIDCounter, result: import('./clock').EventData[]}>}
+ */
+export async function eventsSince(blocks, head, since) {
+    if (!head.length) {
+        throw new Error('no head');
+    }
+    // @ts-ignore
+    const sinceHead = [...since, ...head]; // ?
+    const { cids, events: unknownSorted3 } = await findEventsToSync(blocks, sinceHead);
+    return { clockCIDs: cids, result: unknownSorted3.map(({ value: { data } }) => data) };
+}
+/**
+ *
+ * @param {import('./blockstore.js').TransactionBlockstore} blocks Bucket block storage.
+ * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
+ *
+ * @returns {Promise<{cids: CIDCounter, clockCIDs: CIDCounter, result: import('./clock').EventData[]}>}
+ *
+ */
+export async function getAll(blocks, head) {
+    // todo use the root node left around from put, etc
+    // move load to a central place
+    if (!head.length) {
+        return { clockCIDs: new CIDCounter(), cids: new CIDCounter(), result: [] };
+    }
+    const { node: prollyRootNode, cids: clockCIDs } = await root(blocks, head);
+    if (!prollyRootNode) {
+        return { clockCIDs, cids: new CIDCounter(), result: [] };
+    }
+    const { result, cids } = await prollyRootNode.getAllEntries(); // todo params
+    return { clockCIDs, cids, result: result.map(({ key, value }) => ({ key, value })) };
+}
+/**
+ * @param {import('./blockstore.js').TransactionBlockstore} blocks Bucket block storage.
+ * @param {import('./clock').EventLink<import('./clock').EventData>[]} head Merkle clock head.
+ * @param {string} key The key of the value to retrieve.
+ */
+export async function get(blocks, head, key) {
+    // instead pass root from db? and always update on change
+    if (!head.length) {
+        return { cids: new CIDCounter(), result: null };
+    }
+    const { node: prollyRootNode, cids: clockCIDs } = await root(blocks, head);
+    if (!prollyRootNode) {
+        return { clockCIDs, cids: new CIDCounter(), result: null };
+    }
+    const { result, cids } = await prollyRootNode.get(key);
+    return { result, cids, clockCIDs };
+}
+export async function* vis(blocks, head) {
+    if (!head.length) {
+        return { cids: new CIDCounter(), result: null };
+    }
+    const { node: prollyRootNode, cids } = await root(blocks, head);
+    const lines = [];
+    for await (const line of prollyRootNode.vis()) {
+        yield line;
+        lines.push(line);
+    }
+    return { vis: lines.join('\n'), cids };
+}
+export async function visMerkleTree(blocks, head) {
+    if (!head.length) {
+        return { cids: new CIDCounter(), result: null };
+    }
+    const { node: prollyRootNode, cids } = await root(blocks, head);
+    const lines = [];
+    for await (const line of prollyRootNode.vis()) {
+        lines.push(line);
+    }
+    return { vis: lines.join('\n'), cids };
+}
+export async function visMerkleClock(blocks, head) {
+    const lines = [];
+    for await (const line of visClock(blocks, head)) {
+        // yield line
+        lines.push(line);
+    }
+    return { vis: lines.join('\n') };
+}

package/dist/sha1.js

@@ -0,0 +1,74 @@
+// @ts-nocheck
+// from https://github.com/duzun/sync-sha1/blob/master/rawSha1.js
+// MIT License Copyright (c) 2020 Dumitru Uzun
+// 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.
+// import {
+//   isLittleEndian, switchEndianness32
+// } from 'string-encode'
+/**
+* SHA1 on binary array
+*
+* @param   {Uint8Array}  b  Data to hash
+*
+* @return  {Uint8Array}  sha1 hash
+*/
+export function rawSha1(b) {
+    let i = b.byteLength;
+    let bs = 0;
+    let A;
+    let B;
+    let C;
+    let D;
+    let G;
+    const H = Uint32Array.from([A = 0x67452301, B = 0xEFCDAB89, ~A, ~B, 0xC3D2E1F0]);
+    const W = new Uint32Array(80);
+    const nrWords = (i / 4 + 2) | 15;
+    const words = new Uint32Array(nrWords + 1);
+    let j;
+    words[nrWords] = i * 8;
+    words[i >> 2] |= 0x80 << (~i << 3);
+    for (; i--;) {
+        words[i >> 2] |= b[i] << (~i << 3);
+    }
+    for (A = H.slice(); bs < nrWords; bs += 16, A.set(H)) {
+        for (i = 0; i < 80; A[0] = (G = ((b = A[0]) << 5 | b >>> 27) +
+            A[4] +
+            (W[i] = (i < 16) ? words[bs + i] : G << 1 | G >>> 31) +
+            0x5A827999,
+            B = A[1],
+            C = A[2],
+            D = A[3],
+            G + ((j = i / 5 >> 2) // eslint-disable-line no-cond-assign
+                ? j !== 2
+                    ? (B ^ C ^ D) + (j & 2 ? 0x6FE0483D : 0x14577208)
+                    : (B & C | B & D | C & D) + 0x34994343
+                : B & C | ~B & D))
+            , A[1] = b
+            , A[2] = B << 30 | B >>> 2
+            , A[3] = C
+            , A[4] = D
+            , ++i) {
+            G = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+        }
+        for (i = 5; i;)
+            H[--i] = H[i] + A[i];
+    }
+    // if (isLittleEndian()) {
+    //   H = H.map(switchEndianness32)
+    // }
+    return new Uint8Array(H.buffer, H.byteOffset, H.byteLength);
+}