(function () {
    'use strict';

    // log provides a wrapper for console.log that prefixes '[libkernel]' to the
    // output.
    function log(...inputs) {
        console.log("[libkernel]", ...inputs);
    }
    // logErr provides a wrapper for console.error that prefixes '[libkernel]' to
    // the output.
    function logErr(...inputs) {
        console.error("[libkernel]", ...inputs);
    }

    // objAsString will try to return the provided object as a string. If the
    // object is already a string, it will be returned without modification. If the
    // object is an 'Error', the message of the error will be returned. If the object
    // has a toString method, the toString method will be called and the result
    // will be returned. If the object is null or undefined, a special string will
    // be returned indicating that the undefined/null object cannot be converted to
    // a string. In all other cases, JSON.stringify is used. If JSON.stringify
    // throws an exception, a message "[could not provide object as string]" will
    // be returned.
    //
    // NOTE: objAsString is intended to produce human readable output. It is lossy,
    // and it is not intended to be used for serialization.
    function objAsString(obj) {
        // Check for undefined input.
        if (obj === undefined) {
            return "[cannot convert undefined to string]";
        }
        if (obj === null) {
            return "[cannot convert null to string]";
        }
        // Parse the error into a string.
        if (typeof obj === "string") {
            return obj;
        }
        // Check if the object is an error, and return the message of the error if
        // so.
        if (obj instanceof Error) {
            return obj.message;
        }
        // Check if the object has a 'toString' method defined on it. To ensure
        // that we don't crash or throw, check that the toString is a function, and
        // also that the return value of toString is a string.
        if (Object.prototype.hasOwnProperty.call(obj, "toString")) {
            if (typeof obj.toString === "function") {
                const str = obj.toString();
                if (typeof str === "string") {
                    return str;
                }
            }
        }
        // If the object does not have a custom toString, attempt to perform a
        // JSON.stringify. We use a lot of bigints in libskynet, and calling
        // JSON.stringify on an object with a bigint will cause a throw, so we add
        // some custom handling to allow bigint objects to still be encoded.
        try {
            return JSON.stringify(obj, (_, v) => {
                if (typeof v === "bigint") {
                    return v.toString();
                }
                return v;
            });
        }
        catch (err) {
            if (err !== undefined && typeof err.message === "string") {
                return `[stringify failed]: ${err.message}`;
            }
            return "[stringify failed]";
        }
    }

    // addContextToErr is a helper function that standardizes the formatting of
    // adding context to an error.
    //
    // NOTE: To protect against accidental situations where an Error type or some
    // other type is provided instead of a string, we wrap both of the inputs with
    // objAsString before returning them. This prevents runtime failures.
    function addContextToErr$1(err, context) {
        if (err === null || err === undefined) {
            err = "[no error provided]";
        }
        return objAsString(context) + ": " + objAsString(err);
    }

    const MAX_UINT_64 = 18446744073709551615n;
    // bufToB64 will convert a Uint8Array to a base64 string with URL encoding and
    // no padding characters.
    function bufToB64$1(buf) {
        const b64Str = btoa(String.fromCharCode(...buf));
        return b64Str.replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
    }
    // encodeU64 will encode a bigint in the range of a uint64 to an 8 byte
    // Uint8Array.
    function encodeU64$1(num) {
        // Check the bounds on the bigint.
        if (num < 0) {
            return [new Uint8Array(0), "expected a positive integer"];
        }
        if (num > MAX_UINT_64) {
            return [new Uint8Array(0), "expected a number no larger than a uint64"];
        }
        // Encode the bigint into a Uint8Array.
        const encoded = new Uint8Array(8);
        for (let i = 0; i < encoded.length; i++) {
            const byte = Number(num & 0xffn);
            encoded[i] = byte;
            num = num >> 8n;
        }
        return [encoded, null];
    }

    const gfi$1 = function (init) {
        let i;
        const r = new Float64Array(16);
        if (init)
            for (i = 0; i < init.length; i++)
                r[i] = init[i];
        return r;
    };
    gfi$1([1]); gfi$1([
        0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f,
        0x6cee, 0x5203,
    ]); gfi$1([
        0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df,
        0xd9dc, 0x2406,
    ]); gfi$1([
        0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e,
        0x36d3, 0x2169,
    ]); gfi$1([
        0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666,
        0x6666, 0x6666,
    ]); gfi$1([
        0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1,
        0x2480, 0x2b83,
    ]);

    // checkObj take an untrusted object and a list of typechecks to perform and
    // will check that the object adheres to the typechecks. If a type is missing
    // or has the wrong type, an error will be returned. This is intended to be
    // used to check untrusted objects after they get decoded from JSON. This is
    // particularly useful when receiving objects from untrusted entities over the
    // network or over postMessage.
    //
    // Below is an example object, followed by the call that you would make to
    // checkObj to verify the object.
    //
    // const expectedObj = {
    //   aNum: 35,
    //   aStr: "hi",
    //   aBig: 10n,
    // };
    //
    // const err = checkObj(expectedObj, [
    //   ["aNum", "number"],
    //   ["aStr", "string"],
    //   ["aBig", "bigint"],
    // ]);
    function checkObj(obj, checks) {
        for (let i = 0; i < checks.length; i++) {
            const check = checks[i];
            const type = typeof obj[check[0]];
            if (type !== check[1]) {
                return "check failed, expecting " + check[1] + " got " + type;
            }
        }
        return null;
    }

    // Create the queryMap.
    let queries = {};
    // Define the nonce handling. nonceSeed is 16 random bytes that get generated
    // at init and serve as the baseline for creating random nonces. nonceCounter
    // tracks which messages have been sent. We hash together the nonceSeed and the
    // current nonceCounter to get a secure nonce.
    //
    // We need a secure nonce so that we know which messages from the kernel are
    // intended for us. There could be multiple pieces of independent code talking
    // to the kernel and using nonces, by having secure random nonces we can
    // guarantee that the applications will not use conflicting nonces.
    let nonceSeed;
    let nonceCounter;
    function initNonce() {
        nonceSeed = new Uint8Array(16);
        nonceCounter = 0;
        crypto.getRandomValues(nonceSeed);
    }
    // nextNonce will combine the nonceCounter with the nonceSeed to produce a
    // unique string that can be used as the nonce with the kernel.
    //
    // Note: the nonce is only ever going to be visible to the kernel and to other
    // code running in the same webpage, so we don't need to hash our nonceSeed. We
    // just need it to be unique, not undetectable.
    function nextNonce() {
        let nonceNum = nonceCounter;
        nonceCounter += 1;
        let [nonceNumBytes, err] = encodeU64$1(BigInt(nonceNum));
        if (err !== null) {
            // encodeU64 only fails if nonceNum is outside the bounds of a
            // uint64, which shouldn't happen ever.
            logErr("encodeU64 somehow failed", err);
        }
        let noncePreimage = new Uint8Array(nonceNumBytes.length + nonceSeed.length);
        noncePreimage.set(nonceNumBytes, 0);
        noncePreimage.set(nonceSeed, nonceNumBytes.length);
        return bufToB64$1(noncePreimage);
    }
    // Establish the handler for incoming messages.
    function handleMessage(event) {
        // Ignore all messages that aren't from approved kernel sources. The two
        // approved sources are skt.us and the browser extension bridge (which has
        // an event.source equal to 'window')
        if (event.source !== window && event.origin !== "https://skt.us") {
            return;
        }
        // Ignore any messages that don't have a method and data field.
        if (!("method" in event.data) || !("data" in event.data)) {
            return;
        }
        // Handle logging messages.
        if (event.data.method === "log") {
            // We display the logging message if the kernel is a browser
            // extension, so that the kernel's logs appear in the app
            // console as well as the extension console. If the kernel is
            // in an iframe, its logging messages will already be in the
            // app console and therefore don't need to be displayed.
            if (kernelOrigin === window.origin) {
                if (event.data.data.isErr) {
                    console.error(event.data.data.message);
                }
                else {
                    console.log(event.data.data.message);
                }
            }
            return;
        }
        // init is complete when the kernel sends us the auth status. If the
        // user is logged in, report success, otherwise return an error
        // indicating that the user is not logged in.
        if (event.data.method === "kernelAuthStatus") {
            // If we have received an auth status message, it means the bootloader
            // at a minimum is working.
            if (initResolved === false) {
                initResolved = true;
                // We can't actually establish that init is complete until the
                // kernel source has been set. This happens async and might happen
                // after we receive the auth message.
                sourcePromise.then(() => {
                    initResolve();
                });
            }
            // If the auth status message says that login is complete, it means
            // that the user is logged in.
            if (loginResolved === false && event.data.data.loginComplete === true) {
                loginResolved = true;
                loginResolve();
            }
            // If the auth status message says that the kernel loaded, it means
            // that the kernel is ready to receive messages.
            if (kernelLoadedResolved === false && event.data.data.kernelLoaded !== "not yet") {
                kernelLoadedResolved = true;
                if (event.data.data.kernelLoaded === "success") {
                    kernelLoadedResolve(null);
                }
                else {
                    kernelLoadedResolve(event.data.data.kernelLoaded);
                }
            }
            // If we have received a message indicating that the user has logged
            // out, we need to reload the page and reset the auth process.
            if (event.data.data.logoutComplete === true) {
                {
                    logoutResolve();
                }
                window.location.reload();
            }
            return;
        }
        // Check that the message sent has a nonce. We don't log
        // on failure because the message may have come from 'window', which
        // will happen if the app has other messages being sent to the window.
        if (!("nonce" in event.data)) {
            return;
        }
        // If we can't locate the nonce in the queries map, there is nothing to do.
        // This can happen especially for responseUpdate messages.
        if (!(event.data.nonce in queries)) {
            return;
        }
        let query = queries[event.data.nonce];
        // Handle a response. Once the response has been received, it is safe to
        // delete the query from the queries map.
        if (event.data.method === "response") {
            queries[event.data.nonce].resolve([event.data.data, event.data.err]);
            delete queries[event.data.nonce];
            return;
        }
        // Handle a response update.
        if (event.data.method === "responseUpdate") {
            // If no update handler was provided, there is nothing to do.
            if (typeof query.receiveUpdate === "function") {
                query.receiveUpdate(event.data.data);
            }
            return;
        }
        // Handle a responseNonce.
        if (event.data.method === "responseNonce") {
            if (typeof query.kernelNonceReceived === "function") {
                query.kernelNonceReceived(event.data.data.nonce);
            }
            return;
        }
        // Ignore any other messages as they might be from other applications.
    }
    // launchKernelFrame will launch the skt.us iframe that is used to connect to the
    // Skynet kernel if the kernel cannot be reached through the browser extension.
    function launchKernelFrame() {
        let iframe = document.createElement("iframe");
        iframe.src = "https://skt.us";
        iframe.width = "0";
        iframe.height = "0";
        iframe.style.border = "0";
        iframe.style.position = "absolute";
        document.body.appendChild(iframe);
        kernelSource = iframe.contentWindow;
        kernelOrigin = "https://skt.us";
        kernelAuthLocation = "https://skt.us/auth.html";
        sourceResolve();
        // Set a timer to fail the login process if the kernel doesn't load in
        // time.
        setTimeout(() => {
            if (initResolved === true) {
                return;
            }
            initResolved = true;
            initResolve("tried to open kernel in iframe, but hit a timeout");
        }, 24000);
    }
    // messageBridge will send a message to the bridge of the skynet extension to
    // see if it exists. If it does not respond or if it responds with an error,
    // messageBridge will open an iframe to skt.us and use that as the kernel.
    let kernelSource;
    let kernelOrigin;
    let kernelAuthLocation;
    function messageBridge() {
        // Establish the function that will handle the bridge's response.
        let bridgeInitComplete = false;
        let bridgeResolve = () => { }; // Need to set bridgeResolve here to make tsc happy
        let p = new Promise((resolve) => {
            bridgeResolve = resolve;
        });
        p.then(([, err]) => {
            // Check if the timeout already elapsed.
            if (bridgeInitComplete === true) {
                logErr("received response from bridge, but init already finished");
                return;
            }
            bridgeInitComplete = true;
            // Deconstruct the input and return if there's an error.
            if (err !== null) {
                logErr("bridge exists but returned an error", err);
                launchKernelFrame();
                return;
            }
            // Bridge has responded successfully, and there's no error.
            kernelSource = window;
            kernelOrigin = window.origin;
            kernelAuthLocation = "http://kernel.skynet/auth.html";
            console.log("established connection to bridge, using browser extension for kernel");
            sourceResolve();
        });
        // Add the handler to the queries map.
        let nonce = nextNonce();
        queries[nonce] = {
            resolve: bridgeResolve,
        };
        // Send a message to the bridge of the browser extension to determine
        // whether the bridge exists.
        window.postMessage({
            nonce,
            method: "kernelBridgeVersion",
        }, window.origin);
        // Set a timeout, if we do not hear back from the bridge in 500
        // milliseconds we assume that the bridge is not available.
        setTimeout(() => {
            // If we've already received and processed a message from the
            // bridge, there is nothing to do.
            if (bridgeInitComplete === true) {
                return;
            }
            bridgeInitComplete = true;
            log("browser extension not found, falling back to skt.us");
            launchKernelFrame();
        }, 500);
        return initPromise;
    }
    // init is a function that returns a promise which will resolve when
    // initialization is complete.
    //
    // The init / auth process has 5 stages. The first stage is that something
    // somewhere needs to call init(). It is safe to call init() multiple times,
    // thanks to the 'initialized' variable.
    let initialized = false; // set to true once 'init()' has been called
    let initResolved = false; // set to true once we know the bootloader is working
    let initResolve;
    let initPromise;
    let loginResolved = false; // set to true once we know the user is logged in
    let loginResolve;
    let loginPromise;
    let kernelLoadedResolved = false; // set to true once the user kernel is loaded
    let kernelLoadedResolve;
    let kernelLoadedPromise;
    let logoutResolve;
    let logoutPromise;
    let sourceResolve;
    let sourcePromise; // resolves when the source is known and set
    function init() {
        // If init has already been called, just return the init promise.
        if (initialized === true) {
            return initPromise;
        }
        initialized = true;
        // Run all of the init functions.
        initNonce();
        window.addEventListener("message", handleMessage);
        messageBridge();
        // Create the promises that resolve at various stages of the auth flow.
        initPromise = new Promise((resolve) => {
            initResolve = resolve;
        });
        loginPromise = new Promise((resolve) => {
            loginResolve = resolve;
        });
        kernelLoadedPromise = new Promise((resolve) => {
            kernelLoadedResolve = resolve;
        });
        logoutPromise = new Promise((resolve) => {
            logoutResolve = resolve;
        });
        sourcePromise = new Promise((resolve) => {
            sourceResolve = resolve;
        });
        // Return the initPromise, which will resolve when bootloader init is
        // complete.
        return initPromise;
    }
    // callModule is a generic function to call a module. The first input is the
    // module identifier (typically a skylink), the second input is the method
    // being called on the module, and the final input is optional and contains
    // input data to be passed to the module. The input data will depend on the
    // module and the method that is being called. The return value is an ErrTuple
    // that contains the module's response. The format of the response is an
    // arbitrary object whose fields depend on the module and method being called.
    //
    // callModule can only be used for query-response communication, there is no
    // support for sending or receiving updates.
    function callModule(module, method, data) {
        let moduleCallData = {
            module,
            method,
            data,
        };
        let [, query] = newKernelQuery("moduleCall", moduleCallData, false);
        return query;
    }
    // connectModule is the standard function to send a query to a module that can
    // optionally send and optionally receive updates. The first three inputs match
    // the inputs of 'callModule', and the fourth input is a function that will be
    // called any time that the module sends a responseUpdate. The receiveUpdate
    // function should have the following signature:
    //
    // 	`function receiveUpdate(data: any)`
    //
    // The structure of the data will depend on the module and method that was
    // queried.
    //
    // The first return value is a 'sendUpdate' function that can be called to send
    // a queryUpdate to the module. The sendUpdate function has the same signature
    // as the receiveUpdate function, it's an arbitrary object whose fields depend
    // on the module and method being queried.
    //
    // The second return value is a promise that returns an ErrTuple. It will
    // resolve when the module sends a response message, and works the same as the
    // return value of callModule.
    function connectModule(module, method, data, receiveUpdate) {
        let moduleCallData = {
            module,
            method,
            data,
        };
        return newKernelQuery("moduleCall", moduleCallData, true, receiveUpdate);
    }
    // newKernelQuery opens a query to the kernel. Details like postMessage
    // communication and nonce handling are all abstracted away by newKernelQuery.
    //
    // The first arg is the method that is being called on the kernel, and the
    // second arg is the data that will be sent to the kernel as input to the
    // method.
    //
    // The thrid arg is an optional function that can be passed in to receive
    // responseUpdates to the query. Not every query will send responseUpdates, and
    // most responseUpdates can be ignored, but sometimes contain useful
    // information like download progress.
    //
    // The first output is a 'sendUpdate' function that can be called to send a
    // queryUpdate. The second output is a promise that will resolve when the query
    // receives a response message. Once the response message has been received, no
    // more updates can be sent or received.
    function newKernelQuery(method, data, sendUpdates, receiveUpdate) {
        // NOTE: The implementation here is gnarly, because I didn't want to use
        // async/await (that decision should be left to the caller) and I also
        // wanted this function to work correctly even if init() had not been
        // called yet.
        //
        // This function returns a sendUpdate function along with a promise, so we
        // can't simply wrap everything in a basic promise. The sendUpdate function
        // has to block internally until all of the setup is complete, and then we
        // can't send a query until all of the setup is complete, and the setup
        // cylce has multiple dependencies and therefore we get a few promises that
        // all depend on each other.
        //
        // Using async/await here actually breaks certain usage patterns (or at
        // least makes them much more difficult to use correctly). The standard way
        // to establish duplex communication using connectModule is to define a
        // variable 'sendUpdate' before defining the function 'receiveUpdate', and
        // then setting 'sendUpdate' equal to the first return value of
        // 'connectModue'. It looks like this:
        //
        // let sendUpdate;
        // let receiveUpdate = function(data: any) {
        //     if (data.needsUpdate) {
        //         sendUpdate(someUpdate)
        //     }
        // }
        // let [sendUpdateFn, response] = connectModule(x, y, z, receiveUpdate)
        // sendUpdate = sendUpdateFn
        //
        // If we use async/await, it's not safe to set sendUpdate after
        // connectModule returns because 'receiveUpdate' may be called before
        // 'sendUpdate' is set. You can fix that by using a promise, but it's a
        // complicated fix and we want this library to be usable by less
        // experienced developers.
        //
        // Therefore, we make an implementation tradeoff here and avoid async/await
        // at the cost of having a bunch of complicated promise chaining.
        // Create a promise that will resolve once the nonce is available. We
        // cannot get the nonce until init() is complete. getNonce therefore
        // implies that init is complete.
        let getNonce = new Promise((resolve) => {
            init().then(() => {
                kernelLoadedPromise.then(() => {
                    resolve(nextNonce());
                });
            });
        });
        // Two promises are being created at once here. Once is 'p', which will be
        // returned to the caller of newKernelQuery and will be resolved when the
        // kernel provides a 'response' message. The other is for internal use and
        // will resolve once the query has been created.
        let p;
        let haveQueryCreated = new Promise((queryCreatedResolve) => {
            p = new Promise((resolve) => {
                getNonce.then((nonce) => {
                    queries[nonce] = { resolve };
                    if (receiveUpdate !== null && receiveUpdate !== undefined) {
                        queries[nonce]["receiveUpdate"] = receiveUpdate;
                    }
                    queryCreatedResolve(nonce);
                });
            });
        });
        // Create a promise that will be resolved once we are ready to receive the
        // kernelNonce. We won't be ready to receive the kernel nonce until after
        // the queries[nonce] object has been created.
        let readyForKernelNonce;
        let getReadyForKernelNonce = new Promise((resolve) => {
            readyForKernelNonce = resolve;
        });
        // Create the sendUpdate function. It defaults to doing nothing. After the
        // sendUpdate function is ready to receive the kernelNonce, resolve the
        // promise that blocks until the sendUpdate function is ready to receive
        // the kernel nonce.
        let sendUpdate;
        if (sendUpdates !== true) {
            sendUpdate = () => { };
            readyForKernelNonce(); // We won't get a kernel nonce, no reason to block.
        }
        else {
            // sendUpdate will send an update to the kernel. The update can't be
            // sent until the kernel nonce is known. Create a promise that will
            // resolve when the kernel nonce is known.
            //
            // This promise cannot itself be created until the queries[nonce]
            // object has been created, so block for the query to be created.
            let blockForKernelNonce = new Promise((resolve) => {
                haveQueryCreated.then((nonce) => {
                    queries[nonce]["kernelNonceReceived"] = resolve;
                    readyForKernelNonce();
                });
            });
            // The sendUpdate function needs both the local nonce and also the
            // kernel nonce. Block for both. Having the kernel nonce implies that
            // the local nonce is ready, therefore start by blocking for the kernel
            // nonce.
            sendUpdate = function (updateData) {
                blockForKernelNonce.then((nonce) => {
                    kernelSource.postMessage({
                        method: "queryUpdate",
                        nonce,
                        data: updateData,
                    }, kernelOrigin);
                });
            };
        }
        // Prepare to send the query to the kernel. The query cannot be sent until
        // the queries object is created and also we are ready to receive the
        // kernel nonce.
        haveQueryCreated.then((nonce) => {
            getReadyForKernelNonce.then(() => {
                // There are two types of messages we can send depending on whether
                // we are talking to skt.us or the background script.
                let kernelMessage = {
                    method,
                    nonce,
                    data,
                    sendKernelNonce: sendUpdates,
                };
                let backgroundMessage = {
                    method: "newKernelQuery",
                    nonce,
                    data: kernelMessage,
                };
                // The message structure needs to adjust based on whether we are
                // talking directly to the kernel or whether we are talking to the
                // background page.
                if (kernelOrigin === "https://skt.us") {
                    kernelSource.postMessage(kernelMessage, kernelOrigin);
                }
                else {
                    kernelSource.postMessage(backgroundMessage, kernelOrigin);
                }
            });
        });
        // Return sendUpdate and the promise. sendUpdate is already set to block
        // until all the necessary prereqs are complete.
        return [sendUpdate, p];
    }

    // There are 5 stages of auth.
    //
    // Stage 0: Bootloader is not loaded.
    // Stage 1: Bootloader is loaded, user is not logged in.
    // Stage 2: Bootloader is loaded, user is logged in.
    // Stage 3: Kernel is loaded, user is logged in.
    // Stage 4: Kernel is loaded, user is logged out.
    //
    // init() will block until auth has reached stage 1. If the user is already
    // logged in from a previous session, auth will immediately progress to stage
    // 2.
    //
    // loginComplete() will block until auth has reached stage 2. The kernel is not
    // ready to receive messages yet, but apps do not need to present users with a
    // login dialog.
    //
    // kernelLoaded() will block until auth has reached stage 3. kernelLoaded()
    // returns a promise that can resolve with an error. If there was an error, it
    // means the kernel could not be loaded and cannot be used.
    //
    // logoutComplete() will block until auth has reached stage 4. libkernel does
    // not support resetting the auth stages, once stage 4 has been reached the app
    // needs to refresh.
    // loginComplete will resolve when the user has successfully logged in.
    function loginComplete() {
        return loginPromise;
    }
    // kernelLoaded will resolve when the user has successfully loaded the kernel.
    // If there was an error in loading the kernel, the error will be returned.
    //
    // NOTE: kernelLoaded will not resolve until after loginComplete has resolved.
    function kernelLoaded() {
        return kernelLoadedPromise;
    }
    // logoutComplete will resolve when the user has logged out. Note that
    // logoutComplete will only resolve if the user logged in first - if the user
    // was not logged in to begin with, this promise will not resolve.
    function logoutComplete() {
        return logoutPromise;
    }
    // openAuthWindow is intended to be used as an onclick target when the user
    // clicks the 'login' button on a skynet application. It will block until the
    // auth location is known, and then it will pop open the correct auth window
    // for the user.
    //
    // NOTE: openAuthWindow will only open a window if the user is not already
    // logged in. If the user is already logged in, this function is a no-op.
    //
    // NOTE: When using this function, you probably want to have your login button
    // faded out or presenting the user with a spinner until init() resolves. In
    // the worst case (user has no browser extension, and is on a slow internet
    // connection) this could take multiple seconds.
    function openAuthWindow() {
        // openAuthWindow doesn't care what the auth status is, it's just trying to
        // open the right window.
        init().then(() => {
            window.open(kernelAuthLocation, "_blank");
        });
    }

    // download will take a skylink and return the file data for that skylink. The
    // download occurs using a kernel module that verifies the data's integrity and
    // prevents the portal from lying about the download.
    function download(skylink) {
        return new Promise((resolve) => {
            let downloadModule = "AQCIaQ0P-r6FwPEDq3auCZiuH_jqrHfqRcY7TjZ136Z_Yw";
            let data = {
                skylink,
            };
            callModule(downloadModule, "secureDownload", data).then(([result, err]) => {
                // Pull the fileData out of the result.
                if (err !== null) {
                    resolve([new Uint8Array(0), addContextToErr$1(err, "unable to complete download")]);
                    return;
                }
                resolve([result.fileData, null]);
            });
        });
    }

    // registryRead will perform a registry read on a portal. readEntry does not
    // guarantee that the latest revision has been provided, however it does
    // guarantee that the provided data has a matching signature.
    //
    // registryRead returns the full registry entry object provided by the module
    // because the object is relatively complex and all of the fields are more or
    // less required.
    function registryRead(publicKey, dataKey) {
        return new Promise((resolve) => {
            let registryModule = "AQCovesg1AXUzKXLeRzQFILbjYMKr_rvNLsNhdq5GbYb2Q";
            let data = {
                publicKey,
                dataKey,
            };
            callModule(registryModule, "readEntry", data).then(([result, err]) => {
                if (err !== null) {
                    resolve([{}, addContextToErr$1(err, "readEntry module call failed")]);
                    return;
                }
                resolve([
                    {
                        exists: result.exists,
                        entryData: result.entryData,
                        revision: result.revision,
                    },
                    null,
                ]);
            });
        });
    }
    // registryWrite will perform a registry write on a portal.
    //
    // registryWrite is not considered a safe function, there are easy ways to
    // misuse registryWrite such that user data will be lost. We recommend using a
    // safe set of functions for writing to the registry such as getsetjson.
    function registryWrite(keypair, dataKey, entryData, revision) {
        return new Promise((resolve) => {
            let registryModule = "AQCovesg1AXUzKXLeRzQFILbjYMKr_rvNLsNhdq5GbYb2Q";
            let callData = {
                publicKey: keypair.publicKey,
                secretKey: keypair.secretKey,
                dataKey,
                entryData,
                revision,
            };
            callModule(registryModule, "writeEntry", callData).then(([result, err]) => {
                if (err !== null) {
                    resolve(["", err]);
                    return;
                }
                resolve([result.entryID, null]);
            });
        });
    }

    // upload will take a filename and some file data and perform a secure upload
    // to Skynet. All data is verified and the correct Skylink is returned. This
    // function cannot fully guarantee that the data was pinned, but it can fully
    // guarantee that the final skylink matches the data that was presented for the
    // upload.
    function upload(filename, fileData) {
        return new Promise((resolve) => {
            // Prepare the module call.
            let uploadModule = "AQAT_a0MzOInZoJzt1CwBM2U8oQ3GIfP5yKKJu8Un-SfNg";
            let data = {
                filename,
                fileData,
            };
            callModule(uploadModule, "secureUpload", data).then(([result, err]) => {
                // Pull the skylink out of the result.
                if (err !== null) {
                    resolve(["", addContextToErr$1(err, "uable to complete upload")]);
                    return;
                }
                resolve([result.skylink, null]);
            });
        });
    }

    // kernelVersion will fetch the version number of the kernel. If successful,
    // the returned value will be an object containing a field 'version' with a
    // version string, and a 'distribtion' field with a string that states the
    // distribution of the kernel".
    function kernelVersion() {
        return new Promise((resolve) => {
            let [, query] = newKernelQuery("version", {}, false);
            query.then(([result, err]) => {
                if (err !== null) {
                    resolve(["", "", err]);
                    return;
                }
                resolve([result.version, result.distribution, err]);
            });
        });
    }

    var kernel = /*#__PURE__*/Object.freeze({
        __proto__: null,
        kernelLoaded: kernelLoaded,
        loginComplete: loginComplete,
        logoutComplete: logoutComplete,
        openAuthWindow: openAuthWindow,
        download: download,
        registryRead: registryRead,
        registryWrite: registryWrite,
        upload: upload,
        kernelVersion: kernelVersion,
        callModule: callModule,
        connectModule: connectModule,
        init: init,
        newKernelQuery: newKernelQuery,
        addContextToErr: addContextToErr$1,
        checkObj: checkObj
    });

    // Blake2B, adapted from the reference implementation in RFC7693
    // Ported to Javascript by DC - https://github.com/dcposch
    // Then ported to typescript by https://github.com/DavidVorick
    // 64-bit unsigned addition
    // Sets v[a,a+1] += v[b,b+1]
    // v should be a Uint32Array
    function ADD64AA(v, a, b) {
        const o0 = v[a] + v[b];
        let o1 = v[a + 1] + v[b + 1];
        if (o0 >= 0x100000000) {
            o1++;
        }
        v[a] = o0;
        v[a + 1] = o1;
    }
    // 64-bit unsigned addition
    // Sets v[a,a+1] += b
    // b0 is the low 32 bits of b, b1 represents the high 32 bits
    function ADD64AC(v, a, b0, b1) {
        let o0 = v[a] + b0;
        if (b0 < 0) {
            o0 += 0x100000000;
        }
        let o1 = v[a + 1] + b1;
        if (o0 >= 0x100000000) {
            o1++;
        }
        v[a] = o0;
        v[a + 1] = o1;
    }
    // Little-endian byte access
    function B2B_GET32(arr, i) {
        return arr[i] ^ (arr[i + 1] << 8) ^ (arr[i + 2] << 16) ^ (arr[i + 3] << 24);
    }
    // G Mixing function
    // The ROTRs are inlined for speed
    function B2B_G(a, b, c, d, ix, iy, m, v) {
        const x0 = m[ix];
        const x1 = m[ix + 1];
        const y0 = m[iy];
        const y1 = m[iy + 1];
        ADD64AA(v, a, b); // v[a,a+1] += v[b,b+1] ... in JS we must store a uint64 as two uint32s
        ADD64AC(v, a, x0, x1); // v[a, a+1] += x ... x0 is the low 32 bits of x, x1 is the high 32 bits
        // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated to the right by 32 bits
        let xor0 = v[d] ^ v[a];
        let xor1 = v[d + 1] ^ v[a + 1];
        v[d] = xor1;
        v[d + 1] = xor0;
        ADD64AA(v, c, d);
        // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 24 bits
        xor0 = v[b] ^ v[c];
        xor1 = v[b + 1] ^ v[c + 1];
        v[b] = (xor0 >>> 24) ^ (xor1 << 8);
        v[b + 1] = (xor1 >>> 24) ^ (xor0 << 8);
        ADD64AA(v, a, b);
        ADD64AC(v, a, y0, y1);
        // v[d,d+1] = (v[d,d+1] xor v[a,a+1]) rotated right by 16 bits
        xor0 = v[d] ^ v[a];
        xor1 = v[d + 1] ^ v[a + 1];
        v[d] = (xor0 >>> 16) ^ (xor1 << 16);
        v[d + 1] = (xor1 >>> 16) ^ (xor0 << 16);
        ADD64AA(v, c, d);
        // v[b,b+1] = (v[b,b+1] xor v[c,c+1]) rotated right by 63 bits
        xor0 = v[b] ^ v[c];
        xor1 = v[b + 1] ^ v[c + 1];
        v[b] = (xor1 >>> 31) ^ (xor0 << 1);
        v[b + 1] = (xor0 >>> 31) ^ (xor1 << 1);
    }
    // Initialization Vector
    const BLAKE2B_IV32 = new Uint32Array([
        0xf3bcc908, 0x6a09e667, 0x84caa73b, 0xbb67ae85, 0xfe94f82b, 0x3c6ef372, 0x5f1d36f1, 0xa54ff53a, 0xade682d1,
        0x510e527f, 0x2b3e6c1f, 0x9b05688c, 0xfb41bd6b, 0x1f83d9ab, 0x137e2179, 0x5be0cd19,
    ]);
    const SIGMA8 = [
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3, 11, 8, 12,
        0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4, 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8, 9, 0, 5, 7, 2, 4, 10,
        15, 14, 1, 11, 12, 6, 8, 3, 13, 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9, 12, 5, 1, 15, 14, 13, 4, 10, 0,
        7, 6, 3, 9, 2, 8, 11, 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10, 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7,
        1, 4, 10, 5, 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
        15, 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
    ];
    // These are offsets into a uint64 buffer.
    // Multiply them all by 2 to make them offsets into a uint32 buffer,
    // because this is Javascript and we don't have uint64s
    const SIGMA82 = new Uint8Array(SIGMA8.map(function (x) {
        return x * 2;
    }));
    // Compression function. 'last' flag indicates last block.
    // Note we're representing 16 uint64s as 32 uint32s
    function blake2bCompress(ctx, last) {
        const v = new Uint32Array(32);
        const m = new Uint32Array(32);
        let i = 0;
        // init work variables
        for (i = 0; i < 16; i++) {
            v[i] = ctx.h[i];
            v[i + 16] = BLAKE2B_IV32[i];
        }
        // low 64 bits of offset
        v[24] = v[24] ^ ctx.t;
        v[25] = v[25] ^ (ctx.t / 0x100000000);
        // high 64 bits not supported, offset may not be higher than 2**53-1
        // last block flag set ?
        if (last) {
            v[28] = ~v[28];
            v[29] = ~v[29];
        }
        // get little-endian words
        for (i = 0; i < 32; i++) {
            m[i] = B2B_GET32(ctx.b, 4 * i);
        }
        // twelve rounds of mixing
        for (i = 0; i < 12; i++) {
            B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1], m, v);
            B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3], m, v);
            B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5], m, v);
            B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7], m, v);
            B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9], m, v);
            B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11], m, v);
            B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13], m, v);
            B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15], m, v);
        }
        for (i = 0; i < 16; i++) {
            ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16];
        }
    }
    // Creates a BLAKE2b hashing context
    // Requires an output length between 1 and 64 bytes
    function blake2bInit() {
        // state, 'param block'
        const ctx = {
            b: new Uint8Array(128),
            h: new Uint32Array(16),
            t: 0,
            c: 0,
            outlen: 32, // output length in bytes
        };
        // initialize hash state
        for (let i = 0; i < 16; i++) {
            ctx.h[i] = BLAKE2B_IV32[i];
        }
        ctx.h[0] ^= 0x01010000 ^ 32;
        return ctx;
    }
    // Updates a BLAKE2b streaming hash
    // Requires hash context and Uint8Array (byte array)
    function blake2bUpdate(ctx, input) {
        for (let i = 0; i < input.length; i++) {
            if (ctx.c === 128) {
                // buffer full ?
                ctx.t += ctx.c; // add counters
                blake2bCompress(ctx, false); // compress (not last)
                ctx.c = 0; // counter to zero
            }
            ctx.b[ctx.c++] = input[i];
        }
    }
    // Completes a BLAKE2b streaming hash
    // Returns a Uint8Array containing the message digest
    function blake2bFinal(ctx) {
        ctx.t += ctx.c; // mark last block offset
        while (ctx.c < 128) {
            // fill up with zeros
            ctx.b[ctx.c++] = 0;
        }
        blake2bCompress(ctx, true); // final block flag = 1
        // little endian convert and store
        const out = new Uint8Array(ctx.outlen);
        for (let i = 0; i < ctx.outlen; i++) {
            out[i] = ctx.h[i >> 2] >> (8 * (i & 3));
        }
        return out;
    }
    // Computes the blake2b hash of the input. Returns 32 bytes.
    let blake2b = function (input) {
        const ctx = blake2bInit();
        blake2bUpdate(ctx, input);
        return blake2bFinal(ctx);
    };

    const defaultPortalList = ["https://siasky.net", "https://web3portal.com"];

    // DICTIONARY_UNIQUE_PREFIX defines the number of characters that are
    // guaranteed to be unique for each word in the dictionary. The seed code only
    // looks at these three characters when parsing a word, allowing users to make
    // substitutions for words if they prefer or find it easier to memorize.
    const DICTIONARY_UNIQUE_PREFIX = 3;
    // dictionary contains the word list for the mysky seed.
    const dictionary = [
        "abbey",
        "ablaze",
        "abort",
        "absorb",
        "abyss",
        "aces",
        "aching",
        "acidic",
        "across",
        "acumen",
        "adapt",
        "adept",
        "adjust",
        "adopt",
        "adult",
        "aerial",
        "afar",
        "affair",
        "afield",
        "afloat",
        "afoot",
        "afraid",
        "after",
        "agenda",
        "agile",
        "aglow",
        "agony",
        "agreed",
        "ahead",
        "aided",
        "aisle",
        "ajar",
        "akin",
        "alarms",
        "album",
        "alerts",
        "alley",
        "almost",
        "aloof",
        "alpine",
        "also",
        "alumni",
        "always",
        "amaze",
        "ambush",
        "amidst",
        "ammo",
        "among",
        "amply",
        "amused",
        "anchor",
        "angled",
        "ankle",
        "antics",
        "anvil",
        "apart",
        "apex",
        "aphid",
        "aplomb",
        "apply",
        "archer",
        "ardent",
        "arena",
        "argue",
        "arises",
        "army",
        "around",
        "arrow",
        "ascend",
        "aside",
        "asked",
        "asleep",
        "aspire",
        "asylum",
        "atlas",
        "atom",
        "atrium",
        "attire",
        "auburn",
        "audio",
        "august",
        "aunt",
        "autumn",
        "avatar",
        "avidly",
        "avoid",
        "awful",
        "awning",
        "awoken",
        "axes",
        "axis",
        "axle",
        "aztec",
        "azure",
        "baby",
        "bacon",
        "badge",
        "bailed",
        "bakery",
        "bamboo",
        "banjo",
        "basin",
        "batch",
        "bawled",
        "bays",
        "beer",
        "befit",
        "begun",
        "behind",
        "being",
        "below",
        "bested",
        "bevel",
        "beware",
        "beyond",
        "bias",
        "bids",
        "bikini",
        "birth",
        "bite",
        "blip",
        "boat",
        "bodies",
        "bogeys",
        "boil",
        "boldly",
        "bomb",
        "border",
        "boss",
        "both",
        "bovine",
        "boxes",
        "broken",
        "brunt",
        "bubble",
        "budget",
        "buffet",
        "bugs",
        "bulb",
        "bumper",
        "bunch",
        "butter",
        "buying",
        "buzzer",
        "byline",
        "bypass",
        "cabin",
        "cactus",
        "cadets",
        "cafe",
        "cage",
        "cajun",
        "cake",
        "camp",
        "candy",
        "casket",
        "catch",
        "cause",
        "cease",
        "cedar",
        "cell",
        "cement",
        "cent",
        "chrome",
        "cider",
        "cigar",
        "cinema",
        "circle",
        "claim",
        "click",
        "clue",
        "coal",
        "cobra",
        "cocoa",
        "code",
        "coffee",
        "cogs",
        "coils",
        "colony",
        "comb",
        "cool",
        "copy",
        "cousin",
        "cowl",
        "cube",
        "cuffs",
        "custom",
        "dads",
        "daft",
        "dagger",
        "daily",
        "damp",
        "dapper",
        "darted",
        "dash",
        "dating",
        "dawn",
        "dazed",
        "debut",
        "decay",
        "deftly",
        "deity",
        "dented",
        "depth",
        "desk",
        "devoid",
        "dice",
        "diet",
        "digit",
        "dilute",
        "dime",
        "dinner",
        "diode",
        "ditch",
        "divers",
        "dizzy",
        "doctor",
        "dodge",
        "does",
        "dogs",
        "doing",
        "donuts",
        "dosage",
        "dotted",
        "double",
        "dove",
        "down",
        "dozen",
        "dreams",
        "drinks",
        "drunk",
        "drying",
        "dual",
        "dubbed",
        "dude",
        "duets",
        "duke",
        "dummy",
        "dunes",
        "duplex",
        "dusted",
        "duties",
        "dwarf",
        "dwelt",
        "dying",
        "each",
        "eagle",
        "earth",
        "easy",
        "eating",
        "echo",
        "eden",
        "edgy",
        "edited",
        "eels",
        "eggs",
        "eight",
        "either",
        "eject",
        "elapse",
        "elbow",
        "eldest",
        "eleven",
        "elite",
        "elope",
        "else",
        "eluded",
        "emails",
        "ember",
        "emerge",
        "emit",
        "empty",
        "energy",
        "enigma",
        "enjoy",
        "enlist",
        "enmity",
        "enough",
        "ensign",
        "envy",
        "epoxy",
        "equip",
        "erase",
        "error",
        "estate",
        "etched",
        "ethics",
        "excess",
        "exhale",
        "exit",
        "exotic",
        "extra",
        "exult",
        "fading",
        "faked",
        "fall",
        "family",
        "fancy",
        "fatal",
        "faulty",
        "fawns",
        "faxed",
        "fazed",
        "feast",
        "feel",
        "feline",
        "fences",
        "ferry",
        "fever",
        "fewest",
        "fiat",
        "fibula",
        "fidget",
        "fierce",
        "fight",
        "films",
        "firm",
        "five",
        "fixate",
        "fizzle",
        "fleet",
        "flying",
        "foamy",
        "focus",
        "foes",
        "foggy",
        "foiled",
        "fonts",
        "fossil",
        "fowls",
        "foxes",
        "foyer",
        "framed",
        "frown",
        "fruit",
        "frying",
        "fudge",
        "fuel",
        "fully",
        "fuming",
        "fungal",
        "future",
        "fuzzy",
        "gables",
        "gadget",
        "gags",
        "gained",
        "galaxy",
        "gambit",
        "gang",
        "gasp",
        "gather",
        "gauze",
        "gave",
        "gawk",
        "gaze",
        "gecko",
        "geek",
        "gels",
        "germs",
        "geyser",
        "ghetto",
        "ghost",
        "giant",
        "giddy",
        "gifts",
        "gills",
        "ginger",
        "girth",
        "giving",
        "glass",
        "glide",
        "gnaw",
        "gnome",
        "goat",
        "goblet",
        "goes",
        "going",
        "gone",
        "gopher",
        "gossip",
        "gotten",
        "gown",
        "grunt",
        "guest",
        "guide",
        "gulp",
        "guru",
        "gusts",
        "gutter",
        "guys",
        "gypsy",
        "gyrate",
        "hairy",
        "having",
        "hawk",
        "hazard",
        "heels",
        "hefty",
        "height",
        "hence",
        "heron",
        "hiding",
        "hijack",
        "hiker",
        "hills",
        "hinder",
        "hippo",
        "hire",
        "hive",
        "hoax",
        "hobby",
        "hockey",
        "hold",
        "honked",
        "hookup",
        "hope",
        "hornet",
        "hotel",
        "hover",
        "howls",
        "huddle",
        "huge",
        "hull",
        "humid",
        "hunter",
        "huts",
        "hybrid",
        "hyper",
        "icing",
        "icon",
        "idiom",
        "idled",
        "idols",
        "igloo",
        "ignore",
        "iguana",
        "impel",
        "incur",
        "injury",
        "inline",
        "inmate",
        "input",
        "insult",
        "invoke",
        "ionic",
        "irate",
        "iris",
        "irony",
        "island",
        "issued",
        "itches",
        "items",
        "itself",
        "ivory",
        "jabbed",
        "jaded",
        "jagged",
        "jailed",
        "jargon",
        "jaunt",
        "jaws",
        "jazz",
        "jeans",
        "jeers",
        "jester",
        "jewels",
        "jigsaw",
        "jingle",
        "jive",
        "jobs",
        "jockey",
        "jogger",
        "joking",
        "jolted",
        "jostle",
        "joyous",
        "judge",
        "juicy",
        "july",
        "jump",
        "junk",
        "jury",
        "karate",
        "keep",
        "kennel",
        "kept",
        "kettle",
        "king",
        "kiosk",
        "kisses",
        "kiwi",
        "knee",
        "knife",
        "koala",
        "ladder",
        "lagoon",
        "lair",
        "lakes",
        "lamb",
        "laptop",
        "large",
        "last",
        "later",
        "lava",
        "layout",
        "lazy",
        "ledge",
        "leech",
        "left",
        "legion",
        "lemon",
        "lesson",
        "liar",
        "licks",
        "lids",
        "lied",
        "light",
        "lilac",
        "limits",
        "linen",
        "lion",
        "liquid",
        "listen",
        "lively",
        "loaded",
        "locker",
        "lodge",
        "lofty",
        "logic",
        "long",
        "lopped",
        "losing",
        "loudly",
        "love",
        "lower",
        "loyal",
        "lucky",
        "lumber",
        "lunar",
        "lurk",
        "lush",
        "luxury",
        "lymph",
        "lynx",
        "lyrics",
        "macro",
        "mailed",
        "major",
        "makeup",
        "malady",
        "mammal",
        "maps",
        "match",
        "maul",
        "mayor",
        "maze",
        "meant",
        "memoir",
        "menu",
        "merger",
        "mesh",
        "metro",
        "mews",
        "mice",
        "midst",
        "mighty",
        "mime",
        "mirror",
        "misery",
        "moat",
        "mobile",
        "mocked",
        "mohawk",
        "molten",
        "moment",
        "money",
        "moon",
        "mops",
        "morsel",
        "mostly",
        "mouth",
        "mowing",
        "much",
        "muddy",
        "muffin",
        "mugged",
        "mullet",
        "mumble",
        "muppet",
        "mural",
        "muzzle",
        "myriad",
        "myth",
        "nagged",
        "nail",
        "names",
        "nanny",
        "napkin",
        "nasty",
        "navy",
        "nearby",
        "needed",
        "neon",
        "nephew",
        "nerves",
        "nestle",
        "never",
        "newt",
        "nexus",
        "nibs",
        "niche",
        "niece",
        "nifty",
        "nimbly",
        "nobody",
        "nodes",
        "noises",
        "nomad",
        "noted",
        "nouns",
        "nozzle",
        "nuance",
        "nudged",
        "nugget",
        "null",
        "number",
        "nuns",
        "nurse",
        "nylon",
        "oaks",
        "oars",
        "oasis",
        "object",
        "occur",
        "ocean",
        "odds",
        "offend",
        "often",
        "okay",
        "older",
        "olive",
        "omega",
        "onion",
        "online",
        "onto",
        "onward",
        "oozed",
        "opened",
        "opus",
        "orange",
        "orbit",
        "orchid",
        "orders",
        "organs",
        "origin",
        "oscar",
        "otter",
        "ouch",
        "ought",
        "ounce",
        "oust",
        "oval",
        "oven",
        "owed",
        "owls",
        "owner",
        "oxygen",
        "oyster",
        "ozone",
        "pact",
        "pager",
        "palace",
        "paper",
        "pastry",
        "patio",
        "pause",
        "peeled",
        "pegs",
        "pencil",
        "people",
        "pepper",
        "pests",
        "petals",
        "phase",
        "phone",
        "piano",
        "picked",
        "pierce",
        "pimple",
        "pirate",
        "pivot",
        "pixels",
        "pizza",
        "pledge",
        "pliers",
        "plus",
        "poetry",
        "point",
        "poker",
        "polar",
        "ponies",
        "pool",
        "potato",
        "pouch",
        "powder",
        "pram",
        "pride",
        "pruned",
        "prying",
        "public",
        "puck",
        "puddle",
        "puffin",
        "pulp",
        "punch",
        "puppy",
        "purged",
        "push",
        "putty",
        "pylons",
        "python",
        "queen",
        "quick",
        "quote",
        "radar",
        "rafts",
        "rage",
        "raking",
        "rally",
        "ramped",
        "rapid",
        "rarest",
        "rash",
        "rated",
        "ravine",
        "rays",
        "razor",
        "react",
        "rebel",
        "recipe",
        "reduce",
        "reef",
        "refer",
        "reheat",
        "relic",
        "remedy",
        "repent",
        "reruns",
        "rest",
        "return",
        "revamp",
        "rewind",
        "rhino",
        "rhythm",
        "ribbon",
        "richly",
        "ridges",
        "rift",
        "rigid",
        "rims",
        "riots",
        "ripped",
        "rising",
        "ritual",
        "river",
        "roared",
        "robot",
        "rodent",
        "rogue",
        "roles",
        "roomy",
        "roped",
        "roster",
        "rotate",
        "rover",
        "royal",
        "ruby",
        "rudely",
        "rugged",
        "ruined",
        "ruling",
        "rumble",
        "runway",
        "rural",
        "sack",
        "safety",
        "saga",
        "sailor",
        "sake",
        "salads",
        "sample",
        "sanity",
        "sash",
        "satin",
        "saved",
        "scenic",
        "school",
        "scoop",
        "scrub",
        "scuba",
        "second",
        "sedan",
        "seeded",
        "setup",
        "sewage",
        "sieve",
        "silk",
        "sipped",
        "siren",
        "sizes",
        "skater",
        "skew",
        "skulls",
        "slid",
        "slower",
        "slug",
        "smash",
        "smog",
        "snake",
        "sneeze",
        "sniff",
        "snout",
        "snug",
        "soapy",
        "sober",
        "soccer",
        "soda",
        "soggy",
        "soil",
        "solved",
        "sonic",
        "soothe",
        "sorry",
        "sowed",
        "soya",
        "space",
        "speedy",
        "sphere",
        "spout",
        "sprig",
        "spud",
        "spying",
        "square",
        "stick",
        "subtly",
        "suede",
        "sugar",
        "summon",
        "sunken",
        "surfer",
        "sushi",
        "suture",
        "swept",
        "sword",
        "swung",
        "system",
        "taboo",
        "tacit",
        "tagged",
        "tail",
        "taken",
        "talent",
        "tamper",
        "tanks",
        "tasked",
        "tattoo",
        "taunts",
        "tavern",
        "tawny",
        "taxi",
        "tell",
        "tender",
        "tepid",
        "tether",
        "thaw",
        "thorn",
        "thumbs",
        "thwart",
        "ticket",
        "tidy",
        "tiers",
        "tiger",
        "tilt",
        "timber",
        "tinted",
        "tipsy",
        "tirade",
        "tissue",
        "titans",
        "today",
        "toffee",
        "toilet",
        "token",
        "tonic",
        "topic",
        "torch",
        "tossed",
        "total",
        "touchy",
        "towel",
        "toxic",
        "toyed",
        "trash",
        "trendy",
        "tribal",
        "truth",
        "trying",
        "tubes",
        "tucks",
        "tudor",
        "tufts",
        "tugs",
        "tulips",
        "tunnel",
        "turnip",
        "tusks",
        "tutor",
        "tuxedo",
        "twang",
        "twice",
        "tycoon",
        "typist",
        "tyrant",
        "ugly",
        "ulcers",
        "umpire",
        "uncle",
        "under",
        "uneven",
        "unfit",
        "union",
        "unmask",
        "unrest",
        "unsafe",
        "until",
        "unveil",
        "unwind",
        "unzip",
        "upbeat",
        "update",
        "uphill",
        "upkeep",
        "upload",
        "upon",
        "upper",
        "urban",
        "urgent",
        "usage",
        "useful",
        "usher",
        "using",
        "usual",
        "utmost",
        "utopia",
        "vague",
        "vain",
        "value",
        "vane",
        "vary",
        "vats",
        "vaults",
        "vector",
        "veered",
        "vegan",
        "vein",
        "velvet",
        "vessel",
        "vexed",
        "vials",
        "victim",
        "video",
        "viking",
        "violin",
        "vipers",
        "vitals",
        "vivid",
        "vixen",
        "vocal",
        "vogue",
        "voice",
        "vortex",
        "voted",
        "vowels",
        "voyage",
        "wade",
        "waffle",
        "waist",
        "waking",
        "wanted",
        "warped",
        "water",
        "waxing",
        "wedge",
        "weird",
        "went",
        "wept",
        "were",
        "whale",
        "when",
        "whole",
        "width",
        "wield",
        "wife",
        "wiggle",
        "wildly",
        "winter",
        "wiring",
        "wise",
        "wives",
        "wizard",
        "wobbly",
        "woes",
        "woken",
        "wolf",
        "woozy",
        "worry",
        "woven",
        "wrap",
        "wrist",
        "wrong",
        "yacht",
        "yahoo",
        "yanks",
    ];

    // tryStringify will try to turn the provided input into a string. If the input
    // object is already a string, the input object will be returned. If the input
    // object has a toString method, the toString method will be called. If that
    // fails, we try to call JSON.stringify on the object. And if that fails, we
    // set the return value to "[stringify failed]".
    function tryStringify(obj) {
        // Check for undefined input.
        if (obj === undefined) {
            return "[cannot stringify undefined input]";
        }
        if (obj === null) {
            return "[null]";
        }
        // Parse the error into a string.
        if (typeof obj === "string") {
            return obj;
        }
        // Check if the object has a 'toString' method defined on it. To ensure
        // that we don't crash or throw, check that the toString is a function, and
        // also that the return value of toString is a string.
        if (Object.prototype.hasOwnProperty.call(obj, "toString")) {
            if (typeof obj.toString === "function") {
                let str = obj.toString();
                if (typeof str === "string") {
                    return str;
                }
            }
        }
        // If the object does not have a custom toString, attempt to perform a
        // JSON.stringify.
        try {
            return JSON.stringify(obj);
        }
        catch {
            return "[stringify failed]";
        }
    }

    // addContextToErr is a helper function that standardizes the formatting of
    // adding context to an error. Within the world of go we discovered that being
    // persistent about layering context onto errors is helpful when debugging,
    // even though it often creates rather verbose error messages.
    //
    // addContextToErr will return null if the input err is null.
    //
    // NOTE: To protect against accidental situations where an Error type or some
    // other type is provided instead of a string, we wrap both of the inputs with
    // tryStringify before returning them. This prevents runtime failures.
    function addContextToErr(err, context) {
        if (err === null) {
            err = "[no error provided]";
        }
        err = tryStringify(err);
        return tryStringify(context) + ": " + tryStringify(err);
    }
    // composeErr takes a series of inputs and composes them into a single string.
    // Each element will be separated by a newline. If the input is not a string,
    // it will be transformed into a string with JSON.stringify.
    //
    // Any object that cannot be stringified will be skipped, though an error will
    // be logged.
    function composeErr(...inputs) {
        let result = "";
        let resultEmpty = true;
        for (let i = 0; i < inputs.length; i++) {
            if (inputs[i] === null) {
                continue;
            }
            if (resultEmpty) {
                resultEmpty = false;
            }
            else {
                result += "\n";
            }
            result += tryStringify(inputs[i]);
        }
        if (resultEmpty) {
            return null;
        }
        return result;
    }

    // Helper consts to make it easy to return empty values alongside errors.
    const nu8$6 = new Uint8Array(0);
    // b64ToBuf will take an untrusted base64 string and convert it into a
    // Uin8Array, returning an error if the input is not valid base64.
    function b64ToBuf(b64) {
        // Check that the final string is valid base64.
        let b64regex = /^[0-9a-zA-Z-_/+=]*$/;
        if (!b64regex.test(b64)) {
            return [nu8$6, "provided string is not valid base64"];
        }
        // Swap any '-' characters for '+', and swap any '_' characters for '/'
        // for use in the atob function.
        b64 = b64.replace(/-/g, "+").replace(/_/g, "/");
        // Perform the conversion.
        let binStr = atob(b64);
        let len = binStr.length;
        let buf = new Uint8Array(len);
        for (let i = 0; i < len; i++) {
            buf[i] = binStr.charCodeAt(i);
        }
        return [buf, null];
    }
    // bufToHex takes a Uint8Array as input and returns the hex encoding of those
    // bytes as a string.
    function bufToHex(buf) {
        return [...buf].map((x) => x.toString(16).padStart(2, "0")).join("");
    }
    // bufToB64 will convert a Uint8Array to a base64 string with URL encoding and
    // no padding characters.
    function bufToB64(buf) {
        let b64Str = btoa(String.fromCharCode.apply(null, buf));
        return b64Str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
    }
    // bufToStr takes an ArrayBuffer as input and returns a text string. bufToStr
    // will check for invalid characters.
    function bufToStr(buf) {
        try {
            let text = new TextDecoder("utf-8", { fatal: true }).decode(buf);
            return [text, null];
        }
        catch (err) {
            return ["", addContextToErr(err.toString(), "unable to decode ArrayBuffer to string")];
        }
    }
    // decodeBigint will take an 8 byte Uint8Array and decode it as a bigint.
    function decodeBigint(buf) {
        if (buf.length !== 8) {
            return [0n, "a number is expected to be 8 bytes"];
        }
        let num = 0n;
        for (let i = 7; i >= 0; i--) {
            num *= 256n;
            num += BigInt(buf[i]);
        }
        return [num, null];
    }
    // encodePrefixedBytes takes a Uint8Array as input and returns a Uint8Array
    // that has the length prefixed as an 8 byte prefix. The input can be at most 4
    // GiB.
    function encodePrefixedBytes(bytes) {
        let len = bytes.length;
        if (len > 4294968295) {
            return [nu8$6, "input is too large to be encoded"];
        }
        let buf = new ArrayBuffer(8 + len);
        let view = new DataView(buf);
        view.setUint32(0, len, true);
        let uint8Bytes = new Uint8Array(buf);
        uint8Bytes.set(bytes, 8);
        return [uint8Bytes, null];
    }
    // encodeU64 will encode a bigint in the range of a uint64 to an 8 byte
    // Uint8Array.
    function encodeU64(num) {
        // Check the bounds on the bigint.
        if (num < 0) {
            return [nu8$6, "expected a positive integer"];
        }
        if (num > 18446744073709551615n) {
            return [nu8$6, "expected a number no larger than a uint64"];
        }
        // Encode the bigint into a Uint8Array.
        let encoded = new Uint8Array(8);
        for (let i = 0; i < encoded.length; i++) {
            let byte = Number(num & 0xffn);
            encoded[i] = byte;
            num = num >> 8n;
        }
        return [encoded, null];
    }
    // hexToBuf takes an untrusted string as input, verifies that the string is
    // valid hex, and then converts the string to a Uint8Array.
    function hexToBuf(hex) {
        // Check that the length makes sense.
        if (hex.length % 2 != 0) {
            return [nu8$6, "input has incorrect length"];
        }
        // Check that all of the characters are legal.
        let match = /[0-9A-Fa-f]*/g;
        if (!match.test(hex)) {
            return [nu8$6, "input has invalid character"];
        }
        // Create the buffer and fill it.
        let matches = hex.match(/.{1,2}/g);
        if (matches === null) {
            return [nu8$6, "input is incomplete"];
        }
        let u8 = new Uint8Array(matches.map((byte) => parseInt(byte, 16)));
        return [u8, null];
    }

    // Helper values for cleanly returning errors.
    const nu8$5 = new Uint8Array(0);
    // blake2bAddSubtreeToProofStack will add a subtree to a proof stack.
    function blake2bAddSubtreeToProofStack(ps, subtreeRoot, subtreeHeight) {
        // Input checking.
        if (subtreeRoot.length !== 32) {
            return "cannot add subtree because root is wrong length";
        }
        // If the proofStack has no elements in it yet, add the subtree
        // with no further checks.
        if (ps.subtreeRoots.length === 0) {
            ps.subtreeRoots.push(subtreeRoot);
            ps.subtreeHeights.push(subtreeHeight);
            return null;
        }
        // Check the height of the new subtree against the height of the smallest
        // subtree in the proofStack. If the new subtree is larger, the subtree
        // cannot be added.
        let maxHeight = ps.subtreeHeights[ps.subtreeHeights.length - 1];
        if (subtreeHeight > maxHeight) {
            return `cannot add a subtree that is taller ${subtreeHeight} than the smallest ${maxHeight} subtree in the stack`;
        }
        // If the new subtreeHeight is smaller than the max height, we can just
        // append the subtree height without doing anything more.
        if (subtreeHeight < maxHeight) {
            ps.subtreeRoots.push(subtreeRoot);
            ps.subtreeHeights.push(subtreeHeight);
            return null;
        }
        // If the new subtree is the same height as the smallest subtree, we
        // have to pull the smallest subtree out, combine it with the new
        // subtree, and push the result.
        let oldSTR = ps.subtreeRoots.pop();
        ps.subtreeHeights.pop(); // We already have the height.
        let combinedRoot = new Uint8Array(65);
        combinedRoot[0] = 1;
        combinedRoot.set(oldSTR, 1);
        combinedRoot.set(subtreeRoot, 33);
        let newSubtreeRoot = blake2b(combinedRoot);
        return blake2bAddSubtreeToProofStack(ps, newSubtreeRoot, subtreeHeight + 1n);
    }
    // blake2bAddLeafBytesToProofStack will add a leaf to a proof stack.
    function blake2bAddLeafBytesToProofStack(ps, leafBytes) {
        if (leafBytes.length !== 64) {
            return "proofStack expects leafByte objects to be exactly 64 bytes";
        }
        let taggedBytes = new Uint8Array(65);
        taggedBytes.set(leafBytes, 1);
        let subtreeRoot = blake2b(taggedBytes);
        return blake2bAddSubtreeToProofStack(ps, subtreeRoot, 1n);
    }
    // blake2bProofStackRoot returns the final Merkle root of the data in the
    // current proof stack.
    function blake2bProofStackRoot(ps) {
        // Input checking.
        if (ps.subtreeRoots.length === 0) {
            return [nu8$5, "cannot compute the Merkle root of an empty data set"];
        }
        // Algorithm is pretty basic, start with the final tree, and then add
        // it to the previous tree. Repeat until there are no more trees.
        let baseSubtreeRoot = ps.subtreeRoots.pop();
        while (ps.subtreeRoots.length !== 0) {
            let nextSubtreeRoot = ps.subtreeRoots.pop();
            let combinedRoot = new Uint8Array(65);
            combinedRoot[0] = 1;
            combinedRoot.set(baseSubtreeRoot, 1);
            combinedRoot.set(nextSubtreeRoot, 33);
            baseSubtreeRoot = blake2b(combinedRoot);
        }
        return [baseSubtreeRoot, null];
    }
    // nextSubtreeHeight returns the height of the largest subtree that contains
    // 'start', contains no elements prior to 'start', and also does not contain
    // 'end'.
    function nextSubtreeHeight(start, end) {
        // Input checking.
        if (end <= start) {
            return [0n, 0n, `end (${end}) must be strictly larger than start (${start})`];
        }
        // Merkle trees have a nice mathematical property that the largest tree
        // which contains a particular node and no nodes prior to it will have
        // a height that is equal to the number of trailing zeroes in the base
        // 2 representation of the index of that node.
        //
        // We are exploiting that property to compute the 'idealTreeHeight'. If
        // 'start' is zero, the ideal tree height will just keep counting up
        // forever, so we cut it off at 53.
        let idealTreeHeight = 1n;
        let idealTreeSize = 1n;
        // The conditional inside the loop tests if the next ideal tree size is
        // acceptable. If it is, we increment the height and double the size.
        while (start % (idealTreeSize * 2n) === 0n) {
            idealTreeHeight++;
            idealTreeSize = idealTreeSize * 2n;
        }
        // To compute the max tree height, we essentially just find the largest
        // power of 2 that is smaller than or equal to the gap between start
        // and end.
        let maxTreeHeight = 1n;
        let maxTreeSize = 1n;
        let range = end - start + 1n;
        while (maxTreeSize * 2n < range) {
            maxTreeHeight++;
            maxTreeSize = maxTreeSize * 2n;
        }
        // Return the smaller of the ideal height and the max height, as each
        // of them is an upper bound on how large things are allowed to be.
        if (idealTreeHeight < maxTreeHeight) {
            return [idealTreeHeight, idealTreeSize, null];
        }
        return [maxTreeHeight, maxTreeSize, null];
    }
    // blake2bMerkleRoot computes the merkle root of the provided data using a leaf
    // size of 64 bytes and blake2b as the hashing function.
    function blake2bMerkleRoot(data) {
        // Check that the input is an acceptable length.
        if (data.length % 64 !== 0) {
            return [nu8$5, "cannot take the merkle root of data that is not a multiple of 64 bytes"];
        }
        // Compute the Merkle root.
        let ps = {
            subtreeRoots: [],
            subtreeHeights: [],
        };
        for (let i = 0; i < data.length; i += 64) {
            blake2bAddLeafBytesToProofStack(ps, data.slice(i, i + 64));
        }
        return blake2bProofStackRoot(ps);
    }
    // blake2bVerifySectorRangeProof will verify a merkle proof that the provided
    // data exists within the provided sector at the provided range.
    //
    // NOTE: This implementation only handles a single range, but the transition to
    // doing mulit-range proofs is not very large. The main reason I didn't extend
    // this function was because it made the inputs a lot messier. The Sia merkle
    // tree repo uses the same techniques and has the full implementation, use that
    // as a reference if you need to extend this function to support multi-range
    // proofs.
    function blake2bVerifySectorRangeProof(root, data, rangeStart, rangeEnd, proof) {
        // Verify the inputs.
        if (root.length !== 32) {
            return "provided root is not a blake2b sector root";
        }
        if (rangeEnd <= rangeStart) {
            return "provided has no data";
        }
        if (rangeStart < 0n) {
            return "cannot use negative ranges";
        }
        if (rangeEnd > 4194304n) {
            return "range is out of bounds";
        }
        if (proof.length % 32 !== 0) {
            return "merkle proof has invalid length";
        }
        if (data.length !== Number(rangeEnd - rangeStart)) {
            return "data length does not match provided range";
        }
        if (data.length % 64 !== 0) {
            return "data must have a multiple of 64 bytes";
        }
        // We will consume proof elements until we get to the rangeStart of the
        // data.
        let ps = {
            subtreeRoots: [],
            subtreeHeights: [],
        };
        let currentOffset = 0n;
        let proofOffset = 0;
        while (currentOffset < rangeStart) {
            if (proof.length < proofOffset + 32) {
                return "merkle proof has insufficient data";
            }
            let [height, size, errNST] = nextSubtreeHeight(currentOffset / 64n, rangeStart / 64n);
            if (errNST !== null) {
                return addContextToErr(errNST, "error computing subtree height of initial proof stack");
            }
            let newSubtreeRoot = new Uint8Array(32);
            newSubtreeRoot.set(proof.slice(proofOffset, proofOffset + 32), 0);
            proofOffset += 32;
            let errSPS = blake2bAddSubtreeToProofStack(ps, newSubtreeRoot, height);
            if (errSPS !== null) {
                return addContextToErr(errSPS, "error adding subtree to initial proof stack");
            }
            currentOffset += size * 64n;
        }
        // We will consume data elements until we get to the end of the data.
        let dataOffset = 0;
        while (data.length > dataOffset) {
            let errLBPS = blake2bAddLeafBytesToProofStack(ps, data.slice(dataOffset, dataOffset + 64));
            if (errLBPS !== null) {
                return addContextToErr(errLBPS, "error adding leaves to proof stack");
            }
            dataOffset += 64;
            currentOffset += 64n;
        }
        // Consume proof elements until the entire sector is proven.
        let sectorEnd = 4194304n;
        while (currentOffset < sectorEnd) {
            if (proof.length < proofOffset + 32) {
                return "merkle proof has insufficient data";
            }
            let [height, size, errNST] = nextSubtreeHeight(currentOffset / 64n, sectorEnd / 64n);
            if (errNST !== null) {
                return addContextToErr(errNST, "error computing subtree height of trailing proof stack");
            }
            let newSubtreeRoot = new Uint8Array(32);
            newSubtreeRoot.set(proof.slice(proofOffset, proofOffset + 32), 0);
            proofOffset += 32;
            let errSPS = blake2bAddSubtreeToProofStack(ps, newSubtreeRoot, height);
            if (errSPS !== null) {
                return addContextToErr(errSPS, "error adding subtree to trailing proof stack");
            }
            currentOffset += size * 64n;
        }
        return null;
    }

    // Helper consts to make it easier to return empty values in the event of an
    // error.
    const nu8$4 = new Uint8Array(0);
    // verifyDownload will verify a download response from a portal. The input is
    // essentially components of a skylink - the offset, length, and merkle root.
    // The output is the raw file data.
    //
    // The 'buf' input should match the standard response body of a verified
    // download request to a portal, which is the skylink raw data followed by a
    // merkle proof. The offset and length provided as input indicate the offset
    // and length of the skylink raw data - not the offset and length of the
    // request within the file (that would be a different set of params).
    //
    // The skylink raw data itself breaks down into a metadata component and a file
    // component. The metadata component will contain information like the length
    // of the real file, and any fanout structure for large files. The first step
    // we need to take is verifying the Merkel proof, which will appear at the end
    // of the buffer. We'll have to hash the data we received and then compare it
    // against the Merkle proof and ensure it matches the data we are expecting.
    // Then we'll have to look at the layout to figure out which pieces of the data
    // are the full file, while also checking for corruption as the file can be
    // malicious independent of the portal operator.
    //
    // As long as the Merkle proof matches the root, offset, and length that we
    // have as input, the portal is considered non-malicious. Any additional errors
    // we find after that can be considered malice or incompetence on the part of
    // the person who uploaded the file.
    function verifyDownload(root, offset, fetchSize, buf) {
        let u8 = new Uint8Array(buf);
        // Input checking. If any of this is incorrect, its safe to blame the
        // server because the skylink format fundamentally should enable these
        // to be correct.
        if (u8.length < fetchSize) {
            return [nu8$4, true, "provided data is not large enough to cover fetchSize"];
        }
        if (u8.length < 99) {
            return [nu8$4, true, "provided data is not large enough to contain a skyfile"];
        }
        // Grab the skylinkData and Merkle proof from the array, and then
        // verify the Merkle proof.
        let skylinkData = u8.slice(0, Number(fetchSize));
        let merkleProof = u8.slice(Number(fetchSize), u8.length);
        let errVBSRP = blake2bVerifySectorRangeProof(root, skylinkData, offset, fetchSize, merkleProof);
        if (errVBSRP !== null) {
            return [nu8$4, true, addContextToErr(errVBSRP, "provided Merkle proof is not valid")];
        }
        // Up until this point, an error indicated that the portal was at fault for
        // either returning the wrong data or otherwise providing a malformed
        // repsonse. The remaining checks relate to the consistency of the file
        // itself, if the file is corrupt but the hash matches, there will be an
        // error and the portal will not be at fault.
        // The organization of the skylinkData is always:
        // 	layoutBytes || fanoutBytes || metadataBytes || fileBytes
        //
        // The layout is always exactly 99 bytes. Bytes [1,8] of the layout
        // contain the exact size of the fileBytes. Bytes [9, 16] of the layout
        // contain the exact size of the metadata. And bytes [17,24] of the
        // layout contain the exact size of the fanout. To get the offset of
        // the fileData, we need to extract the sizes of the metadata and
        // fanout, and then add those values to 99 to get the fileData offset.
        let fileSizeBytes = skylinkData.slice(1, 9);
        let mdSizeBytes = skylinkData.slice(9, 17);
        let fanoutSizeBytes = skylinkData.slice(17, 25);
        let [fileSize, errFSDN] = decodeBigint(fileSizeBytes);
        if (errFSDN !== null) {
            return [nu8$4, false, addContextToErr(errFSDN, "unable to decode filesize")];
        }
        let [mdSize, errMDDN] = decodeBigint(mdSizeBytes);
        if (errMDDN !== null) {
            return [nu8$4, false, addContextToErr(errMDDN, "unable to decode metadata size")];
        }
        let [fanoutSize, errFODN] = decodeBigint(fanoutSizeBytes);
        if (errFODN !== null) {
            return [nu8$4, false, addContextToErr(errFODN, "unable to decode fanout size")];
        }
        if (BigInt(skylinkData.length) < 99n + fileSize + mdSize + fanoutSize) {
            return [nu8$4, false, "provided data is too short to contain the full skyfile"];
        }
        let fileData = skylinkData.slice(Number(99n + mdSize + fanoutSize), Number(99n + mdSize + fanoutSize + fileSize));
        return [fileData, false, null];
    }

    // @ts-nocheck
    // json_parse extracted from the json-bigint npm library
    // regexpxs extracted from
    // (c) BSD-3-Clause
    // https://github.com/fastify/secure-json-parse/graphs/contributors and https://github.com/hapijs/bourne/graphs/contributors
    const suspectProtoRx = /(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])/;
    const suspectConstructorRx = /(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)/;
    let json_parse = function (options) {
        // This is a function that can parse a JSON text, producing a JavaScript
        // data structure. It is a simple, recursive descent parser. It does not use
        // eval or regular expressions, so it can be used as a model for implementing
        // a JSON parser in other languages.
        // We are defining the function inside of another function to avoid creating
        // global variables.
        // Default options one can override by passing options to the parse()
        let _options = {
            strict: false,
            storeAsString: false,
            alwaysParseAsBig: false,
            protoAction: "error",
            constructorAction: "error",
        };
        // If there are options, then use them to override the default _options
        if (options !== undefined && options !== null) {
            if (options.strict === true) {
                _options.strict = true;
            }
            if (options.storeAsString === true) {
                _options.storeAsString = true;
            }
            _options.alwaysParseAsBig = options.alwaysParseAsBig === true ? options.alwaysParseAsBig : false;
            if (typeof options.constructorAction !== "undefined") {
                if (options.constructorAction === "error" ||
                    options.constructorAction === "ignore" ||
                    options.constructorAction === "preserve") {
                    _options.constructorAction = options.constructorAction;
                }
                else {
                    throw new Error(`Incorrect value for constructorAction option, must be "error", "ignore" or undefined but passed ${options.constructorAction}`);
                }
            }
            if (typeof options.protoAction !== "undefined") {
                if (options.protoAction === "error" || options.protoAction === "ignore" || options.protoAction === "preserve") {
                    _options.protoAction = options.protoAction;
                }
                else {
                    throw new Error(`Incorrect value for protoAction option, must be "error", "ignore" or undefined but passed ${options.protoAction}`);
                }
            }
        }
        let at, // The index of the current character
        ch, // The current character
        escapee = {
            '"': '"',
            "\\": "\\",
            "/": "/",
            b: "\b",
            f: "\f",
            n: "\n",
            r: "\r",
            t: "\t",
        }, text, error = function (m) {
            // Call error when something is wrong.
            throw {
                name: "SyntaxError",
                message: m,
                at: at,
                text: text,
            };
        }, next = function (c) {
            // If a c parameter is provided, verify that it matches the current character.
            if (c && c !== ch) {
                error("Expected '" + c + "' instead of '" + ch + "'");
            }
            // Get the next character. When there are no more characters,
            // return the empty string.
            ch = text.charAt(at);
            at += 1;
            return ch;
        }, number = function () {
            // Parse a number value.
            let number, string = "";
            if (ch === "-") {
                string = "-";
                next("-");
            }
            while (ch >= "0" && ch <= "9") {
                string += ch;
                next();
            }
            if (ch === ".") {
                string += ".";
                while (next() && ch >= "0" && ch <= "9") {
                    string += ch;
                }
            }
            if (ch === "e" || ch === "E") {
                string += ch;
                next();
                if (ch === "-" || ch === "+") {
                    string += ch;
                    next();
                }
                while (ch >= "0" && ch <= "9") {
                    string += ch;
                    next();
                }
            }
            number = +string;
            if (!isFinite(number)) {
                error("Bad number");
            }
            else {
                if (Number.isSafeInteger(number))
                    return !_options.alwaysParseAsBig ? number : BigInt(number);
                // Number with fractional part should be treated as number(double) including big integers in scientific notation, i.e 1.79e+308
                else
                    return _options.storeAsString ? string : /[.eE]/.test(string) ? number : BigInt(string);
            }
        }, string = function () {
            // Parse a string value.
            let hex, i, string = "", uffff;
            // When parsing for string values, we must look for " and \ characters.
            if (ch === '"') {
                let startAt = at;
                while (next()) {
                    if (ch === '"') {
                        if (at - 1 > startAt)
                            string += text.substring(startAt, at - 1);
                        next();
                        return string;
                    }
                    if (ch === "\\") {
                        if (at - 1 > startAt)
                            string += text.substring(startAt, at - 1);
                        next();
                        if (ch === "u") {
                            uffff = 0;
                            for (i = 0; i < 4; i += 1) {
                                hex = parseInt(next(), 16);
                                if (!isFinite(hex)) {
                                    break;
                                }
                                uffff = uffff * 16 + hex;
                            }
                            string += String.fromCharCode(uffff);
                        }
                        else if (typeof escapee[ch] === "string") {
                            string += escapee[ch];
                        }
                        else {
                            break;
                        }
                        startAt = at;
                    }
                }
            }
            error("Bad string");
        }, white = function () {
            // Skip whitespace.
            while (ch && ch <= " ") {
                next();
            }
        }, word = function () {
            // true, false, or null.
            switch (ch) {
                case "t":
                    next("t");
                    next("r");
                    next("u");
                    next("e");
                    return true;
                case "f":
                    next("f");
                    next("a");
                    next("l");
                    next("s");
                    next("e");
                    return false;
                case "n":
                    next("n");
                    next("u");
                    next("l");
                    next("l");
                    return null;
            }
            error("Unexpected '" + ch + "'");
        }, value, // Place holder for the value function.
        array = function () {
            // Parse an array value.
            let array = [];
            if (ch === "[") {
                next("[");
                white();
                if (ch === "]") {
                    next("]");
                    return array; // empty array
                }
                while (ch) {
                    array.push(value());
                    white();
                    if (ch === "]") {
                        next("]");
                        return array;
                    }
                    next(",");
                    white();
                }
            }
            error("Bad array");
        }, object = function () {
            // Parse an object value.
            let key, object = Object.create(null);
            if (ch === "{") {
                next("{");
                white();
                if (ch === "}") {
                    next("}");
                    return object; // empty object
                }
                while (ch) {
                    key = string();
                    white();
                    next(":");
                    if (_options.strict === true && Object.hasOwnProperty.call(object, key)) {
                        error('Duplicate key "' + key + '"');
                    }
                    if (suspectProtoRx.test(key) === true) {
                        if (_options.protoAction === "error") {
                            error("Object contains forbidden prototype property");
                        }
                        else if (_options.protoAction === "ignore") {
                            value();
                        }
                        else {
                            object[key] = value();
                        }
                    }
                    else if (suspectConstructorRx.test(key) === true) {
                        if (_options.constructorAction === "error") {
                            error("Object contains forbidden constructor property");
                        }
                        else if (_options.constructorAction === "ignore") {
                            value();
                        }
                        else {
                            object[key] = value();
                        }
                    }
                    else {
                        object[key] = value();
                    }
                    white();
                    if (ch === "}") {
                        next("}");
                        return object;
                    }
                    next(",");
                    white();
                }
            }
            error("Bad object");
        };
        value = function () {
            // Parse a JSON value. It could be an object, an array, a string, a number,
            // or a word.
            white();
            switch (ch) {
                case "{":
                    return object();
                case "[":
                    return array();
                case '"':
                    return string();
                case "-":
                    return number();
                default:
                    return ch >= "0" && ch <= "9" ? number() : word();
            }
        };
        // Return the json_parse function. It will have access to all of the above
        // functions and variables.
        return function (source, reviver) {
            let result;
            text = source + "";
            at = 0;
            ch = " ";
            result = value();
            white();
            if (ch) {
                error("Syntax error");
            }
            // If there is a reviver function, we recursively walk the new structure,
            // passing each name/value pair to the reviver function for possible
            // transformation, starting with a temporary root object that holds the result
            // in an empty key. If there is not a reviver function, we simply return the
            // result.
            return typeof reviver === "function"
                ? (function walk(holder, key) {
                    let v, value = holder[key];
                    if (value && typeof value === "object") {
                        Object.keys(value).forEach(function (k) {
                            v = walk(value, k);
                            if (v !== undefined) {
                                value[k] = v;
                            }
                            else {
                                delete value[k];
                            }
                        });
                    }
                    return reviver.call(holder, key, value);
                })({ "": result }, "")
                : result;
        };
    };
    // parseJSON is a wrapper for JSONbig.parse that returns an error rather than
    // throwing an error. JSONbig is an alternative to JSON.parse that decodes
    // every number as a bigint. This is required when working with the skyd API
    // because the skyd API uses 64 bit precision for all of its numbers, and
    // therefore cannot be parsed losslessly by javascript. The skyd API is
    // cryptographic, therefore full precision is required.
    function parseJSON(json) {
        try {
            let obj = json_parse({ alwaysParseAsBig: true })(json);
            return [obj, null];
        }
        catch (err) {
            return [{}, tryStringify(err)];
        }
    }

    // Helper consts that make it easier to return empty values when returning an
    // error inside of a function.
    const nu8$3 = new Uint8Array(0);
    // parseSkylinkBitfield parses a skylink bitfield and returns the corresponding
    // version, offset, and fetchSize.
    function parseSkylinkBitfield(skylink) {
        // Validate the input.
        if (skylink.length !== 34) {
            return [0n, 0n, 0n, "provided skylink has incorrect length"];
        }
        // Extract the bitfield.
        let bitfield = new DataView(skylink.buffer).getUint16(0, true);
        // Extract the version.
        let version = (bitfield & 3) + 1;
        // Only versions 1 and 2 are recognized.
        if (version !== 1 && version !== 2) {
            return [0n, 0n, 0n, "provided skylink has unrecognized version"];
        }
        // If the skylink is set to version 2, we only recognize the link if
        // the rest of the bits in the bitfield are empty.
        if (version === 2) {
            if ((bitfield & 3) !== bitfield) {
                return [0n, 0n, 0n, "provided skylink has unrecognized version"];
            }
            return [BigInt(version), 0n, 0n, null];
        }
        // Verify that the mode is valid, then fetch the mode.
        bitfield = bitfield >> 2;
        if ((bitfield & 255) === 255) {
            return [0n, 0n, 0n, "provided skylink has an unrecognized version"];
        }
        let mode = 0;
        for (let i = 0; i < 8; i++) {
            if ((bitfield & 1) === 0) {
                bitfield = bitfield >> 1;
                break;
            }
            bitfield = bitfield >> 1;
            mode++;
        }
        // If the mode is greater than 7, this is not a valid v1 skylink.
        if (mode > 7) {
            return [0n, 0n, 0n, "provided skylink has an invalid v1 bitfield"];
        }
        // Determine the offset and fetchSize increment.
        let offsetIncrement = 4096 << mode;
        let fetchSizeIncrement = 4096;
        let fetchSizeStart = 0;
        if (mode > 0) {
            fetchSizeIncrement = fetchSizeIncrement << (mode - 1);
            fetchSizeStart = (1 << 15) << (mode - 1);
        }
        // The next three bits decide the fetchSize.
        let fetchSizeBits = bitfield & 7;
        fetchSizeBits++; // semantic upstep, range should be [1,8] not [0,8).
        let fetchSize = fetchSizeBits * fetchSizeIncrement + fetchSizeStart;
        bitfield = bitfield >> 3;
        // The remaining bits determine the offset.
        let offset = bitfield * offsetIncrement;
        if (offset + fetchSize > 1 << 22) {
            return [0n, 0n, 0n, "provided skylink has an invalid v1 bitfield"];
        }
        // Return what we learned.
        return [BigInt(version), BigInt(offset), BigInt(fetchSize), null];
    }
    // skylinkV1Bitfield sets the bitfield of a V1 skylink. It assumes the version
    // is 1 and the offset is 0. It will determine the appropriate fetchSize from
    // the provided dataSize.
    function skylinkV1Bitfield(dataSizeBI) {
        // Check that the dataSize is not too large.
        if (dataSizeBI > 1 << 22) {
            return [nu8$3, "dataSize must be less than the sector size"];
        }
        let dataSize = Number(dataSizeBI);
        // Determine the mode for the file. The mode is determined by the
        // dataSize.
        let mode = 0;
        for (let i = 1 << 15; i < dataSize; i *= 2) {
            mode += 1;
        }
        // Determine the download number.
        let downloadNumber = 0;
        if (mode === 0) {
            if (dataSize !== 0) {
                downloadNumber = Math.floor((dataSize - 1) / (1 << 12));
            }
        }
        else {
            let step = 1 << (11 + mode);
            let target = dataSize - (1 << (14 + mode));
            if (target !== 0) {
                downloadNumber = Math.floor((target - 1) / step);
            }
        }
        // Create the Uint8Array and fill it out. The main reason I switch over
        // the 7 modes like this is because I wasn't sure how to make a uint16
        // in javascript. If we could treat the uint8array as a uint16 and then
        // later convert it over, we could use basic bitshifiting and really
        // simplify the code here.
        let bitfield = new Uint8Array(2);
        if (mode === 7) {
            // 0 0 0 X X X 0 1|1 1 1 1 1 1 0 0
            bitfield[0] = downloadNumber;
            bitfield[0] *= 4;
            bitfield[0] += 1;
            bitfield[1] = 4 + 8 + 16 + 32 + 64 + 128;
        }
        if (mode === 6) {
            // 0 0 0 0 X X X 0|1 1 1 1 1 1 0 0
            bitfield[0] = downloadNumber;
            bitfield[0] *= 2;
            bitfield[1] = 4 + 8 + 16 + 32 + 64 + 128;
        }
        if (mode === 5) {
            // 0 0 0 0 0 X X X|0 1 1 1 1 1 0 0
            bitfield[0] = downloadNumber;
            bitfield[1] = 4 + 8 + 16 + 32 + 64;
        }
        if (mode === 4) {
            // 0 0 0 0 0 0 X X|X 0 1 1 1 1 0 0
            bitfield[0] = downloadNumber;
            bitfield[0] /= 2;
            bitfield[1] = (downloadNumber & 1) * 128;
            bitfield[1] += 4 + 8 + 16 + 32;
        }
        if (mode === 3) {
            // 0 0 0 0 0 0 0 X|X X 0 1 1 1 0 0
            bitfield[0] = downloadNumber;
            bitfield[0] /= 4;
            bitfield[1] = (downloadNumber & 3) * 64;
            bitfield[1] += 4 + 8 + 16;
        }
        if (mode === 2) {
            // 0 0 0 0 0 0 0 0|X X X 0 1 1 0 0
            bitfield[0] = 0;
            bitfield[1] = downloadNumber * 32;
            bitfield[1] += 4 + 8;
        }
        if (mode === 1) {
            // 0 0 0 0 0 0 0 0|0 X X X 0 1 0 0
            bitfield[0] = 0;
            bitfield[1] = downloadNumber * 16;
            bitfield[1] += 4;
        }
        if (mode === 0) {
            // 0 0 0 0 0 0 0 0|0 0 X X X 0 0 0
            bitfield[0] = 0;
            bitfield[1] = downloadNumber * 8;
        }
        // Swap the byte order.
        let zero = bitfield[0];
        bitfield[0] = bitfield[1];
        bitfield[1] = zero;
        return [bitfield, null];
    }

    const HASH_SIZE = 64;
    const K = [
        0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc, 0x3956c25b,
        0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118, 0xd807aa98, 0xa3030242,
        0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2, 0x72be5d74, 0xf27b896f, 0x80deb1fe,
        0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694, 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,
        0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65, 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc,
        0xbd41fbd4, 0x76f988da, 0x831153b5, 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f,
        0xbf597fc7, 0xbeef0ee4, 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967,
        0x0a0e6e70, 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
        0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b, 0xa2bfe8a1,
        0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30, 0xd192e819, 0xd6ef5218,
        0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8, 0x19a4c116, 0xb8d2d0c8, 0x1e376c08,
        0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8, 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,
        0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3, 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814,
        0xa1f0ab72, 0x8cc70208, 0x1a6439ec, 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915,
        0xc67178f2, 0xe372532b, 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f,
        0xee6ed178, 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
        0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c, 0x4cc5d4be,
        0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817,
    ];
    function ts64(x, i, h, l) {
        x[i] = (h >> 24) & 0xff;
        x[i + 1] = (h >> 16) & 0xff;
        x[i + 2] = (h >> 8) & 0xff;
        x[i + 3] = h & 0xff;
        x[i + 4] = (l >> 24) & 0xff;
        x[i + 5] = (l >> 16) & 0xff;
        x[i + 6] = (l >> 8) & 0xff;
        x[i + 7] = l & 0xff;
    }
    function crypto_hashblocks_hl(hh, hl, m, n) {
        let wh = new Int32Array(16), wl = new Int32Array(16), bh0, bh1, bh2, bh3, bh4, bh5, bh6, bh7, bl0, bl1, bl2, bl3, bl4, bl5, bl6, bl7, th, tl, i, j, h, l, a, b, c, d;
        let ah0 = hh[0], ah1 = hh[1], ah2 = hh[2], ah3 = hh[3], ah4 = hh[4], ah5 = hh[5], ah6 = hh[6], ah7 = hh[7], al0 = hl[0], al1 = hl[1], al2 = hl[2], al3 = hl[3], al4 = hl[4], al5 = hl[5], al6 = hl[6], al7 = hl[7];
        let pos = 0;
        while (n >= 128) {
            for (i = 0; i < 16; i++) {
                j = 8 * i + pos;
                wh[i] = (m[j + 0] << 24) | (m[j + 1] << 16) | (m[j + 2] << 8) | m[j + 3];
                wl[i] = (m[j + 4] << 24) | (m[j + 5] << 16) | (m[j + 6] << 8) | m[j + 7];
            }
            for (i = 0; i < 80; i++) {
                bh0 = ah0;
                bh1 = ah1;
                bh2 = ah2;
                bh3 = ah3;
                bh4 = ah4;
                bh5 = ah5;
                bh6 = ah6;
                bh7 = ah7;
                bl0 = al0;
                bl1 = al1;
                bl2 = al2;
                bl3 = al3;
                bl4 = al4;
                bl5 = al5;
                bl6 = al6;
                bl7 = al7;
                // add
                h = ah7;
                l = al7;
                a = l & 0xffff;
                b = l >>> 16;
                c = h & 0xffff;
                d = h >>> 16;
                // Sigma1
                h =
                    ((ah4 >>> 14) | (al4 << (32 - 14))) ^
                        ((ah4 >>> 18) | (al4 << (32 - 18))) ^
                        ((al4 >>> (41 - 32)) | (ah4 << (32 - (41 - 32))));
                l =
                    ((al4 >>> 14) | (ah4 << (32 - 14))) ^
                        ((al4 >>> 18) | (ah4 << (32 - 18))) ^
                        ((ah4 >>> (41 - 32)) | (al4 << (32 - (41 - 32))));
                a += l & 0xffff;
                b += l >>> 16;
                c += h & 0xffff;
                d += h >>> 16;
                // Ch
                h = (ah4 & ah5) ^ (~ah4 & ah6);
                l = (al4 & al5) ^ (~al4 & al6);
                a += l & 0xffff;
                b += l >>> 16;
                c += h & 0xffff;
                d += h >>> 16;
                // K
                h = K[i * 2];
                l = K[i * 2 + 1];
                a += l & 0xffff;
                b += l >>> 16;
                c += h & 0xffff;
                d += h >>> 16;
                // w
                h = wh[i % 16];
                l = wl[i % 16];
                a += l & 0xffff;
                b += l >>> 16;
                c += h & 0xffff;
                d += h >>> 16;
                b += a >>> 16;
                c += b >>> 16;
                d += c >>> 16;
                th = (c & 0xffff) | (d << 16);
                tl = (a & 0xffff) | (b << 16);
                // add
                h = th;
                l = tl;
                a = l & 0xffff;
                b = l >>> 16;
                c = h & 0xffff;
                d = h >>> 16;
                // Sigma0
                h =
                    ((ah0 >>> 28) | (al0 << (32 - 28))) ^
                        ((al0 >>> (34 - 32)) | (ah0 << (32 - (34 - 32)))) ^
                        ((al0 >>> (39 - 32)) | (ah0 << (32 - (39 - 32))));
                l =
                    ((al0 >>> 28) | (ah0 << (32 - 28))) ^
                        ((ah0 >>> (34 - 32)) | (al0 << (32 - (34 - 32)))) ^
                        ((ah0 >>> (39 - 32)) | (al0 << (32 - (39 - 32))));
                a += l & 0xffff;
                b += l >>> 16;
                c += h & 0xffff;
                d += h >>> 16;
                // Maj
                h = (ah0 & ah1) ^ (ah0 & ah2) ^ (ah1 & ah2);
                l = (al0 & al1) ^ (al0 & al2) ^ (al1 & al2);
                a += l & 0xffff;
                b += l >>> 16;
                c += h & 0xffff;
                d += h >>> 16;
                b += a >>> 16;
                c += b >>> 16;
                d += c >>> 16;
                bh7 = (c & 0xffff) | (d << 16);
                bl7 = (a & 0xffff) | (b << 16);
                // add
                h = bh3;
                l = bl3;
                a = l & 0xffff;
                b = l >>> 16;
                c = h & 0xffff;
                d = h >>> 16;
                h = th;
                l = tl;
                a += l & 0xffff;
                b += l >>> 16;
                c += h & 0xffff;
                d += h >>> 16;
                b += a >>> 16;
                c += b >>> 16;
                d += c >>> 16;
                bh3 = (c & 0xffff) | (d << 16);
                bl3 = (a & 0xffff) | (b << 16);
                ah1 = bh0;
                ah2 = bh1;
                ah3 = bh2;
                ah4 = bh3;
                ah5 = bh4;
                ah6 = bh5;
                ah7 = bh6;
                ah0 = bh7;
                al1 = bl0;
                al2 = bl1;
                al3 = bl2;
                al4 = bl3;
                al5 = bl4;
                al6 = bl5;
                al7 = bl6;
                al0 = bl7;
                if (i % 16 === 15) {
                    for (j = 0; j < 16; j++) {
                        // add
                        h = wh[j];
                        l = wl[j];
                        a = l & 0xffff;
                        b = l >>> 16;
                        c = h & 0xffff;
                        d = h >>> 16;
                        h = wh[(j + 9) % 16];
                        l = wl[(j + 9) % 16];
                        a += l & 0xffff;
                        b += l >>> 16;
                        c += h & 0xffff;
                        d += h >>> 16;
                        // sigma0
                        th = wh[(j + 1) % 16];
                        tl = wl[(j + 1) % 16];
                        h = ((th >>> 1) | (tl << (32 - 1))) ^ ((th >>> 8) | (tl << (32 - 8))) ^ (th >>> 7);
                        l = ((tl >>> 1) | (th << (32 - 1))) ^ ((tl >>> 8) | (th << (32 - 8))) ^ ((tl >>> 7) | (th << (32 - 7)));
                        a += l & 0xffff;
                        b += l >>> 16;
                        c += h & 0xffff;
                        d += h >>> 16;
                        // sigma1
                        th = wh[(j + 14) % 16];
                        tl = wl[(j + 14) % 16];
                        h = ((th >>> 19) | (tl << (32 - 19))) ^ ((tl >>> (61 - 32)) | (th << (32 - (61 - 32)))) ^ (th >>> 6);
                        l =
                            ((tl >>> 19) | (th << (32 - 19))) ^
                                ((th >>> (61 - 32)) | (tl << (32 - (61 - 32)))) ^
                                ((tl >>> 6) | (th << (32 - 6)));
                        a += l & 0xffff;
                        b += l >>> 16;
                        c += h & 0xffff;
                        d += h >>> 16;
                        b += a >>> 16;
                        c += b >>> 16;
                        d += c >>> 16;
                        wh[j] = (c & 0xffff) | (d << 16);
                        wl[j] = (a & 0xffff) | (b << 16);
                    }
                }
            }
            // add
            h = ah0;
            l = al0;
            a = l & 0xffff;
            b = l >>> 16;
            c = h & 0xffff;
            d = h >>> 16;
            h = hh[0];
            l = hl[0];
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;
            b += a >>> 16;
            c += b >>> 16;
            d += c >>> 16;
            hh[0] = ah0 = (c & 0xffff) | (d << 16);
            hl[0] = al0 = (a & 0xffff) | (b << 16);
            h = ah1;
            l = al1;
            a = l & 0xffff;
            b = l >>> 16;
            c = h & 0xffff;
            d = h >>> 16;
            h = hh[1];
            l = hl[1];
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;
            b += a >>> 16;
            c += b >>> 16;
            d += c >>> 16;
            hh[1] = ah1 = (c & 0xffff) | (d << 16);
            hl[1] = al1 = (a & 0xffff) | (b << 16);
            h = ah2;
            l = al2;
            a = l & 0xffff;
            b = l >>> 16;
            c = h & 0xffff;
            d = h >>> 16;
            h = hh[2];
            l = hl[2];
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;
            b += a >>> 16;
            c += b >>> 16;
            d += c >>> 16;
            hh[2] = ah2 = (c & 0xffff) | (d << 16);
            hl[2] = al2 = (a & 0xffff) | (b << 16);
            h = ah3;
            l = al3;
            a = l & 0xffff;
            b = l >>> 16;
            c = h & 0xffff;
            d = h >>> 16;
            h = hh[3];
            l = hl[3];
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;
            b += a >>> 16;
            c += b >>> 16;
            d += c >>> 16;
            hh[3] = ah3 = (c & 0xffff) | (d << 16);
            hl[3] = al3 = (a & 0xffff) | (b << 16);
            h = ah4;
            l = al4;
            a = l & 0xffff;
            b = l >>> 16;
            c = h & 0xffff;
            d = h >>> 16;
            h = hh[4];
            l = hl[4];
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;
            b += a >>> 16;
            c += b >>> 16;
            d += c >>> 16;
            hh[4] = ah4 = (c & 0xffff) | (d << 16);
            hl[4] = al4 = (a & 0xffff) | (b << 16);
            h = ah5;
            l = al5;
            a = l & 0xffff;
            b = l >>> 16;
            c = h & 0xffff;
            d = h >>> 16;
            h = hh[5];
            l = hl[5];
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;
            b += a >>> 16;
            c += b >>> 16;
            d += c >>> 16;
            hh[5] = ah5 = (c & 0xffff) | (d << 16);
            hl[5] = al5 = (a & 0xffff) | (b << 16);
            h = ah6;
            l = al6;
            a = l & 0xffff;
            b = l >>> 16;
            c = h & 0xffff;
            d = h >>> 16;
            h = hh[6];
            l = hl[6];
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;
            b += a >>> 16;
            c += b >>> 16;
            d += c >>> 16;
            hh[6] = ah6 = (c & 0xffff) | (d << 16);
            hl[6] = al6 = (a & 0xffff) | (b << 16);
            h = ah7;
            l = al7;
            a = l & 0xffff;
            b = l >>> 16;
            c = h & 0xffff;
            d = h >>> 16;
            h = hh[7];
            l = hl[7];
            a += l & 0xffff;
            b += l >>> 16;
            c += h & 0xffff;
            d += h >>> 16;
            b += a >>> 16;
            c += b >>> 16;
            d += c >>> 16;
            hh[7] = ah7 = (c & 0xffff) | (d << 16);
            hl[7] = al7 = (a & 0xffff) | (b << 16);
            pos += 128;
            n -= 128;
        }
        return n;
    }
    const sha512internal = function (out, m, n) {
        let hh = new Int32Array(8), hl = new Int32Array(8), x = new Uint8Array(256), i, b = n;
        hh[0] = 0x6a09e667;
        hh[1] = 0xbb67ae85;
        hh[2] = 0x3c6ef372;
        hh[3] = 0xa54ff53a;
        hh[4] = 0x510e527f;
        hh[5] = 0x9b05688c;
        hh[6] = 0x1f83d9ab;
        hh[7] = 0x5be0cd19;
        hl[0] = 0xf3bcc908;
        hl[1] = 0x84caa73b;
        hl[2] = 0xfe94f82b;
        hl[3] = 0x5f1d36f1;
        hl[4] = 0xade682d1;
        hl[5] = 0x2b3e6c1f;
        hl[6] = 0xfb41bd6b;
        hl[7] = 0x137e2179;
        crypto_hashblocks_hl(hh, hl, m, n);
        n %= 128;
        for (i = 0; i < n; i++)
            x[i] = m[b - n + i];
        x[n] = 128;
        n = 256 - 128 * (n < 112 ? 1 : 0);
        x[n - 9] = 0;
        ts64(x, n - 8, (b / 0x20000000) | 0, b << 3);
        crypto_hashblocks_hl(hh, hl, x, n);
        for (i = 0; i < 8; i++)
            ts64(out, 8 * i, hh[i], hl[i]);
        return 0;
    };
    // sha512 is the standard sha512 cryptographic hash function. This is the
    // default choice for Skynet operations, though many of the Sia protocol
    // standards use blake2b instead, so you will see both.
    function sha512(m) {
        const out = new Uint8Array(HASH_SIZE);
        sha512internal(out, m, m.length);
        return out;
    }

    let crypto_sign_BYTES = 64, crypto_sign_PUBLICKEYBYTES = 32, crypto_sign_SECRETKEYBYTES = 64, crypto_sign_SEEDBYTES = 32;
    let gf = function () {
        let r = new Float64Array(16);
        return r;
    };
    let gfi = function (init) {
        let i, r = new Float64Array(16);
        if (init)
            for (i = 0; i < init.length; i++)
                r[i] = init[i];
        return r;
    };
    let gf0 = gf(), gf1 = gfi([1]), D = gfi([
        0x78a3, 0x1359, 0x4dca, 0x75eb, 0xd8ab, 0x4141, 0x0a4d, 0x0070, 0xe898, 0x7779, 0x4079, 0x8cc7, 0xfe73, 0x2b6f,
        0x6cee, 0x5203,
    ]), D2 = gfi([
        0xf159, 0x26b2, 0x9b94, 0xebd6, 0xb156, 0x8283, 0x149a, 0x00e0, 0xd130, 0xeef3, 0x80f2, 0x198e, 0xfce7, 0x56df,
        0xd9dc, 0x2406,
    ]), X = gfi([
        0xd51a, 0x8f25, 0x2d60, 0xc956, 0xa7b2, 0x9525, 0xc760, 0x692c, 0xdc5c, 0xfdd6, 0xe231, 0xc0a4, 0x53fe, 0xcd6e,
        0x36d3, 0x2169,
    ]), Y = gfi([
        0x6658, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666, 0x6666,
        0x6666, 0x6666,
    ]), I = gfi([
        0xa0b0, 0x4a0e, 0x1b27, 0xc4ee, 0xe478, 0xad2f, 0x1806, 0x2f43, 0xd7a7, 0x3dfb, 0x0099, 0x2b4d, 0xdf0b, 0x4fc1,
        0x2480, 0x2b83,
    ]);
    function vn(x, xi, y, yi, n) {
        let i, d = 0;
        for (i = 0; i < n; i++)
            d |= x[xi + i] ^ y[yi + i];
        return (1 & ((d - 1) >>> 8)) - 1;
    }
    function crypto_verify_32(x, xi, y, yi) {
        return vn(x, xi, y, yi, 32);
    }
    function set25519(r, a) {
        let i;
        for (i = 0; i < 16; i++)
            r[i] = a[i] | 0;
    }
    function car25519(o) {
        let i, v, c = 1;
        for (i = 0; i < 16; i++) {
            v = o[i] + c + 65535;
            c = Math.floor(v / 65536);
            o[i] = v - c * 65536;
        }
        o[0] += c - 1 + 37 * (c - 1);
    }
    function sel25519(p, q, b) {
        let t, c = ~(b - 1);
        for (let i = 0; i < 16; i++) {
            t = c & (p[i] ^ q[i]);
            p[i] ^= t;
            q[i] ^= t;
        }
    }
    function pack25519(o, n) {
        let i, j, b;
        let m = gf(), t = gf();
        for (i = 0; i < 16; i++)
            t[i] = n[i];
        car25519(t);
        car25519(t);
        car25519(t);
        for (j = 0; j < 2; j++) {
            m[0] = t[0] - 0xffed;
            for (i = 1; i < 15; i++) {
                m[i] = t[i] - 0xffff - ((m[i - 1] >> 16) & 1);
                m[i - 1] &= 0xffff;
            }
            m[15] = t[15] - 0x7fff - ((m[14] >> 16) & 1);
            b = (m[15] >> 16) & 1;
            m[14] &= 0xffff;
            sel25519(t, m, 1 - b);
        }
        for (i = 0; i < 16; i++) {
            o[2 * i] = t[i] & 0xff;
            o[2 * i + 1] = t[i] >> 8;
        }
    }
    function neq25519(a, b) {
        let c = new Uint8Array(32), d = new Uint8Array(32);
        pack25519(c, a);
        pack25519(d, b);
        return crypto_verify_32(c, 0, d, 0);
    }
    function par25519(a) {
        let d = new Uint8Array(32);
        pack25519(d, a);
        return d[0] & 1;
    }
    function unpack25519(o, n) {
        let i;
        for (i = 0; i < 16; i++)
            o[i] = n[2 * i] + (n[2 * i + 1] << 8);
        o[15] &= 0x7fff;
    }
    function A(o, a, b) {
        for (let i = 0; i < 16; i++)
            o[i] = a[i] + b[i];
    }
    function Z(o, a, b) {
        for (let i = 0; i < 16; i++)
            o[i] = a[i] - b[i];
    }
    function M(o, a, b) {
        let v, c, t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0, t8 = 0, t9 = 0, t10 = 0, t11 = 0, t12 = 0, t13 = 0, t14 = 0, t15 = 0, t16 = 0, t17 = 0, t18 = 0, t19 = 0, t20 = 0, t21 = 0, t22 = 0, t23 = 0, t24 = 0, t25 = 0, t26 = 0, t27 = 0, t28 = 0, t29 = 0, t30 = 0, b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4], b5 = b[5], b6 = b[6], b7 = b[7], b8 = b[8], b9 = b[9], b10 = b[10], b11 = b[11], b12 = b[12], b13 = b[13], b14 = b[14], b15 = b[15];
        v = a[0];
        t0 += v * b0;
        t1 += v * b1;
        t2 += v * b2;
        t3 += v * b3;
        t4 += v * b4;
        t5 += v * b5;
        t6 += v * b6;
        t7 += v * b7;
        t8 += v * b8;
        t9 += v * b9;
        t10 += v * b10;
        t11 += v * b11;
        t12 += v * b12;
        t13 += v * b13;
        t14 += v * b14;
        t15 += v * b15;
        v = a[1];
        t1 += v * b0;
        t2 += v * b1;
        t3 += v * b2;
        t4 += v * b3;
        t5 += v * b4;
        t6 += v * b5;
        t7 += v * b6;
        t8 += v * b7;
        t9 += v * b8;
        t10 += v * b9;
        t11 += v * b10;
        t12 += v * b11;
        t13 += v * b12;
        t14 += v * b13;
        t15 += v * b14;
        t16 += v * b15;
        v = a[2];
        t2 += v * b0;
        t3 += v * b1;
        t4 += v * b2;
        t5 += v * b3;
        t6 += v * b4;
        t7 += v * b5;
        t8 += v * b6;
        t9 += v * b7;
        t10 += v * b8;
        t11 += v * b9;
        t12 += v * b10;
        t13 += v * b11;
        t14 += v * b12;
        t15 += v * b13;
        t16 += v * b14;
        t17 += v * b15;
        v = a[3];
        t3 += v * b0;
        t4 += v * b1;
        t5 += v * b2;
        t6 += v * b3;
        t7 += v * b4;
        t8 += v * b5;
        t9 += v * b6;
        t10 += v * b7;
        t11 += v * b8;
        t12 += v * b9;
        t13 += v * b10;
        t14 += v * b11;
        t15 += v * b12;
        t16 += v * b13;
        t17 += v * b14;
        t18 += v * b15;
        v = a[4];
        t4 += v * b0;
        t5 += v * b1;
        t6 += v * b2;
        t7 += v * b3;
        t8 += v * b4;
        t9 += v * b5;
        t10 += v * b6;
        t11 += v * b7;
        t12 += v * b8;
        t13 += v * b9;
        t14 += v * b10;
        t15 += v * b11;
        t16 += v * b12;
        t17 += v * b13;
        t18 += v * b14;
        t19 += v * b15;
        v = a[5];
        t5 += v * b0;
        t6 += v * b1;
        t7 += v * b2;
        t8 += v * b3;
        t9 += v * b4;
        t10 += v * b5;
        t11 += v * b6;
        t12 += v * b7;
        t13 += v * b8;
        t14 += v * b9;
        t15 += v * b10;
        t16 += v * b11;
        t17 += v * b12;
        t18 += v * b13;
        t19 += v * b14;
        t20 += v * b15;
        v = a[6];
        t6 += v * b0;
        t7 += v * b1;
        t8 += v * b2;
        t9 += v * b3;
        t10 += v * b4;
        t11 += v * b5;
        t12 += v * b6;
        t13 += v * b7;
        t14 += v * b8;
        t15 += v * b9;
        t16 += v * b10;
        t17 += v * b11;
        t18 += v * b12;
        t19 += v * b13;
        t20 += v * b14;
        t21 += v * b15;
        v = a[7];
        t7 += v * b0;
        t8 += v * b1;
        t9 += v * b2;
        t10 += v * b3;
        t11 += v * b4;
        t12 += v * b5;
        t13 += v * b6;
        t14 += v * b7;
        t15 += v * b8;
        t16 += v * b9;
        t17 += v * b10;
        t18 += v * b11;
        t19 += v * b12;
        t20 += v * b13;
        t21 += v * b14;
        t22 += v * b15;
        v = a[8];
        t8 += v * b0;
        t9 += v * b1;
        t10 += v * b2;
        t11 += v * b3;
        t12 += v * b4;
        t13 += v * b5;
        t14 += v * b6;
        t15 += v * b7;
        t16 += v * b8;
        t17 += v * b9;
        t18 += v * b10;
        t19 += v * b11;
        t20 += v * b12;
        t21 += v * b13;
        t22 += v * b14;
        t23 += v * b15;
        v = a[9];
        t9 += v * b0;
        t10 += v * b1;
        t11 += v * b2;
        t12 += v * b3;
        t13 += v * b4;
        t14 += v * b5;
        t15 += v * b6;
        t16 += v * b7;
        t17 += v * b8;
        t18 += v * b9;
        t19 += v * b10;
        t20 += v * b11;
        t21 += v * b12;
        t22 += v * b13;
        t23 += v * b14;
        t24 += v * b15;
        v = a[10];
        t10 += v * b0;
        t11 += v * b1;
        t12 += v * b2;
        t13 += v * b3;
        t14 += v * b4;
        t15 += v * b5;
        t16 += v * b6;
        t17 += v * b7;
        t18 += v * b8;
        t19 += v * b9;
        t20 += v * b10;
        t21 += v * b11;
        t22 += v * b12;
        t23 += v * b13;
        t24 += v * b14;
        t25 += v * b15;
        v = a[11];
        t11 += v * b0;
        t12 += v * b1;
        t13 += v * b2;
        t14 += v * b3;
        t15 += v * b4;
        t16 += v * b5;
        t17 += v * b6;
        t18 += v * b7;
        t19 += v * b8;
        t20 += v * b9;
        t21 += v * b10;
        t22 += v * b11;
        t23 += v * b12;
        t24 += v * b13;
        t25 += v * b14;
        t26 += v * b15;
        v = a[12];
        t12 += v * b0;
        t13 += v * b1;
        t14 += v * b2;
        t15 += v * b3;
        t16 += v * b4;
        t17 += v * b5;
        t18 += v * b6;
        t19 += v * b7;
        t20 += v * b8;
        t21 += v * b9;
        t22 += v * b10;
        t23 += v * b11;
        t24 += v * b12;
        t25 += v * b13;
        t26 += v * b14;
        t27 += v * b15;
        v = a[13];
        t13 += v * b0;
        t14 += v * b1;
        t15 += v * b2;
        t16 += v * b3;
        t17 += v * b4;
        t18 += v * b5;
        t19 += v * b6;
        t20 += v * b7;
        t21 += v * b8;
        t22 += v * b9;
        t23 += v * b10;
        t24 += v * b11;
        t25 += v * b12;
        t26 += v * b13;
        t27 += v * b14;
        t28 += v * b15;
        v = a[14];
        t14 += v * b0;
        t15 += v * b1;
        t16 += v * b2;
        t17 += v * b3;
        t18 += v * b4;
        t19 += v * b5;
        t20 += v * b6;
        t21 += v * b7;
        t22 += v * b8;
        t23 += v * b9;
        t24 += v * b10;
        t25 += v * b11;
        t26 += v * b12;
        t27 += v * b13;
        t28 += v * b14;
        t29 += v * b15;
        v = a[15];
        t15 += v * b0;
        t16 += v * b1;
        t17 += v * b2;
        t18 += v * b3;
        t19 += v * b4;
        t20 += v * b5;
        t21 += v * b6;
        t22 += v * b7;
        t23 += v * b8;
        t24 += v * b9;
        t25 += v * b10;
        t26 += v * b11;
        t27 += v * b12;
        t28 += v * b13;
        t29 += v * b14;
        t30 += v * b15;
        t0 += 38 * t16;
        t1 += 38 * t17;
        t2 += 38 * t18;
        t3 += 38 * t19;
        t4 += 38 * t20;
        t5 += 38 * t21;
        t6 += 38 * t22;
        t7 += 38 * t23;
        t8 += 38 * t24;
        t9 += 38 * t25;
        t10 += 38 * t26;
        t11 += 38 * t27;
        t12 += 38 * t28;
        t13 += 38 * t29;
        t14 += 38 * t30;
        // t15 left as is
        // first car
        c = 1;
        v = t0 + c + 65535;
        c = Math.floor(v / 65536);
        t0 = v - c * 65536;
        v = t1 + c + 65535;
        c = Math.floor(v / 65536);
        t1 = v - c * 65536;
        v = t2 + c + 65535;
        c = Math.floor(v / 65536);
        t2 = v - c * 65536;
        v = t3 + c + 65535;
        c = Math.floor(v / 65536);
        t3 = v - c * 65536;
        v = t4 + c + 65535;
        c = Math.floor(v / 65536);
        t4 = v - c * 65536;
        v = t5 + c + 65535;
        c = Math.floor(v / 65536);
        t5 = v - c * 65536;
        v = t6 + c + 65535;
        c = Math.floor(v / 65536);
        t6 = v - c * 65536;
        v = t7 + c + 65535;
        c = Math.floor(v / 65536);
        t7 = v - c * 65536;
        v = t8 + c + 65535;
        c = Math.floor(v / 65536);
        t8 = v - c * 65536;
        v = t9 + c + 65535;
        c = Math.floor(v / 65536);
        t9 = v - c * 65536;
        v = t10 + c + 65535;
        c = Math.floor(v / 65536);
        t10 = v - c * 65536;
        v = t11 + c + 65535;
        c = Math.floor(v / 65536);
        t11 = v - c * 65536;
        v = t12 + c + 65535;
        c = Math.floor(v / 65536);
        t12 = v - c * 65536;
        v = t13 + c + 65535;
        c = Math.floor(v / 65536);
        t13 = v - c * 65536;
        v = t14 + c + 65535;
        c = Math.floor(v / 65536);
        t14 = v - c * 65536;
        v = t15 + c + 65535;
        c = Math.floor(v / 65536);
        t15 = v - c * 65536;
        t0 += c - 1 + 37 * (c - 1);
        // second car
        c = 1;
        v = t0 + c + 65535;
        c = Math.floor(v / 65536);
        t0 = v - c * 65536;
        v = t1 + c + 65535;
        c = Math.floor(v / 65536);
        t1 = v - c * 65536;
        v = t2 + c + 65535;
        c = Math.floor(v / 65536);
        t2 = v - c * 65536;
        v = t3 + c + 65535;
        c = Math.floor(v / 65536);
        t3 = v - c * 65536;
        v = t4 + c + 65535;
        c = Math.floor(v / 65536);
        t4 = v - c * 65536;
        v = t5 + c + 65535;
        c = Math.floor(v / 65536);
        t5 = v - c * 65536;
        v = t6 + c + 65535;
        c = Math.floor(v / 65536);
        t6 = v - c * 65536;
        v = t7 + c + 65535;
        c = Math.floor(v / 65536);
        t7 = v - c * 65536;
        v = t8 + c + 65535;
        c = Math.floor(v / 65536);
        t8 = v - c * 65536;
        v = t9 + c + 65535;
        c = Math.floor(v / 65536);
        t9 = v - c * 65536;
        v = t10 + c + 65535;
        c = Math.floor(v / 65536);
        t10 = v - c * 65536;
        v = t11 + c + 65535;
        c = Math.floor(v / 65536);
        t11 = v - c * 65536;
        v = t12 + c + 65535;
        c = Math.floor(v / 65536);
        t12 = v - c * 65536;
        v = t13 + c + 65535;
        c = Math.floor(v / 65536);
        t13 = v - c * 65536;
        v = t14 + c + 65535;
        c = Math.floor(v / 65536);
        t14 = v - c * 65536;
        v = t15 + c + 65535;
        c = Math.floor(v / 65536);
        t15 = v - c * 65536;
        t0 += c - 1 + 37 * (c - 1);
        o[0] = t0;
        o[1] = t1;
        o[2] = t2;
        o[3] = t3;
        o[4] = t4;
        o[5] = t5;
        o[6] = t6;
        o[7] = t7;
        o[8] = t8;
        o[9] = t9;
        o[10] = t10;
        o[11] = t11;
        o[12] = t12;
        o[13] = t13;
        o[14] = t14;
        o[15] = t15;
    }
    function S(o, a) {
        M(o, a, a);
    }
    function inv25519(o, i) {
        let c = gf();
        let a;
        for (a = 0; a < 16; a++)
            c[a] = i[a];
        for (a = 253; a >= 0; a--) {
            S(c, c);
            if (a !== 2 && a !== 4)
                M(c, c, i);
        }
        for (a = 0; a < 16; a++)
            o[a] = c[a];
    }
    function pow2523(o, i) {
        let c = gf();
        let a;
        for (a = 0; a < 16; a++)
            c[a] = i[a];
        for (a = 250; a >= 0; a--) {
            S(c, c);
            if (a !== 1)
                M(c, c, i);
        }
        for (a = 0; a < 16; a++)
            o[a] = c[a];
    }
    function add(p, q) {
        let a = gf(), b = gf(), c = gf(), d = gf(), e = gf(), f = gf(), g = gf(), h = gf(), t = gf();
        Z(a, p[1], p[0]);
        Z(t, q[1], q[0]);
        M(a, a, t);
        A(b, p[0], p[1]);
        A(t, q[0], q[1]);
        M(b, b, t);
        M(c, p[3], q[3]);
        M(c, c, D2);
        M(d, p[2], q[2]);
        A(d, d, d);
        Z(e, b, a);
        Z(f, d, c);
        A(g, d, c);
        A(h, b, a);
        M(p[0], e, f);
        M(p[1], h, g);
        M(p[2], g, f);
        M(p[3], e, h);
    }
    function cswap(p, q, b) {
        let i;
        for (i = 0; i < 4; i++) {
            sel25519(p[i], q[i], b);
        }
    }
    function pack(r, p) {
        let tx = gf(), ty = gf(), zi = gf();
        inv25519(zi, p[2]);
        M(tx, p[0], zi);
        M(ty, p[1], zi);
        pack25519(r, ty);
        r[31] ^= par25519(tx) << 7;
    }
    function scalarmult(p, q, s) {
        let b, i;
        set25519(p[0], gf0);
        set25519(p[1], gf1);
        set25519(p[2], gf1);
        set25519(p[3], gf0);
        for (i = 255; i >= 0; --i) {
            b = (s[(i / 8) | 0] >> (i & 7)) & 1;
            cswap(p, q, b);
            add(q, p);
            add(p, p);
            cswap(p, q, b);
        }
    }
    function scalarbase(p, s) {
        let q = [gf(), gf(), gf(), gf()];
        set25519(q[0], X);
        set25519(q[1], Y);
        set25519(q[2], gf1);
        M(q[3], X, Y);
        scalarmult(p, q, s);
    }
    let L = new Float64Array([
        0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0x10,
    ]);
    function modL(r, x) {
        let carry, i, j, k;
        for (i = 63; i >= 32; --i) {
            carry = 0;
            for (j = i - 32, k = i - 12; j < k; ++j) {
                x[j] += carry - 16 * x[i] * L[j - (i - 32)];
                carry = Math.floor((x[j] + 128) / 256);
                x[j] -= carry * 256;
            }
            x[j] += carry;
            x[i] = 0;
        }
        carry = 0;
        for (j = 0; j < 32; j++) {
            x[j] += carry - (x[31] >> 4) * L[j];
            carry = x[j] >> 8;
            x[j] &= 255;
        }
        for (j = 0; j < 32; j++)
            x[j] -= carry * L[j];
        for (i = 0; i < 32; i++) {
            x[i + 1] += x[i] >> 8;
            r[i] = x[i] & 255;
        }
    }
    function unpackneg(r, p) {
        let t = gf(), chk = gf(), num = gf(), den = gf(), den2 = gf(), den4 = gf(), den6 = gf();
        set25519(r[2], gf1);
        unpack25519(r[1], p);
        S(num, r[1]);
        M(den, num, D);
        Z(num, num, r[2]);
        A(den, r[2], den);
        S(den2, den);
        S(den4, den2);
        M(den6, den4, den2);
        M(t, den6, num);
        M(t, t, den);
        pow2523(t, t);
        M(t, t, num);
        M(t, t, den);
        M(t, t, den);
        M(r[0], t, den);
        S(chk, r[0]);
        M(chk, chk, den);
        if (neq25519(chk, num))
            M(r[0], r[0], I);
        S(chk, r[0]);
        M(chk, chk, den);
        if (neq25519(chk, num))
            return -1;
        if (par25519(r[0]) === p[31] >> 7)
            Z(r[0], gf0, r[0]);
        M(r[3], r[0], r[1]);
        return 0;
    }
    function reduce(r) {
        let x = new Float64Array(64), i;
        for (i = 0; i < 64; i++)
            x[i] = r[i];
        for (i = 0; i < 64; i++)
            r[i] = 0;
        modL(r, x);
    }
    function crypto_sign_keypair(pk, sk) {
        let d = new Uint8Array(64);
        let p = [gf(), gf(), gf(), gf()];
        let i;
        sha512internal(d, sk, 32);
        d[0] &= 248;
        d[31] &= 127;
        d[31] |= 64;
        scalarbase(p, d);
        pack(pk, p);
        for (i = 0; i < 32; i++)
            sk[i + 32] = pk[i];
        return 0;
    }
    function crypto_sign_open(m, sm, n, pk) {
        let i;
        let t = new Uint8Array(32), h = new Uint8Array(64);
        let p = [gf(), gf(), gf(), gf()], q = [gf(), gf(), gf(), gf()];
        if (n < 64)
            return -1;
        if (unpackneg(q, pk))
            return -1;
        for (i = 0; i < n; i++)
            m[i] = sm[i];
        for (i = 0; i < 32; i++)
            m[i + 32] = pk[i];
        sha512internal(h, m, n);
        reduce(h);
        scalarmult(p, q, h);
        scalarbase(q, sm.subarray(32));
        add(p, q);
        pack(t, p);
        n -= 64;
        if (crypto_verify_32(sm, 0, t, 0)) {
            for (i = 0; i < n; i++)
                m[i] = 0;
            return -1;
        }
        for (i = 0; i < n; i++)
            m[i] = sm[i + 64];
        return n;
    }
    // Note: difference from C - smlen returned, not passed as argument.
    function crypto_sign(sm, m, n, sk) {
        let d = new Uint8Array(64), h = new Uint8Array(64), r = new Uint8Array(64);
        let i, j, x = new Float64Array(64);
        let p = [gf(), gf(), gf(), gf()];
        sha512internal(d, sk, 32);
        d[0] &= 248;
        d[31] &= 127;
        d[31] |= 64;
        let smlen = n + 64;
        for (i = 0; i < n; i++)
            sm[64 + i] = m[i];
        for (i = 0; i < 32; i++)
            sm[32 + i] = d[32 + i];
        sha512internal(r, sm.subarray(32), n + 32);
        reduce(r);
        scalarbase(p, r);
        pack(sm, p);
        for (i = 32; i < 64; i++)
            sm[i] = sk[i];
        sha512internal(h, sm, n + 64);
        reduce(h);
        for (i = 0; i < 64; i++)
            x[i] = 0;
        for (i = 0; i < 32; i++)
            x[i] = r[i];
        for (i = 0; i < 32; i++) {
            for (j = 0; j < 32; j++) {
                x[i + j] += h[i] * d[j];
            }
        }
        modL(sm.subarray(32), x);
        return smlen;
    }
    // Zero types to make error returns more convenient.
    const nu8$2 = new Uint8Array(0);
    const nkp$1 = { publicKey: nu8$2, secretKey: nu8$2 };
    // checkAllUint8Array is a helper function to perform input checking on the
    // crypto API functions. Because the kernel is often hot-loading untrusted
    // code, we cannot depend on typescript to provide type safety.
    function checkAllUint8Array(...args) {
        for (let i = 0; i < args.length; i++) {
            if (!(args[i] instanceof Uint8Array)) {
                return "unexpected type, use Uint8Array";
            }
        }
        return null;
    }
    // ed25519KeypairFromEntropy is a function that generates an ed25519 keypair
    // from the provided entropy.
    function ed25519KeypairFromEntropy(seed) {
        // Input checking.
        let errU8 = checkAllUint8Array(seed);
        if (errU8 !== null) {
            return [nkp$1, addContextToErr(errU8, "seed is invalid")];
        }
        if (seed.length !== crypto_sign_SEEDBYTES) {
            return [nkp$1, "bad seed size"];
        }
        // Build the keypair.
        let pk = new Uint8Array(crypto_sign_PUBLICKEYBYTES);
        let sk = new Uint8Array(crypto_sign_SECRETKEYBYTES);
        for (let i = 0; i < 32; i++) {
            sk[i] = seed[i];
        }
        crypto_sign_keypair(pk, sk);
        return [
            {
                publicKey: pk,
                secretKey: sk,
            },
            null,
        ];
    }
    // ed25519Sign will produce an ed25519 signature of a given input.
    function ed25519Sign(msg, secretKey) {
        // Input checking.
        let errU8 = checkAllUint8Array(msg, secretKey);
        if (errU8 !== null) {
            return [nu8$2, addContextToErr(errU8, "inputs are invalid")];
        }
        if (secretKey.length !== crypto_sign_SECRETKEYBYTES) {
            return [nu8$2, "bad secret key size"];
        }
        // Build the signature.
        let signedMsg = new Uint8Array(crypto_sign_BYTES + msg.length);
        crypto_sign(signedMsg, msg, msg.length, secretKey);
        let sig = new Uint8Array(crypto_sign_BYTES);
        for (let i = 0; i < sig.length; i++) {
            sig[i] = signedMsg[i];
        }
        return [sig, null];
    }
    // ed25519Verify will check whether a signature is valid against the given
    // publicKey and message.
    function ed25519Verify(msg, sig, publicKey) {
        let errU8 = checkAllUint8Array(msg, sig, publicKey);
        if (errU8 !== null) {
            return false;
        }
        if (sig.length !== crypto_sign_BYTES) {
            return false;
        }
        if (publicKey.length !== crypto_sign_PUBLICKEYBYTES) {
            return false;
        }
        let sm = new Uint8Array(crypto_sign_BYTES + msg.length);
        let m = new Uint8Array(crypto_sign_BYTES + msg.length);
        let i;
        for (i = 0; i < crypto_sign_BYTES; i++) {
            sm[i] = sig[i];
        }
        for (i = 0; i < msg.length; i++) {
            sm[i + crypto_sign_BYTES] = msg[i];
        }
        return crypto_sign_open(m, sm, sm.length, publicKey) >= 0;
    }

    // Define the number of entropy words used when generating the seed.
    const SEED_ENTROPY_WORDS = 13;
    const SEED_BYTES = 16;
    // deriveChildSeed is a helper function to derive a child seed from a parent
    // seed using a string as the path.
    function deriveChildSeed(parentSeed, derivationTag) {
        let tagU8 = new TextEncoder().encode(" - " + derivationTag);
        let preimage = new Uint8Array(parentSeed.length + tagU8.length);
        preimage.set(parentSeed, 0);
        preimage.set(tagU8, parentSeed.length);
        let hash = sha512(preimage);
        return hash.slice(0, SEED_BYTES);
    }
    // deriveMyskyRoot is a helper function to derive the root mysky seed of the
    // provided user seed.
    //
    // NOTE: This is code is to provide legacy compatibility with the MySky
    // ecosystem. Compatibility cannot be broken here.
    function deriveMyskyRootKeypair(userSeed) {
        let saltBytes = new TextEncoder().encode("root discoverable key");
        let saltHash = sha512(saltBytes);
        let userSeedHash = sha512(userSeed);
        let mergedHash = sha512(new Uint8Array([...saltHash, ...userSeedHash]));
        let keyEntropy = mergedHash.slice(0, 32);
        // Error is ignored because it should not be possible with the provided
        // inputs.
        let [keypair] = ed25519KeypairFromEntropy(keyEntropy);
        return keypair;
    }
    // generateSeedPhraseDeterministic will generate and verify a seed phrase for
    // the user.
    function generateSeedPhraseDeterministic(password) {
        let u8 = new TextEncoder().encode(password);
        let buf = sha512(u8);
        let randNums = Uint16Array.from(buf);
        // Generate the seed phrase from the randNums.
        let seedWords = [];
        for (let i = 0; i < SEED_ENTROPY_WORDS; i++) {
            let wordIndex = randNums[i] % dictionary.length;
            if (i == SEED_ENTROPY_WORDS - 1) {
                wordIndex = randNums[i] % (dictionary.length / 4);
            }
            seedWords.push(dictionary[wordIndex]);
        }
        // Convert the seedWords to a seed.
        let [seed, err1] = seedWordsToSeed(seedWords);
        if (err1 !== null) {
            return ["", err1];
        }
        // Compute the checksum.
        let [checksumOne, checksumTwo, err2] = seedToChecksumWords(seed);
        if (err2 !== null) {
            return ["", err2];
        }
        // Assemble the final seed phrase and set the text field.
        let allWords = [...seedWords, checksumOne, checksumTwo];
        let seedPhrase = allWords.join(" ");
        return [seedPhrase, null];
    }
    // seedToChecksumWords will compute the two checksum words for the provided
    // seed. The two return values are the two checksum words.
    function seedToChecksumWords(seed) {
        // Input validation.
        if (seed.length !== SEED_BYTES) {
            return ["", "", `seed has the wrong length: ${seed.length}`];
        }
        // Get the hash.
        let h = sha512(seed);
        // Turn the hash into two words.
        let word1 = h[0] << 8;
        word1 += h[1];
        word1 >>= 6;
        let word2 = h[1] << 10;
        word2 &= 0xffff;
        word2 += h[2] << 2;
        word2 >>= 6;
        return [dictionary[word1], dictionary[word2], null];
    }
    // validSeedPhrase checks whether the provided seed phrase is valid, returning
    // an error if not. If the seed phrase is valid, the full seed will be returned
    // as a Uint8Array.
    function validSeedPhrase(seedPhrase) {
        // Create a helper function to make the below code more readable.
        let prefix = function (s) {
            return s.slice(0, DICTIONARY_UNIQUE_PREFIX);
        };
        // Pull the seed into its respective parts.
        let seedWordsAndChecksum = seedPhrase.split(" ");
        let seedWords = seedWordsAndChecksum.slice(0, SEED_ENTROPY_WORDS);
        let checksumOne = seedWordsAndChecksum[SEED_ENTROPY_WORDS];
        let checksumTwo = seedWordsAndChecksum[SEED_ENTROPY_WORDS + 1];
        // Convert the seedWords to a seed.
        let [seed, err1] = seedWordsToSeed(seedWords);
        if (err1 !== null) {
            return [new Uint8Array(0), addContextToErr(err1, "unable to parse seed phrase")];
        }
        let [checksumOneVerify, checksumTwoVerify, err2] = seedToChecksumWords(seed);
        if (err2 !== null) {
            return [new Uint8Array(0), addContextToErr(err2, "could not compute checksum words")];
        }
        if (prefix(checksumOne) !== prefix(checksumOneVerify)) {
            return [new Uint8Array(0), "first checksum word is invalid"];
        }
        if (prefix(checksumTwo) !== prefix(checksumTwoVerify)) {
            return [new Uint8Array(0), "second checksum word is invalid"];
        }
        return [seed, null];
    }
    // seedWordsToSeed will convert a provided seed phrase to to a Uint8Array that
    // represents the cryptographic seed in bytes.
    function seedWordsToSeed(seedWords) {
        // Input checking.
        if (seedWords.length !== SEED_ENTROPY_WORDS) {
            return [new Uint8Array(0), `Seed words should have length ${SEED_ENTROPY_WORDS} but has length ${seedWords.length}`];
        }
        // We are getting 16 bytes of entropy.
        let bytes = new Uint8Array(SEED_BYTES);
        let curByte = 0;
        let curBit = 0;
        for (let i = 0; i < SEED_ENTROPY_WORDS; i++) {
            // Determine which number corresponds to the next word.
            let word = -1;
            for (let j = 0; j < dictionary.length; j++) {
                if (seedWords[i].slice(0, DICTIONARY_UNIQUE_PREFIX) === dictionary[j].slice(0, DICTIONARY_UNIQUE_PREFIX)) {
                    word = j;
                    break;
                }
            }
            if (word === -1) {
                return [new Uint8Array(0), `word '${seedWords[i]}' at index ${i} not found in dictionary`];
            }
            let wordBits = 10;
            if (i === SEED_ENTROPY_WORDS - 1) {
                wordBits = 8;
            }
            // Iterate over the bits of the 10- or 8-bit word.
            for (let j = 0; j < wordBits; j++) {
                let bitSet = (word & (1 << (wordBits - j - 1))) > 0;
                if (bitSet) {
                    bytes[curByte] |= 1 << (8 - curBit - 1);
                }
                curBit += 1;
                if (curBit >= 8) {
                    // Current byte has 8 bits, go to the next byte.
                    curByte += 1;
                    curBit = 0;
                }
            }
        }
        return [bytes, null];
    }
    // seedPhraseToSeed will take a seed phrase and return the corresponding seed,
    // providing an error if the seed phrase is invalid. This is an alias of
    // validSeedPhrase.
    function seedPhraseToSeed(seedPhrase) {
        return validSeedPhrase(seedPhrase);
    }

    // Define some empty values to make our return statements more concise.
    const nu8$1 = new Uint8Array(0);
    const nkp = { publicKey: nu8$1, secretKey: nu8$1 };
    // computeRegistrySignature will take a secret key and the required fields of a
    // registry entry and use them to compute a registry signature, returning both
    // the signature and the encoded data for the registry entry.
    function computeRegistrySignature(secretKey, dataKey, data, revision) {
        // Check that the data is the right size.
        if (data.length > 86) {
            return [nu8$1, "registry data must be at most 86 bytes"];
        }
        // Build the encoded data.
        let [encodedData, errEPB] = encodePrefixedBytes(data);
        if (errEPB !== null) {
            return [nu8$1, addContextToErr(errEPB, "unable to encode provided registry data")];
        }
        let [encodedRevision, errEU64] = encodeU64(revision);
        if (errEU64 !== null) {
            return [nu8$1, addContextToErr(errEU64, "unable to encode the revision number")];
        }
        // Build the signing data.
        let dataToSign = new Uint8Array(32 + 8 + data.length + 8);
        dataToSign.set(dataKey, 0);
        dataToSign.set(encodedData, 32);
        dataToSign.set(encodedRevision, 32 + 8 + data.length);
        let sigHash = blake2b(dataToSign);
        // Sign the data.
        let [sig, errS] = ed25519Sign(sigHash, secretKey);
        if (errS !== null) {
            return [nu8$1, addContextToErr(errS, "unable to sign registry entry")];
        }
        return [sig, null];
    }
    // deriveRegistryEntryID derives a registry entry ID from a provided pubkey and
    // datakey.
    function deriveRegistryEntryID(pubkey, datakey) {
        // Check the lengths of the inputs.
        if (pubkey.length !== 32) {
            return [nu8$1, "pubkey is invalid, length is wrong"];
        }
        if (datakey.length !== 32) {
            return [nu8$1, "datakey is not a valid hash, length is wrong"];
        }
        // Establish the encoding. First 16 bytes is a specifier, second 8
        // bytes declares the length of the pubkey, the next 32 bytes is the
        // pubkey and the final 32 bytes is the datakey. This encoding is
        // determined by the Sia protocol.
        let encoding = new Uint8Array(16 + 8 + 32 + 32);
        // Set the specifier.
        encoding[0] = "e".charCodeAt(0);
        encoding[1] = "d".charCodeAt(0);
        encoding[2] = "2".charCodeAt(0);
        encoding[3] = "5".charCodeAt(0);
        encoding[4] = "5".charCodeAt(0);
        encoding[5] = "1".charCodeAt(0);
        encoding[6] = "9".charCodeAt(0);
        // Set the pubkey.
        let [encodedLen, errU64] = encodeU64(32n);
        if (errU64 !== null) {
            return [nu8$1, addContextToErr(errU64, "unable to encode pubkey length")];
        }
        encoding.set(encodedLen, 16);
        encoding.set(pubkey, 16 + 8);
        encoding.set(datakey, 16 + 8 + 32);
        // Get the final ID by hashing the encoded data.
        let id = blake2b(encoding);
        return [id, null];
    }
    // entryIDToSkylink converts a registry entry id to a resolver skylink.
    function entryIDToSkylink(entryID) {
        let v2Skylink = new Uint8Array(34);
        v2Skylink.set(entryID, 2);
        v2Skylink[0] = 1;
        return bufToB64(v2Skylink);
    }
    // resolverLink will take a registryEntryID and return the corresponding
    // resolver link.
    function resolverLink(entryID) {
        if (entryID.length !== 32) {
            return ["", "provided entry ID has the wrong length"];
        }
        let v2Skylink = new Uint8Array(34);
        v2Skylink.set(entryID, 2);
        v2Skylink[0] = 1;
        let skylink = bufToB64(v2Skylink);
        return [skylink, null];
    }
    // registryEntryKeys will use the user's seed to derive a keypair and a datakey
    // using the provided seed and tags. The keypairTag is a tag which salts the
    // keypair. If you change the input keypairTag, the resulting public key and
    // secret key will be different. The dataKey tag is the salt for the datakey,
    // if you provide a different datakey tag, the resulting datakey will be
    // different.
    //
    // Note that changing the keypair tag will also change the resulting datakey.
    // The purpose of the keypair tag is to obfuscate the fact that two registry
    // entries are owned by the same identity. This obfuscation would break if two
    // different public keys were using the same datakey. Changing the datakey does
    // not change the public key.
    function taggedRegistryEntryKeys(seed, keypairTagStr, datakeyTagStr) {
        if (seed.length !== SEED_BYTES) {
            return [nkp, nu8$1, "seed has the wrong length"];
        }
        if (keypairTagStr.length > 255) {
            return [nkp, nu8$1, "keypairTag must be less than 256 characters"];
        }
        // If no datakey tag was provided, use the empty string.
        if (datakeyTagStr === undefined) {
            datakeyTagStr = "";
        }
        // Generate a unique set of entropy using the seed and keypairTag.
        let keypairTag = new TextEncoder().encode(keypairTagStr);
        let entropyInput = new Uint8Array(keypairTag.length + seed.length);
        entropyInput.set(seed, 0);
        entropyInput.set(keypairTag, seed.length);
        let keypairEntropy = sha512(entropyInput);
        // Use the seed to dervie the datakey for the registry entry. We use
        // a different tag to ensure that the datakey is independently random, such
        // that the registry entry looks like it could be any other registry entry.
        //
        // We don't want it to be possible for two different combinations of
        // tags to end up with the same datakey. If you don't use a length
        // prefix, for example the tags ["123", "456"] and ["12", "3456"] would
        // have the same datakey. You have to add the length prefix to the
        // first tag otherwise you can get pairs like ["6", "4321"] and ["65",
        // "321"] which could end up with the same datakey.
        let datakeyTag = new TextEncoder().encode(datakeyTagStr);
        let datakeyInput = new Uint8Array(seed.length + 1 + keypairTag.length + datakeyTag.length);
        let keypairLen = new Uint8Array(1);
        keypairLen[0] = keypairTag.length;
        datakeyInput.set(seed);
        datakeyInput.set(keypairLen, seed.length);
        datakeyInput.set(keypairTag, seed.length + 1);
        datakeyInput.set(datakeyTag, seed.length + 1 + keypairTag.length);
        let datakeyEntropy = sha512(datakeyInput);
        // Create the private key for the registry entry.
        let [keypair, errKPFE] = ed25519KeypairFromEntropy(keypairEntropy.slice(0, 32));
        if (errKPFE !== null) {
            return [nkp, nu8$1, addContextToErr(errKPFE, "unable to derive keypair")];
        }
        let datakey = datakeyEntropy.slice(0, 32);
        return [keypair, datakey, null];
    }
    // verifyRegistrySignature will verify the signature of a registry entry.
    function verifyRegistrySignature(pubkey, datakey, data, revision, sig) {
        let [encodedData, errEPB] = encodePrefixedBytes(data);
        if (errEPB !== null) {
            return false;
        }
        let [encodedRevision, errU64] = encodeU64(revision);
        if (errU64 !== null) {
            return false;
        }
        let dataToVerify = new Uint8Array(32 + 8 + data.length + 8);
        dataToVerify.set(datakey, 0);
        dataToVerify.set(encodedData, 32);
        dataToVerify.set(encodedRevision, 32 + 8 + data.length);
        let sigHash = blake2b(dataToVerify);
        return ed25519Verify(sigHash, sig, pubkey);
    }

    // validateSkyfilePath checks whether the provided path is a valid path for a
    // file in a skylink.
    function validateSkyfilePath(path) {
        if (path === "") {
            return "path cannot be blank";
        }
        if (path === "..") {
            return "path cannot be ..";
        }
        if (path === ".") {
            return "path cannot be .";
        }
        if (path.startsWith("/")) {
            return "metdata.Filename cannot start with /";
        }
        if (path.startsWith("../")) {
            return "metdata.Filename cannot start with ../";
        }
        if (path.startsWith("./")) {
            return "metdata.Filename cannot start with ./";
        }
        let pathElems = path.split("/");
        for (let i = 0; i < pathElems.length; i++) {
            if (pathElems[i] === ".") {
                return "path cannot have a . element";
            }
            if (pathElems[i] === "..") {
                return "path cannot have a .. element";
            }
            if (pathElems[i] === "") {
                return "path cannot have an empty element, cannot contain //";
            }
        }
        return null;
    }
    // validateSkyfileMetadata checks whether the provided metadata is valid
    // metadata for a skyfile.
    function validateSkyfileMetadata(metadata) {
        // Check that the filename is valid.
        if (!("Filename" in metadata)) {
            return "metadata.Filename does not exist";
        }
        if (typeof metadata.Filename !== "string") {
            return "metadata.Filename is not a string";
        }
        let errVSP = validateSkyfilePath(metadata.Filename);
        if (errVSP !== null) {
            return addContextToErr(errVSP, "metadata.Filename does not have a valid path");
        }
        // Check that there are no subfiles.
        if ("Subfiles" in metadata) {
            // TODO: Fill this out using code from
            // skymodules.ValidateSkyfileMetadata to support subfiles.
            return "cannot upload files that have subfiles";
        }
        // Check that the default path rules are being respected.
        if ("DisableDefaultPath" in metadata && "DefaultPath" in metadata) {
            return "cannot set both a DefaultPath and also DisableDefaultPath";
        }
        if ("DefaultPath" in metadata) {
            // TODO: Fill this out with code from
            // skymodules.validateDefaultPath to support subfiles and
            // default paths.
            return "cannot set a default path if there are no subfiles";
        }
        if ("TryFiles" in metadata) {
            if (!metadata.TryFiles.IsArray()) {
                return "metadata.TryFiles must be an array";
            }
            if (metadata.TryFiles.length === 0) {
                return "metadata.TryFiles should not be empty";
            }
            if ("DefaultPath" in metadata) {
                return "metadata.TryFiles cannot be used alongside DefaultPath";
            }
            if ("DisableDefaultPath" in metadata) {
                return "metadata.TryFiles cannot be used alongside DisableDefaultPath";
            }
            // TODO: finish the TryFiles checking using skymodules.ValidateTryFiles
            return "TryFiles is not supported at this time";
        }
        if ("ErrorPages" in metadata) {
            // TODO: finish using skymodules.ValidateErrorPages
            return "ErrorPages is not supported at this time";
        }
        return null;
    }
    // validSkylink returns true if the provided Uint8Array is a valid skylink.
    // This is an alias for 'parseSkylinkBitfield', as both perform the same
    // validation.
    function validSkylink(skylink) {
        if (skylink.length !== 34) {
            return false;
        }
        let [, , , errPSB] = parseSkylinkBitfield(skylink);
        if (errPSB !== null) {
            return false;
        }
        return true;
    }

    // Helper consts to make returning empty values alongside errors more
    // convenient.
    const nu8 = new Uint8Array(0);
    // verifyResolverLinkProof will check that the given resolver proof matches the
    // provided skylink. If the proof is correct and the signature matches, the
    // data will be returned. The returned link will be a verified skylink.
    function verifyResolverLinkProof(skylink, proof) {
        // Verify the presented skylink is formatted correctly.
        if (skylink.length !== 34) {
            return [nu8, "skylink is malformed, expecting 34 bytes"];
        }
        // Verify that all of the required fields are present in the proof.
        if (!("data" in proof) ||
            !("datakey" in proof) ||
            !("publickey" in proof) ||
            !("signature" in proof) ||
            !("type" in proof) ||
            !("revision" in proof)) {
            return [nu8, "proof is malformed, fields are missing"];
        }
        if (!("algorithm" in proof.publickey) || !("key" in proof.publickey)) {
            return [nu8, "pubkey is malformed"];
        }
        // Verify the typing of the fields.
        if (typeof proof.data !== "string") {
            return [nu8, "data is malformed"];
        }
        let dataStr = proof.data;
        if (typeof proof.datakey !== "string") {
            return [nu8, "datakey is malformed"];
        }
        let datakeyStr = proof.datakey;
        if (proof.publickey.algorithm !== "ed25519") {
            return [nu8, "pubkey has unrecognized algorithm"];
        }
        if (typeof proof.publickey.key !== "string") {
            return [nu8, "pubkey key is malformed"];
        }
        let pubkeyStr = proof.publickey.key;
        if (typeof proof.signature !== "string") {
            return [nu8, "signature is malformed"];
        }
        if (proof.type !== 1n) {
            return [nu8, "registry entry has unrecognized type: " + tryStringify(proof.type)];
        }
        let sigStr = proof.signature;
        if (typeof proof.revision !== "bigint") {
            return [nu8, "revision is malformed"];
        }
        let revision = proof.revision;
        // Decode all of the fields. They are presented in varied types and
        // encodings.
        let [data, errD] = hexToBuf(dataStr);
        if (errD !== null) {
            return [nu8, addContextToErr(errD, "data is invalid hex")];
        }
        let [datakey, errDK] = hexToBuf(datakeyStr);
        if (errDK !== null) {
            return [nu8, addContextToErr(errDK, "datakey is invalid hex")];
        }
        let [pubkey, errPK] = b64ToBuf(pubkeyStr);
        if (errPK !== null) {
            return [nu8, addContextToErr(errPK, "pubkey key is invalid base64")];
        }
        let [sig, errS] = hexToBuf(sigStr);
        if (errS !== null) {
            return [nu8, addContextToErr(errS, "signature is invalid hex")];
        }
        // Verify that the data is a skylink - this is a proof for a resolver,
        // which means the proof is pointing to a specific skylink.
        if (!validSkylink(data)) {
            return [nu8, "this skylink does not resolve to another skylink"];
        }
        // Verify that the combination of the datakey and the public key match
        // the skylink.
        let [entryID, errREID] = deriveRegistryEntryID(pubkey, datakey);
        if (errREID !== null) {
            return [nu8, addContextToErr(errREID, "proof pubkey is malformed")];
        }
        let linkID = skylink.slice(2, 34);
        for (let i = 0; i < entryID.length; i++) {
            if (entryID[i] !== linkID[i]) {
                return [nu8, "proof pubkey and datakey do not match the skylink root"];
            }
        }
        // Verify the signature.
        if (!verifyRegistrySignature(pubkey, datakey, data, revision, sig)) {
            return [nu8, "signature does not match"];
        }
        return [data, null];
    }
    // verifyResolverLinkProofs will verify a set of resolver link proofs provided
    // by a portal after performing a resolver link lookup. Each proof corresponds
    // to one level of resolution. The final value returned will be the V1 skylink
    // at the end of the chain.
    //
    // This function treats the proof as untrusted data and will verify all of the
    // fields that are provided.
    function verifyResolverLinkProofs(skylink, proof) {
        // Check that the proof is an array.
        if (!Array.isArray(proof)) {
            return [nu8, "provided proof is not an array: " + tryStringify(proof)];
        }
        if (proof.length === 0) {
            return [nu8, "proof array is empty"];
        }
        // Check each proof in the chain, returning the final skylink.
        for (let i = 0; i < proof.length; i++) {
            let errVRLP;
            [skylink, errVRLP] = verifyResolverLinkProof(skylink, proof[i]);
            if (errVRLP !== null) {
                return [nu8, addContextToErr(errVRLP, "one of the resolution proofs is invalid")];
            }
        }
        // Though it says 'skylink', the verifier is actually just returning
        // whatever the registry data is. We need to check that the final value
        // is a V1 skylink.
        if (skylink.length !== 34) {
            return [nu8, "final value returned by the resolver link is not a skylink"];
        }
        let [version, , , errPSB] = parseSkylinkBitfield(skylink);
        if (errPSB !== null) {
            return [nu8, addContextToErr(errPSB, "final value returned by resolver link is not a valid skylink")];
        }
        if (version !== 1n) {
            return [nu8, "final value returned by resolver link is not a v1 skylink"];
        }
        return [skylink, null];
    }

    // Establish the function that verifies the result is correct.
    //
    // The fileDataPtr input is an empty object that verifyDownloadResponse will
    // fill with the fileData. It basically allows the verify function to
    // communicate back to the caller. Note that the verify function might be
    // called multiple times in a row if early portals fail to retrieve the data,
    // but the verify function doesn't write to the fileDataPtr until it knows that
    // the download is final.
    function verifyDownloadResponse(response, u8Link, fileDataPtr) {
        return new Promise((resolve) => {
            // Currently the only valid successful response for a download is a
            // 200. Anything else is unexpected and counts as an error.
            if (response.status !== 200) {
                resolve("unrecognized response status " + tryStringify(response.status) + ", expecting 200");
                return;
            }
            // Break the input link into its components.
            let [version, offset, fetchSize, errBF] = parseSkylinkBitfield(u8Link);
            if (errBF !== null) {
                resolve(addContextToErr(errBF, "skylink bitfield could not be parsed"));
                return;
            }
            // If this is a resolver skylink, we need to verify the resolver
            // proofs. This conditional will update the value of 'u8Link' to be the
            // value of the fully resolved link.
            if (version === 2n) {
                // Verify the resolver proofs and update the link to the correct
                // link.
                let proofJSON = response.headers.get("skynet-proof");
                if (proofJSON === null || proofJSON === undefined) {
                    resolve("response did not include resolver proofs");
                    return;
                }
                let [proof, errPJ] = parseJSON(proofJSON);
                if (errPJ !== null) {
                    resolve(addContextToErr(errPJ, "unable to parse resolver link proofs"));
                    return;
                }
                // We need to update the u8Link in-place so that the rest of the
                // function doesn't need special handling.
                let errVRLP;
                [u8Link, errVRLP] = verifyResolverLinkProofs(u8Link, proof);
                if (errVRLP !== null) {
                    resolve(addContextToErr(errVRLP, "unable to verify resolver link proofs"));
                    return;
                }
                // We also need to update the parsed bitfield, because the link has
                // changed.
                [version, offset, fetchSize, errBF] = parseSkylinkBitfield(u8Link);
                if (errBF !== null) {
                    resolve(addContextToErr(errBF, "fully resolved link has invalid bitfield"));
                    return;
                }
                if (version !== 1n) {
                    resolve("fully resolved link does not have version 1");
                    return;
                }
            }
            response
                .arrayBuffer()
                .then((buf) => {
                let [fileData, portalAtFault, errVD] = verifyDownload(u8Link.slice(2, 34), offset, fetchSize, buf);
                if (errVD !== null && portalAtFault) {
                    resolve("received invalid download from portal");
                    return;
                }
                if (errVD !== null) {
                    fileDataPtr.fileData = new Uint8Array(0);
                    fileDataPtr.err = addContextToErr(errVD, "file is corrupt");
                }
                else {
                    fileDataPtr.fileData = fileData;
                    fileDataPtr.err = null;
                }
                // If the portal is not at fault, we tell progressiveFetch that
                // the download was a success. The caller will have to check
                // the fileDataPtr
                resolve(null);
            })
                .catch((err) => {
                resolve(addContextToErr(err, "unable to read response body"));
            });
        });
    }

    // progressiveFetchHelper is the full progressiveFetch function, split out into
    // a helper because the inptus/api is more complicated but only necessary for
    // internal use.
    function progressiveFetchHelper(pfm, resolve, verifyFunction) {
        // If we run out of portals, return an error.
        if (pfm.remainingPortals.length === 0) {
            let newLog = "query failed because all portals have been tried";
            pfm.logs.push(newLog);
            resolve({
                success: false,
                portal: null,
                response: null,
                portalsFailed: pfm.portalsFailed,
                responsesFailed: pfm.responsesFailed,
                messagesFailed: pfm.messagesFailed,
                remainingPortals: null,
                logs: pfm.logs,
            });
            return;
        }
        // Grab the portal and query.
        let portal = pfm.remainingPortals.shift();
        let query = portal + pfm.endpoint;
        // Create a helper function for trying the next portal.
        let nextPortal = function (response, log) {
            if (response !== null) {
                response
                    .clone()
                    .text()
                    .then((t) => {
                    pfm.logs.push(log);
                    pfm.portalsFailed.push(portal);
                    pfm.responsesFailed.push(response);
                    pfm.messagesFailed.push(t);
                    progressiveFetchHelper(pfm, resolve, verifyFunction);
                });
            }
            else {
                pfm.logs.push(log);
                pfm.portalsFailed.push(portal);
                pfm.responsesFailed.push(response);
                pfm.messagesFailed.push("");
                progressiveFetchHelper(pfm, resolve, verifyFunction);
            }
        };
        // Try sending the query to the portal.
        fetch(query, pfm.fetchOpts)
            .then((response) => {
            // Check for a 5XX error.
            if (!("status" in response) || typeof response.status !== "number") {
                nextPortal(response, "portal has returned invalid response\n" + tryStringify({ portal, query }));
                return;
            }
            if (response.status < 200 || response.status >= 300) {
                nextPortal(response, "portal has returned error status\n" + tryStringify({ portal, query }));
                return;
            }
            // Check the result against the verify function.
            verifyFunction(response.clone()).then((errVF) => {
                if (errVF !== null) {
                    nextPortal(response, "verify function has returned an error from portal " + portal + " - " + errVF);
                    return;
                }
                // Success! Return the response.
                resolve({
                    success: true,
                    portal,
                    response,
                    portalsFailed: pfm.portalsFailed,
                    responsesFailed: pfm.responsesFailed,
                    remainingPortals: pfm.remainingPortals,
                    messagesFailed: pfm.messagesFailed,
                    logs: pfm.logs,
                });
            });
        })
            .catch((err) => {
            // This portal failed, try again with the next portal.
            nextPortal(null, "fetch returned an error\n" + tryStringify(err) + tryStringify(pfm.fetchOpts));
            return;
        });
    }
    // progressiveFetch will query multiple portals until one returns with a
    // non-error response. In the event of a 4XX response, progressiveFetch will
    // keep querying additional portals to try and find a working 2XX response. In
    // the event that no working 2XX response is found, the first 4XX response will
    // be returned.
    //
    // If progressiveFetch returns a 2XX response, it merely means that the portal
    // returned a 2XX response. progressiveFetch cannot be confident that the
    // portal has returned a correct/honest message, the verification has to be
    // handled by the caller. The response (progressiveFetchResult) contains the
    // list of portals that progressiveFetch hasn't tried yet. In the event that
    // the 2XX response is not correct, the progressiveFetchResult contains the
    // list of failover portals that have not been used yet, allowing
    // progressiveFetch to be called again.
    //
    // This progressive method of querying portals helps prevent queries from
    // failing, but if the first portal is not a good portal it introduces
    // substantial latency. progressiveFetch does not do anything to make sure the
    // portals are the best portals, it just queries them in order. The caller
    // should make a best attempt to always have the best, most reliable and
    // fastest portal as the first portal in the list.
    //
    // The reason that we don't blindly accept a 4XX response from a portal is that
    // we have no way of verifying that the 4XX is legitimate. We don't trust the
    // portal, and we can't give a rogue portal the opportunity to interrupt our
    // user experience simply by returning a dishonest 404. So we need to keep
    // querying more portals and gain confidence that the 404 a truthful response.
    function progressiveFetch(endpoint, fetchOpts, portals, verifyFunction) {
        let portalsCopy = [...portals];
        return new Promise((resolve) => {
            let pfm = {
                endpoint,
                fetchOpts,
                remainingPortals: portalsCopy,
                portalsFailed: [],
                responsesFailed: [],
                messagesFailed: [],
                logs: [],
            };
            progressiveFetchHelper(pfm, resolve, verifyFunction);
        });
    }

    // downloadSkylink will download the provided skylink.
    function downloadSkylink(skylink) {
        return new Promise((resolve) => {
            // Get the Uint8Array of the input skylink.
            let [u8Link, errBTB] = b64ToBuf(skylink);
            if (errBTB !== null) {
                resolve([new Uint8Array(0), addContextToErr(errBTB, "unable to decode skylink")]);
                return;
            }
            if (!validSkylink(u8Link)) {
                resolve([new Uint8Array(0), "skylink appears to be invalid"]);
                return;
            }
            // Prepare the download call.
            let endpoint = "/skynet/trustless/basesector/" + skylink;
            let fileDataPtr = { fileData: new Uint8Array(0), err: null };
            let verifyFunction = function (response) {
                return verifyDownloadResponse(response, u8Link, fileDataPtr);
            };
            // Perform the download call.
            progressiveFetch(endpoint, null, defaultPortalList, verifyFunction).then((result) => {
                // Return an error if the call failed.
                if (result.success !== true) {
                    // Check for a 404.
                    for (let i = 0; i < result.responsesFailed.length; i++) {
                        if (result.responsesFailed[i].status === 404) {
                            resolve([new Uint8Array(0), "404"]);
                            return;
                        }
                    }
                    // Error is not a 404, return the logs as the error.
                    let err = tryStringify(result.logs);
                    resolve([new Uint8Array(0), addContextToErr(err, "unable to complete download")]);
                    return;
                }
                // Check if the portal is honest but the download is corrupt.
                if (fileDataPtr.err !== null) {
                    resolve([new Uint8Array(0), addContextToErr(fileDataPtr.err, "download is corrupt")]);
                    return;
                }
                resolve([fileDataPtr.fileData, null]);
            });
        });
    }

    // verifyDecodedResp will verify the decoded response from a portal for a
    // regRead call.
    function verifyDecodedResp(resp, data, pubkey, datakey) {
        // Status is expected to be 200.
        if (resp.status !== 200) {
            return "expected 200 response status, got: " + tryStringify(resp.status);
        }
        // Verify that all required fields were provided.
        if (!("data" in data)) {
            return "expected data field in response";
        }
        if (typeof data.data !== "string") {
            return "expected data field to be a string";
        }
        if (!("revision" in data)) {
            return "expected revision in response";
        }
        if (typeof data.revision !== "bigint") {
            return "expected revision to be a number";
        }
        if (!("signature" in data)) {
            return "expected signature in response";
        }
        if (typeof data.signature !== "string") {
            return "expected signature to be a string";
        }
        // Parse out the fields we need.
        let [entryData, errHTB] = hexToBuf(data.data);
        if (errHTB !== null) {
            return "could not decode registry data from response";
        }
        let [sig, errHTB2] = hexToBuf(data.signature);
        if (errHTB2 !== null) {
            return "could not decode signature from response";
        }
        // Verify the signature.
        if (!verifyRegistrySignature(pubkey, datakey, entryData, data.revision, sig)) {
            return "signature mismatch";
        }
        // TODO: Need to be handling type 2 registry entries here otherwise we will
        // be flagging non malicious portals as malicious.
        return null;
    }
    // verifyRegistryReadResponse will verify that the registry read response from
    // the portal was correct.
    function verifyRegistryReadResponse(resp, pubkey, datakey) {
        return new Promise((resolve) => {
            resp
                .text()
                .then((str) => {
                let [obj, errPJ] = parseJSON(str);
                if (errPJ !== null) {
                    resolve(addContextToErr(errPJ, "unable to parse registry response"));
                    return;
                }
                let errVDR = verifyDecodedResp(resp, obj, pubkey, datakey);
                if (errVDR !== null) {
                    resolve(addContextToErr(errVDR, "regRead response failed verification"));
                    return;
                }
                resolve(null);
            })
                .catch((err) => {
                resolve(addContextToErr(tryStringify(err), "unable to decode response"));
            });
        });
    }
    // verifyRegistryWriteResponse will verify that the response from a
    // registryWrite call is valid. There's not much to verify beyond looking for
    // the right response code, as the portal is not providing us with data, just
    // confirming that a write succeeded.
    function verifyRegistryWriteResponse(resp) {
        return new Promise((resolve) => {
            if (resp.status === 204) {
                resolve(null);
            }
            resolve("expecting 200 status code for registry write, got:" + resp.status.toString());
        });
    }

    // stringifyjson.ts is split into a separate file to avoid a circular
    // dependency. If you merge it with stringifytry.ts you have a circular import
    // where err.js is importing stringify.js and stringify.js is importing err.js.
    // Splitting the functions out resolves this issue.
    // jsonStringify is a replacement for JSON.stringify that returns an error
    // rather than throwing.
    function jsonStringify(obj) {
        try {
            let str = JSON.stringify(obj);
            return [str, null];
        }
        catch (err) {
            return ["", addContextToErr(tryStringify(err), "unable to stringify object")];
        }
    }

    var skynet = /*#__PURE__*/Object.freeze({
        __proto__: null,
        blake2b: blake2b,
        defaultPortalList: defaultPortalList,
        dictionary: dictionary,
        downloadSkylink: downloadSkylink,
        verifyDownload: verifyDownload,
        verifyDownloadResponse: verifyDownloadResponse,
        ed25519Sign: ed25519Sign,
        ed25519Verify: ed25519Verify,
        b64ToBuf: b64ToBuf,
        bufToB64: bufToB64,
        bufToHex: bufToHex,
        bufToStr: bufToStr,
        encodePrefixedBytes: encodePrefixedBytes,
        encodeU64: encodeU64,
        hexToBuf: hexToBuf,
        addContextToErr: addContextToErr,
        composeErr: composeErr,
        blake2bAddLeafBytesToProofStack: blake2bAddLeafBytesToProofStack,
        blake2bMerkleRoot: blake2bMerkleRoot,
        blake2bProofStackRoot: blake2bProofStackRoot,
        parseJSON: parseJSON,
        progressiveFetch: progressiveFetch,
        computeRegistrySignature: computeRegistrySignature,
        deriveRegistryEntryID: deriveRegistryEntryID,
        entryIDToSkylink: entryIDToSkylink,
        resolverLink: resolverLink,
        taggedRegistryEntryKeys: taggedRegistryEntryKeys,
        verifyRegistrySignature: verifyRegistrySignature,
        verifyRegistryReadResponse: verifyRegistryReadResponse,
        verifyRegistryWriteResponse: verifyRegistryWriteResponse,
        deriveChildSeed: deriveChildSeed,
        deriveMyskyRootKeypair: deriveMyskyRootKeypair,
        generateSeedPhraseDeterministic: generateSeedPhraseDeterministic,
        seedPhraseToSeed: seedPhraseToSeed,
        validSeedPhrase: validSeedPhrase,
        sha512: sha512,
        parseSkylinkBitfield: parseSkylinkBitfield,
        skylinkV1Bitfield: skylinkV1Bitfield,
        validateSkyfileMetadata: validateSkyfileMetadata,
        validateSkyfilePath: validateSkyfilePath,
        validSkylink: validSkylink,
        verifyResolverLinkProofs: verifyResolverLinkProofs,
        jsonStringify: jsonStringify,
        tryStringify: tryStringify
    });

    // @ts-ignore
    window.kernel = kernel;
    // @ts-ignore
    window.skynet = skynet;

})();