spasm.js 1.0.2 → 2.0.0-alpha

package/lib.esm/utils/utils.js

@@ -1,3 +1,10 @@
+/*
+ * Using sha256 from 'js-sha256' npm package, because
+ * built-in 'crypto' module works only in a server-side
+ * Node.js environment, not on the client-side (browser).
+ */
+import { sha256 } from "js-sha256";
+import { ethers } from "ethers";
 // Filter out undefined, null, 0, '', false, NaN, {}, []
 // Keep {a: null}, {b: undefined}
 // Examples:
@@ -78,12 +85,17 @@ export const extractSealedEvent = (unknownPostOrEvent) => {
     if (!isObjectWithValues(unknownPostOrEvent))
         return false;
     let signedObject = false;
-    if ('signed_message' in unknownPostOrEvent &&
+    if (unknownPostOrEvent &&
+        typeof (unknownPostOrEvent) === "object" &&
+        'signed_message' in unknownPostOrEvent &&
         unknownPostOrEvent['signed_message'] &&
         typeof (unknownPostOrEvent['signed_message'] === "string")) {
         signedObject = JSON.parse(unknownPostOrEvent['signed_message']);
     }
-    else if ('signedString' in unknownPostOrEvent &&
+    else if (unknownPostOrEvent &&
+        typeof (unknownPostOrEvent) === "object" &&
+        'signedString' in unknownPostOrEvent &&
+        unknownPostOrEvent['signedString'] &&
         typeof (unknownPostOrEvent['signedString'] === "string")) {
         signedObject = JSON.parse(unknownPostOrEvent['signedString']);
     }
@@ -96,6 +108,12 @@ export const toBeTimestamp = (time) => {
     if (Number.isNaN(timestamp)) {
         return undefined;
     }
+    // Optional
+    // Standardize the timestamp to 10 characters (seconds)
+    // by rounding down the timestamp to the nearest second.
+    // if (timestamp.toString().length > 10) {
+    //   timestamp = Math.floor(timestamp / 1000) * 1000;
+    // }
     return timestamp;
 };
 export const getNostrSpasmVersion = (event) => {
@@ -112,4 +130,685 @@ export const getNostrSpasmVersion = (event) => {
     }
     return nostrSpasmVersion;
 };
+// Example usage
+// getSchemeFromUrl('https://example.com/news') // return 'https'
+// getSchemeFromUrl('http://example.com') // return 'http'
+// getSchemeFromUrl('ftp://example.com') // return 'ftp'
+// getSchemeFromUrl('mailto://...') // return 'mailto'
+// getSchemeFromUrl('ipfs://123abc') // return 'ipfs'
+// export const getSchemeFromUrl = (url: any) => {
+//   if (!url || typeof(url) !== "string") return ""
+//   try {
+//     const urlObject = new URL(url);
+//     return urlObject.protocol.slice(0, -1); // Remove the trailing colon
+//   } catch (error) {
+//     console.log('Invalid URL:', url);
+//     return "";
+//   }
+// }
+export const isValidUrl = (value) => {
+    if (!value)
+        return false;
+    try {
+        // new URL() constructor is less vulnerable to ReDoS attacks
+        // because it's a built-it JS function that doesn't use regex
+        new URL(value);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+export const createLinkObjectFromUrl = (url, key) => {
+    if (!url || typeof (url) !== "string")
+        return null;
+    try {
+        const urlObject = new URL(url);
+        const linkObject = {
+            value: url,
+            // protocol: urlObject.protocol.slice(0, -1),
+            // host: urlObject.host,
+            // path: urlObject.pathname,
+            // search: urlObject.search,
+        };
+        if (urlObject.protocol) {
+            linkObject.protocol = urlObject.protocol.slice(0, -1);
+        }
+        if (urlObject.origin) {
+            linkObject.origin = urlObject.origin;
+        }
+        if (urlObject.host) {
+            linkObject.host = urlObject.host;
+        }
+        if (urlObject.pathname &&
+            typeof (urlObject.pathname) === "string" // &&
+        // urlObject.pathname.length > 1
+        ) {
+            linkObject.pathname = urlObject.pathname;
+        }
+        if (urlObject.search &&
+            typeof (urlObject.search) === "string" // &&
+        // urlObject.search.length > 1
+        ) {
+            linkObject.search = urlObject.search;
+        }
+        if (urlObject.port) {
+            linkObject.port = urlObject.port;
+        }
+        if (urlObject.hash) {
+            linkObject.hash = urlObject.hash;
+        }
+        if (key &&
+            (typeof (key) === "string" || typeof (key) === "number")) {
+            linkObject.originalProtocolKey = key;
+        }
+        return linkObject;
+    }
+    catch (error) {
+        console.log('Invalid URL:', url);
+        return null;
+    }
+};
+export const getFormatFromValue = (value) => {
+    let format = undefined;
+    if (!value)
+        return format;
+    if (typeof (value) !== "string" && typeof (value) !== "number") {
+        return format;
+    }
+    if (typeof (value) === "number") {
+        return format = { name: "number" };
+    }
+    if (value && typeof (value) === "string") {
+        // Spasm ID
+        if (value.length === 64 + 9 && value.startsWith("spasmid")) {
+            const version = value.slice(7, 9);
+            format = { name: "spasmid", version: version };
+            return format;
+        }
+        // Dmp ID (signature)
+        if (value.length === 132 && value.startsWith("0x")) {
+            format = { name: "ethereum-sig" };
+            return format;
+        }
+        // Nostr ID
+        if (value.length === 63 && value.startsWith("note")) {
+            format = { name: "nostr-note" };
+            return format;
+        }
+        if (value.length === 68 && value.startsWith("nevent")) {
+            format = { name: "nostr-nevent" };
+            return format;
+        }
+        // Spasm signer
+        // if (address.length === 64 + 9 && address.startsWith("spasmer")) {
+        //   const version = address.slice(7,9)
+        //   format = { name: "spasmer", version: version }
+        //   return format
+        // }
+        // Ethereum signer
+        if (value.length === 42 && value.startsWith("0x")) {
+            format = { name: "ethereum-pubkey" };
+            return format;
+        }
+        // Nostr signer
+        if (value.length === 63 && value.startsWith("npub")) {
+            format = { name: "nostr-npub" };
+            return format;
+        }
+        // url
+        if (isValidUrl(value)) {
+            format = { name: "url" };
+            return format;
+        }
+        if (value.length === 64 &&
+            !value.startsWith("note") &&
+            !value.startsWith("nevent") &&
+            !value.startsWith("npub")) {
+            format = { name: "nostr-hex" };
+            return format;
+        }
+    }
+    if (typeof (value) === "string") {
+        return format = { name: "string" };
+    }
+    return format;
+};
+export const getFormatFromId = (id) => {
+    return getFormatFromValue(id);
+};
+export const getFormatFromAddress = (address) => {
+    return getFormatFromValue(address);
+};
+export const getFormatFromSignature = (address) => {
+    return getFormatFromValue(address);
+};
+export const getHashOfString = (string, algorithm = "sha256") => {
+    if (typeof (string) !== "string")
+        return "";
+    if (algorithm === "sha256") {
+        return sha256(string);
+    }
+    return "";
+};
+// Keep only specified keys in an object.
+export const keepTheseKeysInObject = (obj, keys) => {
+    return keys.reduce((acc, key) => {
+        if (obj.hasOwnProperty(key)) {
+            acc[key] = obj[key];
+        }
+        return acc;
+    }, {});
+};
+// Keep only specified keys in each object of an array.
+export const keepTheseKeysInObjectsInArray = (array, keys) => {
+    return array.map(obj => keepTheseKeysInObject(obj, keys));
+};
+// This function only sorts string and number values.
+export const sortArrayOfStringsAndNumbers = (array) => {
+    // Separate values into valid and invalid categories.
+    const { validValues, invalidValues } = array.reduce((acc, value) => {
+        if (typeof value === 'string' ||
+            typeof value === 'number') {
+            acc.validValues.push(value);
+        }
+        else {
+            acc.invalidValues.push(value);
+        }
+        return acc;
+    }, { validValues: [], invalidValues: [] });
+    // Sort the valid values
+    const sortedValidValues = validValues.sort((a, b) => String(a).localeCompare(String(b)));
+    // Combine sorted valid values with invalid values
+    const result = [...sortedValidValues, ...invalidValues];
+    return result;
+};
+export const sortArrayOfObjects = (objects, sortBy = ["id"]) => {
+    if (!objects ||
+        !Array.isArray(objects) ||
+        !objects[0]) {
+        return [];
+    }
+    // Ensure sortBy is always treated as an array
+    const sortedBy = Array.isArray(sortBy) ? sortBy : [sortBy];
+    // Separate objects into valid and invalid categories based
+    // on the existence of the specified property(ies)
+    const { validObjects, invalidValues } = objects.reduce((acc, item) => {
+        let isValid = false;
+        // Only one prop should exist in item in order
+        // to make it a valid item.
+        sortedBy.forEach((key) => {
+            if (typeof (item) === 'object' && item &&
+                key in item && item[key] &&
+                (typeof (item[key]) === "string" ||
+                    typeof (item[key]) === "number")) {
+                isValid = true;
+            }
+        });
+        if (isValid) {
+            acc.validObjects.push(item);
+        }
+        else {
+            acc.invalidValues.push(item);
+        }
+        return acc;
+    }, { validObjects: [], invalidValues: [] });
+    // Sort the valid objects by the specified property(ies)
+    const sortedValidObjects = validObjects.sort((a, b) => {
+        for (const key of sortedBy) {
+            const aValue = typeof a[key] === 'string' ? a[key] : String(a[key]);
+            const bValue = typeof b[key] === 'string' ? b[key] : String(b[key]);
+            const compareResult = aValue.localeCompare(bValue);
+            if (compareResult !== 0) {
+                return compareResult;
+            }
+        }
+        return 0; // Equal
+    });
+    const sortedInvalidValues = sortArrayOfStringsAndNumbers(invalidValues);
+    // Combine sorted valid objects with invalid objects
+    const result = [...sortedValidObjects, ...sortedInvalidValues];
+    return result;
+};
+export const sortAuthorsForSpasmEventV2 = (authors) => {
+    // Clean and sort addresses
+    authors.forEach(author => {
+        if (author && typeof (author) === "object" &&
+            'addresses' in author && author.addresses &&
+            Array.isArray(author.addresses) &&
+            author.addresses[0]) {
+            // Clean addresses to keep only  'value' and 'format' keys
+            // and remove 'verified' and 'hosts' keys.
+            author.addresses = keepTheseKeysInObjectsInArray(author.addresses, ["value", "format"]);
+            // Sort addresses
+            author.addresses = sortArrayOfObjects(author.addresses, "value");
+        }
+    });
+    // Clean and sort usernames
+    authors.forEach(author => {
+        if (author && typeof (author) === "object" &&
+            'usernames' in author && author.usernames &&
+            Array.isArray(author.usernames) &&
+            author.usernames[0]) {
+            // There is no need to clean usernames because all fields
+            // should be calculated for the Spasm ID 01.
+            // Sort usernames
+            author.usernames = sortArrayOfObjects(author.usernames, "value");
+        }
+    });
+    let authorsWithAddress = [];
+    // Authors without address are used temporary until we split
+    // them further depending on whether they have usernames.
+    let authorsWithoutAddress = [];
+    let authorsWithoutAddressWithUsername = [];
+    let authorsWithoutAddressWithoutUsername = [];
+    authors.forEach(author => {
+        if (author && typeof (author) === "object" &&
+            'addresses' in author && author.addresses &&
+            Array.isArray(author.addresses) && author.addresses[0] &&
+            author.addresses[0].value &&
+            (typeof (author.addresses[0].value) === "string" ||
+                typeof (author.addresses[0].value) === "number")) {
+            authorsWithAddress.push(author);
+        }
+        else {
+            authorsWithoutAddress.push(author);
+        }
+    });
+    authorsWithoutAddress.forEach(author => {
+        if (author && typeof (author) === "object" &&
+            'usernames' in author && author.usernames &&
+            Array.isArray(author.usernames) && author.usernames[0] &&
+            author.usernames[0].value &&
+            (typeof (author.usernames[0].value) === "string" ||
+                typeof (author.usernames[0].value) === "number")) {
+            authorsWithoutAddressWithUsername.push(author);
+        }
+        else {
+            authorsWithoutAddressWithoutUsername.push(author);
+        }
+    });
+    // Sort all 3 arrays
+    const sortedAuthorsWithAddress = sortArrayOfObjectsByKeyValue(authorsWithAddress, "addresses");
+    const sortedAuthorsWithoutAddressWithUsername = sortArrayOfObjectsByKeyValue(authorsWithoutAddressWithUsername, "usernames");
+    const sortedAuthorsWithoutAddressWithoutUsername = sortArrayOfObjects(authorsWithoutAddressWithoutUsername, ["id"]);
+    const result = [
+        ...sortedAuthorsWithAddress,
+        ...sortedAuthorsWithoutAddressWithUsername,
+        ...sortedAuthorsWithoutAddressWithoutUsername
+    ];
+    return result;
+};
+export const sortAuthorsForSpasmid01 = sortAuthorsForSpasmEventV2;
+export const sortArrayOfObjectsByKeyValue = (objects, key) => {
+    const sortedObjects = objects.sort((a, b) => {
+        let aValue = "";
+        let bValue = "";
+        if (a[key] && a[key][0] &&
+            a[key][0].value) {
+            if (typeof (a[key][0].value) === 'string') {
+                aValue = a[key][0].value;
+            }
+            else if (typeof (a[key][0].value) === 'number') {
+                aValue = String(a[key][0].value);
+            }
+        }
+        if (b[key] && b[key][0] &&
+            b[key][0].value) {
+            if (typeof (b[key][0].value) === 'string') {
+                bValue = b[key][0].value;
+            }
+            else if (typeof (b[key][0].value) === 'number') {
+                bValue = String(b[key][0].value);
+            }
+        }
+        const compareResult = aValue.localeCompare(bValue);
+        if (compareResult !== 0) {
+            return compareResult;
+        }
+        return 0; // Equal
+    });
+    return sortedObjects;
+};
+export const sortHostsForSpasmEventV2 = (hosts) => {
+    if (!hosts ||
+        !Array.isArray(hosts) ||
+        !hosts[0]) {
+        return hosts;
+    }
+    const sortedHosts = sortArrayOfObjects(hosts, "value");
+    return sortedHosts;
+};
+export const sortHostsForSpasmid01 = sortHostsForSpasmEventV2;
+export const sortLinksForSpasmEventV2 = sortHostsForSpasmEventV2;
+export const sortLinksForSpasmid01 = sortLinksForSpasmEventV2;
+export const sortMediasForSpasmid01 = (medias) => {
+    if (!medias || !Array.isArray(medias))
+        return [];
+    // Clean and sort IDs
+    medias.forEach(media => {
+        if (media && typeof (media) === "object" &&
+            'ids' in media && media.ids &&
+            Array.isArray(media.ids) &&
+            media.ids[0]) {
+            // Clean ids to keep only  'value' key
+            media.ids = keepTheseKeysInObjectsInArray(media.ids, ["value"]);
+            // Sort ids
+            media.ids = sortArrayOfObjects(media.ids, "value");
+        }
+    });
+    // Clean and sort hashes
+    medias.forEach(media => {
+        if (media && typeof (media) === "object" &&
+            'hashes' in media && media.hashes &&
+            Array.isArray(media.hashes) &&
+            media.hashes[0]) {
+            // Clean hashes to keep only  'value' key
+            media.hashes = keepTheseKeysInObjectsInArray(media.hashes, ["value"]);
+            // Sort hashes
+            media.hashes = sortArrayOfObjects(media.hashes, "value");
+        }
+    });
+    // Clean and sort links
+    medias.forEach(media => {
+        if (media && typeof (media) === "object" &&
+            'links' in media && media.links &&
+            Array.isArray(media.links) &&
+            media.links[0]) {
+            // Clean links to keep only  'value' key
+            media.links = keepTheseKeysInObjectsInArray(media.links, ["value"]);
+            // Sort links
+            media.links = sortArrayOfObjects(media.links, "value");
+        }
+    });
+    // mediasWithIds might also have hashes and links
+    let mediasWithIds = [];
+    let mediasWithoutIds = [];
+    // mediasWithHashes might also have links, but no ids
+    let mediasWithHashes = [];
+    let mediasWithoutIdsHashes = [];
+    // mediasWithLinks only has links, but no ids and hashes
+    let mediasWithLinks = [];
+    let mediasWithoutIdsHashesLinks = [];
+    // Sort medias by ids
+    medias.forEach(media => {
+        if (media && typeof (media) === "object" &&
+            'ids' in media && media.ids &&
+            Array.isArray(media.ids) && media.ids[0] &&
+            media.ids[0].value &&
+            (typeof (media.ids[0].value) === "string" ||
+                typeof (media.ids[0].value) === "number")) {
+            mediasWithIds.push(media);
+        }
+        else {
+            mediasWithoutIds.push(media);
+        }
+    });
+    // Sort medias by hashes
+    mediasWithoutIds.forEach(media => {
+        if (media && typeof (media) === "object" &&
+            'hashes' in media && media.hashes &&
+            Array.isArray(media.hashes) && media.hashes[0] &&
+            media.hashes[0].value &&
+            (typeof (media.hashes[0].value) === "string" ||
+                typeof (media.hashes[0].value) === "number")) {
+            mediasWithHashes.push(media);
+        }
+        else {
+            mediasWithoutIdsHashes.push(media);
+        }
+    });
+    // Sort medias by links
+    mediasWithoutIdsHashes.forEach(media => {
+        if (media && typeof (media) === "object" &&
+            'links' in media && media.links &&
+            Array.isArray(media.links) && media.links[0] &&
+            media.links[0].value &&
+            (typeof (media.links[0].value) === "string" ||
+                typeof (media.links[0].value) === "number")) {
+            mediasWithLinks.push(media);
+        }
+        else {
+            mediasWithoutIdsHashesLinks.push(media);
+        }
+    });
+    const mediasOther = mediasWithoutIdsHashesLinks;
+    // Sort all 3 arrays
+    const sortedMediasWithIds = sortArrayOfObjectsByKeyValue(mediasWithIds, "ids");
+    const sortedMediasWithHashes = sortArrayOfObjectsByKeyValue(mediasWithHashes, "hashes");
+    const sortedMediasWithLinks = sortArrayOfObjectsByKeyValue(mediasWithLinks, "links");
+    const sortedMediasOther = sortArrayOfObjects(mediasOther, ["id"]);
+    const result = [
+        ...sortedMediasWithIds,
+        ...sortedMediasWithHashes,
+        ...sortedMediasWithLinks,
+        ...sortedMediasOther
+    ];
+    return result;
+};
+// Deprecated sortMediasForSpasmEventV2 because we only keep
+// a 'value' key to calculate Spasm ID 01.
+// export const sortMediasForSpasmid01 = sortMediasforSpasmEventV2
+export const sortReferencesForSpasmid01 = (references) => {
+    if (!references || !Array.isArray(references))
+        return [];
+    // Clean and sort IDs
+    references.forEach(reference => {
+        if (reference && typeof (reference) === "object" &&
+            'ids' in reference && reference.ids &&
+            Array.isArray(reference.ids) &&
+            reference.ids[0]) {
+            // Clean ids to keep only  'value' key
+            reference.ids = keepTheseKeysInObjectsInArray(reference.ids, ["value"]);
+            // Sort ids
+            reference.ids = sortArrayOfObjects(reference.ids, "value");
+        }
+    });
+    // Sort references based on IDs
+    const sortedReferences = sortArrayOfObjectsByKeyValue(references, "ids");
+    return sortedReferences;
+};
+export const sortParentForSpasmid01 = (parent) => {
+    if (!parent || typeof (parent) !== "object")
+        return parent;
+    // Clean and sort IDs
+    if (parent && typeof (parent) === "object" &&
+        'ids' in parent && parent.ids &&
+        Array.isArray(parent.ids) &&
+        parent.ids[0]) {
+        // Clean ids to keep only 'value' key
+        parent.ids = keepTheseKeysInObjectsInArray(parent.ids, ["value"]);
+        // Sort ids
+        parent.ids = sortArrayOfObjects(parent.ids, "value");
+    }
+    return parent;
+};
+export const sortTagsForSpasmid01 = (tags) => {
+    if (!tags || !Array.isArray(tags))
+        return [[]];
+    /**
+     * Tags are an array of arrays (e.g., Nostr tags).
+     * Each tag is an array with any number of elements.
+     * Some tags will have the same one-letter first element,
+     * so sorting by the first element is not a good approach.
+     * Instead, the current sorting logic for spasmid01 is
+     * to find the length of the longest tag array (e.g., 10),
+     * and start sorting tags by the 10th element, then
+     * by the 9th element, and continue until sorting is
+     * done by the first element.
+     *
+     * Each tag is an array of values. However, values inside
+     * each tag should not be sorted as it can affect the
+     * intention of the event. For example, the order of an
+     * element in a Nostr tag array has a meaning.
+     */
+    const sortTagsByElementNumber = (elementNumber = 0) => {
+        tags = tags.sort((a, b) => {
+            const key = elementNumber;
+            let aValue = "";
+            let bValue = "";
+            if (a[key]) {
+                if (typeof (a[key]) === 'string') {
+                    aValue = a[key];
+                }
+                else if (typeof (a[key]) === 'number') {
+                    aValue = String(a[key]);
+                }
+            }
+            if (b[key]) {
+                if (typeof (b[key]) === 'string') {
+                    bValue = b[key];
+                }
+                else if (typeof (b[key]) === 'number') {
+                    bValue = String(b[key]);
+                }
+            }
+            const compareResult = aValue.localeCompare(bValue);
+            if (compareResult !== 0) {
+                return compareResult;
+            }
+            return 0; // Equal
+        });
+    };
+    let longestTagArrayLength = 1;
+    // Find the longest array (tag) to be used for sorting.
+    tags.forEach(tag => {
+        if (tag && Array.isArray(tag) &&
+            tag.length > longestTagArrayLength) {
+            longestTagArrayLength = tag.length;
+        }
+    });
+    for (let i = longestTagArrayLength; i >= 0; i--) {
+        sortTagsByElementNumber(i);
+    }
+    return tags;
+};
+export const markSpasmEventAddressAsVerified = (spasmEvent, verifiedAddress, version = "2.0.0") => {
+    if (version === "2.0.0") {
+        if (spasmEvent.authors) {
+            spasmEvent.authors.forEach(author => {
+                if (author.addresses) {
+                    author.addresses.forEach(address => {
+                        if (address.value === verifiedAddress) {
+                            address.verified = true;
+                        }
+                    });
+                }
+            });
+        }
+    }
+};
+export const verifyEthereumSignature = (messageString, signature, signerAddress) => {
+    try {
+        if (signature && typeof (signature) === 'string') {
+            const recoveredAddress = ethers.verifyMessage(messageString, signature);
+            return recoveredAddress.toLowerCase() ===
+                signerAddress.toLowerCase();
+        }
+        return false;
+    }
+    catch (error) {
+        return false;
+    }
+};
+export const utilsStatus = () => {
+    console.log("spasm.js utils status: success");
+};
+// var sha256pure = function sha256(ascii) {
+//     function rightRotate(value, amount) {
+//         return (value>>>amount) | (value<<(32 - amount));
+//     };
+//
+//     var mathPow = Math.pow;
+//     var maxWord = mathPow(2, 32);
+//     var lengthProperty = 'length'
+//     var i, j; // Used as a counter across the whole file
+//     var result = ''
+//
+//     var words = [];
+//     var asciiBitLength = ascii[lengthProperty]*8;
+//
+//     /[> caching results is optional - remove/add slash from front of this line to toggle
+//     // Initial hash value: first 32 bits of the fractional parts of the square roots of the first 8 primes
+//     // (we actually calculate the first 64, but extra values are just ignored)
+//     var hash = sha256.h = sha256.h || [];
+//     // Round constants: first 32 bits of the fractional parts of the cube roots of the first 64 primes
+//     var k = sha256.k = sha256.k || [];
+//     var primeCounter = k[lengthProperty];
+//     [>/
+//     var hash = [], k = [];
+//     var primeCounter = 0;
+//     /[>/
+//
+//     var isComposite = {};
+//     for (var candidate = 2; primeCounter < 64; candidate++) {
+//         if (!isComposite[candidate]) {
+//             for (i = 0; i < 313; i += candidate) {
+//                 isComposite[i] = candidate;
+//             }
+//             hash[primeCounter] = (mathPow(candidate, .5)*maxWord)|0;
+//             k[primeCounter++] = (mathPow(candidate, 1/3)*maxWord)|0;
+//         }
+//     }
+//
+//     ascii += '\x80' // Append Ƈ' bit (plus zero padding)
+//     while (ascii[lengthProperty]%64 - 56) ascii += '\x00' // More zero padding
+//     for (i = 0; i < ascii[lengthProperty]; i++) {
+//         j = ascii.charCodeAt(i);
+//         if (j>>8) return; // ASCII check: only accept characters in range 0-255
+//         words[i>>2] |= j << ((3 - i)%4)*8;
+//     }
+//     words[words[lengthProperty]] = ((asciiBitLength/maxWord)|0);
+//     words[words[lengthProperty]] = (asciiBitLength)
+//
+//     // process each chunk
+//     for (j = 0; j < words[lengthProperty];) {
+//         var w = words.slice(j, j += 16); // The message is expanded into 64 words as part of the iteration
+//         var oldHash = hash;
+//         // This is now the undefinedworking hash", often labelled as variables a...g
+//         // (we have to truncate as well, otherwise extra entries at the end accumulate
+//         hash = hash.slice(0, 8);
+//
+//         for (i = 0; i < 64; i++) {
+//             // Typescript error: i2 value is never read
+//             var i2 = i + j;
+//             // Expand the message into 64 words
+//             // Used below if
+//             var w15 = w[i - 15], w2 = w[i - 2];
+//
+//             // Iterate
+//             var a = hash[0], e = hash[4];
+//             var temp1 = hash[7]
+//                 + (rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25)) // S1
+//                 + ((e&hash[5])^((~e)&hash[6])) // ch
+//                 + k[i]
+//                 // Expand the message schedule if needed
+//                 + (w[i] = (i < 16) ? w[i] : (
+//                         w[i - 16]
+//                         + (rightRotate(w15, 7) ^ rightRotate(w15, 18) ^ (w15>>>3)) // s0
+//                         + w[i - 7]
+//                         + (rightRotate(w2, 17) ^ rightRotate(w2, 19) ^ (w2>>>10)) // s1
+//                     )|0
+//                 );
+//             // This is only used once, so *could* be moved below, but it only saves 4 bytes and makes things unreadble
+//             var temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22)) // S0
+//                 + ((a&hash[1])^(a&hash[2])^(hash[1]&hash[2])); // maj
+//
+//             hash = [(temp1 + temp2)|0].concat(hash); // We don't bother trimming off the extra ones, they're harmless as long as we're truncating when we do the slice()
+//             hash[4] = (hash[4] + temp1)|0;
+//         }
+//
+//         for (i = 0; i < 8; i++) {
+//             hash[i] = (hash[i] + oldHash[i])|0;
+//         }
+//     }
+//
+//     for (i = 0; i < 8; i++) {
+//         for (j = 3; j + 1; j--) {
+//             var b = (hash[i]>>(j*8))&255;
+//             result += ((b < 16) ? 0 : '') + b.toString(16);
+//         }
+//     }
+//     return result;
+// };
 //# sourceMappingURL=utils.js.map