@voter-protocol/noir-prover 0.1.2 → 0.1.3

package/dist/assets/main.worker-DTYIOF7w.js

@@ -1,1375 +0,0 @@
-(function () {
-    'use strict';
-
-    /**
-     * @license
-     * Copyright 2019 Google LLC
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    const proxyMarker = Symbol("Comlink.proxy");
-    const createEndpoint = Symbol("Comlink.endpoint");
-    const releaseProxy = Symbol("Comlink.releaseProxy");
-    const finalizer = Symbol("Comlink.finalizer");
-    const throwMarker = Symbol("Comlink.thrown");
-    const isObject = (val) => (typeof val === "object" && val !== null) || typeof val === "function";
-    /**
-     * Internal transfer handle to handle objects marked to proxy.
-     */
-    const proxyTransferHandler = {
-        canHandle: (val) => isObject(val) && val[proxyMarker],
-        serialize(obj) {
-            const { port1, port2 } = new MessageChannel();
-            expose(obj, port1);
-            return [port2, [port2]];
-        },
-        deserialize(port) {
-            port.start();
-            return wrap(port);
-        },
-    };
-    /**
-     * Internal transfer handler to handle thrown exceptions.
-     */
-    const throwTransferHandler = {
-        canHandle: (value) => isObject(value) && throwMarker in value,
-        serialize({ value }) {
-            let serialized;
-            if (value instanceof Error) {
-                serialized = {
-                    isError: true,
-                    value: {
-                        message: value.message,
-                        name: value.name,
-                        stack: value.stack,
-                    },
-                };
-            }
-            else {
-                serialized = { isError: false, value };
-            }
-            return [serialized, []];
-        },
-        deserialize(serialized) {
-            if (serialized.isError) {
-                throw Object.assign(new Error(serialized.value.message), serialized.value);
-            }
-            throw serialized.value;
-        },
-    };
-    /**
-     * Allows customizing the serialization of certain values.
-     */
-    const transferHandlers = new Map([
-        ["proxy", proxyTransferHandler],
-        ["throw", throwTransferHandler],
-    ]);
-    function isAllowedOrigin(allowedOrigins, origin) {
-        for (const allowedOrigin of allowedOrigins) {
-            if (origin === allowedOrigin || allowedOrigin === "*") {
-                return true;
-            }
-            if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
-        ep.addEventListener("message", function callback(ev) {
-            if (!ev || !ev.data) {
-                return;
-            }
-            if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
-                console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
-                return;
-            }
-            const { id, type, path } = Object.assign({ path: [] }, ev.data);
-            const argumentList = (ev.data.argumentList || []).map(fromWireValue);
-            let returnValue;
-            try {
-                const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
-                const rawValue = path.reduce((obj, prop) => obj[prop], obj);
-                switch (type) {
-                    case "GET" /* MessageType.GET */:
-                        {
-                            returnValue = rawValue;
-                        }
-                        break;
-                    case "SET" /* MessageType.SET */:
-                        {
-                            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
-                            returnValue = true;
-                        }
-                        break;
-                    case "APPLY" /* MessageType.APPLY */:
-                        {
-                            returnValue = rawValue.apply(parent, argumentList);
-                        }
-                        break;
-                    case "CONSTRUCT" /* MessageType.CONSTRUCT */:
-                        {
-                            const value = new rawValue(...argumentList);
-                            returnValue = proxy(value);
-                        }
-                        break;
-                    case "ENDPOINT" /* MessageType.ENDPOINT */:
-                        {
-                            const { port1, port2 } = new MessageChannel();
-                            expose(obj, port2);
-                            returnValue = transfer(port1, [port1]);
-                        }
-                        break;
-                    case "RELEASE" /* MessageType.RELEASE */:
-                        {
-                            returnValue = undefined;
-                        }
-                        break;
-                    default:
-                        return;
-                }
-            }
-            catch (value) {
-                returnValue = { value, [throwMarker]: 0 };
-            }
-            Promise.resolve(returnValue)
-                .catch((value) => {
-                return { value, [throwMarker]: 0 };
-            })
-                .then((returnValue) => {
-                const [wireValue, transferables] = toWireValue(returnValue);
-                ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
-                if (type === "RELEASE" /* MessageType.RELEASE */) {
-                    // detach and deactive after sending release response above.
-                    ep.removeEventListener("message", callback);
-                    closeEndPoint(ep);
-                    if (finalizer in obj && typeof obj[finalizer] === "function") {
-                        obj[finalizer]();
-                    }
-                }
-            })
-                .catch((error) => {
-                // Send Serialization Error To Caller
-                const [wireValue, transferables] = toWireValue({
-                    value: new TypeError("Unserializable return value"),
-                    [throwMarker]: 0,
-                });
-                ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
-            });
-        });
-        if (ep.start) {
-            ep.start();
-        }
-    }
-    function isMessagePort(endpoint) {
-        return endpoint.constructor.name === "MessagePort";
-    }
-    function closeEndPoint(endpoint) {
-        if (isMessagePort(endpoint))
-            endpoint.close();
-    }
-    function wrap(ep, target) {
-        const pendingListeners = new Map();
-        ep.addEventListener("message", function handleMessage(ev) {
-            const { data } = ev;
-            if (!data || !data.id) {
-                return;
-            }
-            const resolver = pendingListeners.get(data.id);
-            if (!resolver) {
-                return;
-            }
-            try {
-                resolver(data);
-            }
-            finally {
-                pendingListeners.delete(data.id);
-            }
-        });
-        return createProxy(ep, pendingListeners, [], target);
-    }
-    function throwIfProxyReleased(isReleased) {
-        if (isReleased) {
-            throw new Error("Proxy has been released and is not useable");
-        }
-    }
-    function releaseEndpoint(ep) {
-        return requestResponseMessage(ep, new Map(), {
-            type: "RELEASE" /* MessageType.RELEASE */,
-        }).then(() => {
-            closeEndPoint(ep);
-        });
-    }
-    const proxyCounter = new WeakMap();
-    const proxyFinalizers = "FinalizationRegistry" in globalThis &&
-        new FinalizationRegistry((ep) => {
-            const newCount = (proxyCounter.get(ep) || 0) - 1;
-            proxyCounter.set(ep, newCount);
-            if (newCount === 0) {
-                releaseEndpoint(ep);
-            }
-        });
-    function registerProxy(proxy, ep) {
-        const newCount = (proxyCounter.get(ep) || 0) + 1;
-        proxyCounter.set(ep, newCount);
-        if (proxyFinalizers) {
-            proxyFinalizers.register(proxy, ep, proxy);
-        }
-    }
-    function unregisterProxy(proxy) {
-        if (proxyFinalizers) {
-            proxyFinalizers.unregister(proxy);
-        }
-    }
-    function createProxy(ep, pendingListeners, path = [], target = function () { }) {
-        let isProxyReleased = false;
-        const proxy = new Proxy(target, {
-            get(_target, prop) {
-                throwIfProxyReleased(isProxyReleased);
-                if (prop === releaseProxy) {
-                    return () => {
-                        unregisterProxy(proxy);
-                        releaseEndpoint(ep);
-                        pendingListeners.clear();
-                        isProxyReleased = true;
-                    };
-                }
-                if (prop === "then") {
-                    if (path.length === 0) {
-                        return { then: () => proxy };
-                    }
-                    const r = requestResponseMessage(ep, pendingListeners, {
-                        type: "GET" /* MessageType.GET */,
-                        path: path.map((p) => p.toString()),
-                    }).then(fromWireValue);
-                    return r.then.bind(r);
-                }
-                return createProxy(ep, pendingListeners, [...path, prop]);
-            },
-            set(_target, prop, rawValue) {
-                throwIfProxyReleased(isProxyReleased);
-                // FIXME: ES6 Proxy Handler `set` methods are supposed to return a
-                // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
-                const [value, transferables] = toWireValue(rawValue);
-                return requestResponseMessage(ep, pendingListeners, {
-                    type: "SET" /* MessageType.SET */,
-                    path: [...path, prop].map((p) => p.toString()),
-                    value,
-                }, transferables).then(fromWireValue);
-            },
-            apply(_target, _thisArg, rawArgumentList) {
-                throwIfProxyReleased(isProxyReleased);
-                const last = path[path.length - 1];
-                if (last === createEndpoint) {
-                    return requestResponseMessage(ep, pendingListeners, {
-                        type: "ENDPOINT" /* MessageType.ENDPOINT */,
-                    }).then(fromWireValue);
-                }
-                // We just pretend that `bind()` didn’t happen.
-                if (last === "bind") {
-                    return createProxy(ep, pendingListeners, path.slice(0, -1));
-                }
-                const [argumentList, transferables] = processArguments(rawArgumentList);
-                return requestResponseMessage(ep, pendingListeners, {
-                    type: "APPLY" /* MessageType.APPLY */,
-                    path: path.map((p) => p.toString()),
-                    argumentList,
-                }, transferables).then(fromWireValue);
-            },
-            construct(_target, rawArgumentList) {
-                throwIfProxyReleased(isProxyReleased);
-                const [argumentList, transferables] = processArguments(rawArgumentList);
-                return requestResponseMessage(ep, pendingListeners, {
-                    type: "CONSTRUCT" /* MessageType.CONSTRUCT */,
-                    path: path.map((p) => p.toString()),
-                    argumentList,
-                }, transferables).then(fromWireValue);
-            },
-        });
-        registerProxy(proxy, ep);
-        return proxy;
-    }
-    function myFlat(arr) {
-        return Array.prototype.concat.apply([], arr);
-    }
-    function processArguments(argumentList) {
-        const processed = argumentList.map(toWireValue);
-        return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
-    }
-    const transferCache = new WeakMap();
-    function transfer(obj, transfers) {
-        transferCache.set(obj, transfers);
-        return obj;
-    }
-    function proxy(obj) {
-        return Object.assign(obj, { [proxyMarker]: true });
-    }
-    function toWireValue(value) {
-        for (const [name, handler] of transferHandlers) {
-            if (handler.canHandle(value)) {
-                const [serializedValue, transferables] = handler.serialize(value);
-                return [
-                    {
-                        type: "HANDLER" /* WireValueType.HANDLER */,
-                        name,
-                        value: serializedValue,
-                    },
-                    transferables,
-                ];
-            }
-        }
-        return [
-            {
-                type: "RAW" /* WireValueType.RAW */,
-                value,
-            },
-            transferCache.get(value) || [],
-        ];
-    }
-    function fromWireValue(value) {
-        switch (value.type) {
-            case "HANDLER" /* WireValueType.HANDLER */:
-                return transferHandlers.get(value.name).deserialize(value.value);
-            case "RAW" /* WireValueType.RAW */:
-                return value.value;
-        }
-    }
-    function requestResponseMessage(ep, pendingListeners, msg, transfers) {
-        return new Promise((resolve) => {
-            const id = generateUUID();
-            pendingListeners.set(id, resolve);
-            if (ep.start) {
-                ep.start();
-            }
-            ep.postMessage(Object.assign({ id }, msg), transfers);
-        });
-    }
-    function generateUUID() {
-        return new Array(4)
-            .fill(0)
-            .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
-            .join("-");
-    }
-
-    function getSharedMemoryAvailable() {
-        const globalScope = typeof window !== 'undefined' ? window : globalThis;
-        return typeof SharedArrayBuffer !== 'undefined' && globalScope.crossOriginIsolated;
-    }
-    function getRemoteBarretenbergWasm(worker) {
-        return wrap(worker);
-    }
-    function getNumCpu() {
-        return navigator.hardwareConcurrency;
-    }
-    // Solution to async initialization of workers, taken from
-    // https://github.com/GoogleChromeLabs/comlink/issues/635#issuecomment-1598913044
-    /** The message expected by the `readinessListener`. */
-    const Ready = { ready: true };
-    /** Listen for the readiness message from the Worker and call the `callback` once. */
-    function readinessListener(worker, callback) {
-        worker.addEventListener('message', function ready(event) {
-            if (!!event.data && event.data.ready === true) {
-                worker.removeEventListener('message', ready);
-                callback();
-            }
-        });
-    }
-
-    var browser = {exports: {}};
-
-    function tryStringify (o) {
-      try { return JSON.stringify(o) } catch(e) { return '"[Circular]"' }
-    }
-
-    var quickFormatUnescaped = format$1;
-
-    function format$1(f, args, opts) {
-      var ss = (opts && opts.stringify) || tryStringify;
-      var offset = 1;
-      if (typeof f === 'object' && f !== null) {
-        var len = args.length + offset;
-        if (len === 1) return f
-        var objects = new Array(len);
-        objects[0] = ss(f);
-        for (var index = 1; index < len; index++) {
-          objects[index] = ss(args[index]);
-        }
-        return objects.join(' ')
-      }
-      if (typeof f !== 'string') {
-        return f
-      }
-      var argLen = args.length;
-      if (argLen === 0) return f
-      var str = '';
-      var a = 1 - offset;
-      var lastPos = -1;
-      var flen = (f && f.length) || 0;
-      for (var i = 0; i < flen;) {
-        if (f.charCodeAt(i) === 37 && i + 1 < flen) {
-          lastPos = lastPos > -1 ? lastPos : 0;
-          switch (f.charCodeAt(i + 1)) {
-            case 100: // 'd'
-            case 102: // 'f'
-              if (a >= argLen)
-                break
-              if (args[a] == null)  break
-              if (lastPos < i)
-                str += f.slice(lastPos, i);
-              str += Number(args[a]);
-              lastPos = i + 2;
-              i++;
-              break
-            case 105: // 'i'
-              if (a >= argLen)
-                break
-              if (args[a] == null)  break
-              if (lastPos < i)
-                str += f.slice(lastPos, i);
-              str += Math.floor(Number(args[a]));
-              lastPos = i + 2;
-              i++;
-              break
-            case 79: // 'O'
-            case 111: // 'o'
-            case 106: // 'j'
-              if (a >= argLen)
-                break
-              if (args[a] === undefined) break
-              if (lastPos < i)
-                str += f.slice(lastPos, i);
-              var type = typeof args[a];
-              if (type === 'string') {
-                str += '\'' + args[a] + '\'';
-                lastPos = i + 2;
-                i++;
-                break
-              }
-              if (type === 'function') {
-                str += args[a].name || '<anonymous>';
-                lastPos = i + 2;
-                i++;
-                break
-              }
-              str += ss(args[a]);
-              lastPos = i + 2;
-              i++;
-              break
-            case 115: // 's'
-              if (a >= argLen)
-                break
-              if (lastPos < i)
-                str += f.slice(lastPos, i);
-              str += String(args[a]);
-              lastPos = i + 2;
-              i++;
-              break
-            case 37: // '%'
-              if (lastPos < i)
-                str += f.slice(lastPos, i);
-              str += '%';
-              lastPos = i + 2;
-              i++;
-              a--;
-              break
-          }
-          ++a;
-        }
-        ++i;
-      }
-      if (lastPos === -1)
-        return f
-      else if (lastPos < flen) {
-        str += f.slice(lastPos);
-      }
-
-      return str
-    }
-
-    const format = quickFormatUnescaped;
-
-    browser.exports = pino;
-
-    const _console = pfGlobalThisOrFallback().console || {};
-    const stdSerializers = {
-      mapHttpRequest: mock,
-      mapHttpResponse: mock,
-      wrapRequestSerializer: passthrough,
-      wrapResponseSerializer: passthrough,
-      wrapErrorSerializer: passthrough,
-      req: mock,
-      res: mock,
-      err: asErrValue,
-      errWithCause: asErrValue
-    };
-    function levelToValue (level, logger) {
-      return level === 'silent'
-        ? Infinity
-        : logger.levels.values[level]
-    }
-    const baseLogFunctionSymbol = Symbol('pino.logFuncs');
-    const hierarchySymbol = Symbol('pino.hierarchy');
-
-    const logFallbackMap = {
-      error: 'log',
-      fatal: 'error',
-      warn: 'error',
-      info: 'log',
-      debug: 'log',
-      trace: 'log'
-    };
-
-    function appendChildLogger (parentLogger, childLogger) {
-      const newEntry = {
-        logger: childLogger,
-        parent: parentLogger[hierarchySymbol]
-      };
-      childLogger[hierarchySymbol] = newEntry;
-    }
-
-    function setupBaseLogFunctions (logger, levels, proto) {
-      const logFunctions = {};
-      levels.forEach(level => {
-        logFunctions[level] = proto[level] ? proto[level] : (_console[level] || _console[logFallbackMap[level] || 'log'] || noop);
-      });
-      logger[baseLogFunctionSymbol] = logFunctions;
-    }
-
-    function shouldSerialize (serialize, serializers) {
-      if (Array.isArray(serialize)) {
-        const hasToFilter = serialize.filter(function (k) {
-          return k !== '!stdSerializers.err'
-        });
-        return hasToFilter
-      } else if (serialize === true) {
-        return Object.keys(serializers)
-      }
-
-      return false
-    }
-
-    function pino (opts) {
-      opts = opts || {};
-      opts.browser = opts.browser || {};
-
-      const transmit = opts.browser.transmit;
-      if (transmit && typeof transmit.send !== 'function') { throw Error('pino: transmit option must have a send function') }
-
-      const proto = opts.browser.write || _console;
-      if (opts.browser.write) opts.browser.asObject = true;
-      const serializers = opts.serializers || {};
-      const serialize = shouldSerialize(opts.browser.serialize, serializers);
-      let stdErrSerialize = opts.browser.serialize;
-
-      if (
-        Array.isArray(opts.browser.serialize) &&
-        opts.browser.serialize.indexOf('!stdSerializers.err') > -1
-      ) stdErrSerialize = false;
-
-      const customLevels = Object.keys(opts.customLevels || {});
-      const levels = ['error', 'fatal', 'warn', 'info', 'debug', 'trace'].concat(customLevels);
-
-      if (typeof proto === 'function') {
-        levels.forEach(function (level) {
-          proto[level] = proto;
-        });
-      }
-      if (opts.enabled === false || opts.browser.disabled) opts.level = 'silent';
-      const level = opts.level || 'info';
-      const logger = Object.create(proto);
-      if (!logger.log) logger.log = noop;
-
-      setupBaseLogFunctions(logger, levels, proto);
-      // setup root hierarchy entry
-      appendChildLogger({}, logger);
-
-      Object.defineProperty(logger, 'levelVal', {
-        get: getLevelVal
-      });
-      Object.defineProperty(logger, 'level', {
-        get: getLevel,
-        set: setLevel
-      });
-
-      const setOpts = {
-        transmit,
-        serialize,
-        asObject: opts.browser.asObject,
-        asObjectBindingsOnly: opts.browser.asObjectBindingsOnly,
-        formatters: opts.browser.formatters,
-        levels,
-        timestamp: getTimeFunction(opts),
-        messageKey: opts.messageKey || 'msg',
-        onChild: opts.onChild || noop
-      };
-      logger.levels = getLevels(opts);
-      logger.level = level;
-
-      logger.isLevelEnabled = function (level) {
-        if (!this.levels.values[level]) {
-          return false
-        }
-
-        return this.levels.values[level] >= this.levels.values[this.level]
-      };
-      logger.setMaxListeners = logger.getMaxListeners =
-      logger.emit = logger.addListener = logger.on =
-      logger.prependListener = logger.once =
-      logger.prependOnceListener = logger.removeListener =
-      logger.removeAllListeners = logger.listeners =
-      logger.listenerCount = logger.eventNames =
-      logger.write = logger.flush = noop;
-      logger.serializers = serializers;
-      logger._serialize = serialize;
-      logger._stdErrSerialize = stdErrSerialize;
-      logger.child = function (...args) { return child.call(this, setOpts, ...args) };
-
-      if (transmit) logger._logEvent = createLogEventShape();
-
-      function getLevelVal () {
-        return levelToValue(this.level, this)
-      }
-
-      function getLevel () {
-        return this._level
-      }
-      function setLevel (level) {
-        if (level !== 'silent' && !this.levels.values[level]) {
-          throw Error('unknown level ' + level)
-        }
-        this._level = level;
-
-        set(this, setOpts, logger, 'error'); // <-- must stay first
-        set(this, setOpts, logger, 'fatal');
-        set(this, setOpts, logger, 'warn');
-        set(this, setOpts, logger, 'info');
-        set(this, setOpts, logger, 'debug');
-        set(this, setOpts, logger, 'trace');
-
-        customLevels.forEach((level) => {
-          set(this, setOpts, logger, level);
-        });
-      }
-
-      function child (setOpts, bindings, childOptions) {
-        if (!bindings) {
-          throw new Error('missing bindings for child Pino')
-        }
-        childOptions = childOptions || {};
-        if (serialize && bindings.serializers) {
-          childOptions.serializers = bindings.serializers;
-        }
-        const childOptionsSerializers = childOptions.serializers;
-        if (serialize && childOptionsSerializers) {
-          var childSerializers = Object.assign({}, serializers, childOptionsSerializers);
-          var childSerialize = opts.browser.serialize === true
-            ? Object.keys(childSerializers)
-            : serialize;
-          delete bindings.serializers;
-          applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize);
-        }
-        function Child (parent) {
-          this._childLevel = (parent._childLevel | 0) + 1;
-
-          // make sure bindings are available in the `set` function
-          this.bindings = bindings;
-
-          if (childSerializers) {
-            this.serializers = childSerializers;
-            this._serialize = childSerialize;
-          }
-          if (transmit) {
-            this._logEvent = createLogEventShape(
-              [].concat(parent._logEvent.bindings, bindings)
-            );
-          }
-        }
-        Child.prototype = this;
-        const newLogger = new Child(this);
-
-        // must happen before the level is assigned
-        appendChildLogger(this, newLogger);
-        newLogger.child = function (...args) { return child.call(this, setOpts, ...args) };
-        // required to actually initialize the logger functions for any given child
-        newLogger.level = childOptions.level || this.level; // allow level to be set by childOptions
-        setOpts.onChild(newLogger);
-
-        return newLogger
-      }
-      return logger
-    }
-
-    function getLevels (opts) {
-      const customLevels = opts.customLevels || {};
-
-      const values = Object.assign({}, pino.levels.values, customLevels);
-      const labels = Object.assign({}, pino.levels.labels, invertObject(customLevels));
-
-      return {
-        values,
-        labels
-      }
-    }
-
-    function invertObject (obj) {
-      const inverted = {};
-      Object.keys(obj).forEach(function (key) {
-        inverted[obj[key]] = key;
-      });
-      return inverted
-    }
-
-    pino.levels = {
-      values: {
-        fatal: 60,
-        error: 50,
-        warn: 40,
-        info: 30,
-        debug: 20,
-        trace: 10
-      },
-      labels: {
-        10: 'trace',
-        20: 'debug',
-        30: 'info',
-        40: 'warn',
-        50: 'error',
-        60: 'fatal'
-      }
-    };
-
-    pino.stdSerializers = stdSerializers;
-    pino.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime });
-
-    function getBindingChain (logger) {
-      const bindings = [];
-      if (logger.bindings) {
-        bindings.push(logger.bindings);
-      }
-
-      // traverse up the tree to get all bindings
-      let hierarchy = logger[hierarchySymbol];
-      while (hierarchy.parent) {
-        hierarchy = hierarchy.parent;
-        if (hierarchy.logger.bindings) {
-          bindings.push(hierarchy.logger.bindings);
-        }
-      }
-
-      return bindings.reverse()
-    }
-
-    function set (self, opts, rootLogger, level) {
-      // override the current log functions with either `noop` or the base log function
-      Object.defineProperty(self, level, {
-        value: (levelToValue(self.level, rootLogger) > levelToValue(level, rootLogger)
-          ? noop
-          : rootLogger[baseLogFunctionSymbol][level]),
-        writable: true,
-        enumerable: true,
-        configurable: true
-      });
-
-      if (self[level] === noop) {
-        if (!opts.transmit) return
-
-        const transmitLevel = opts.transmit.level || self.level;
-        const transmitValue = levelToValue(transmitLevel, rootLogger);
-        const methodValue = levelToValue(level, rootLogger);
-        if (methodValue < transmitValue) return
-      }
-
-      // make sure the log format is correct
-      self[level] = createWrap(self, opts, rootLogger, level);
-
-      // prepend bindings if it is not the root logger
-      const bindings = getBindingChain(self);
-      if (bindings.length === 0) {
-        // early exit in case for rootLogger
-        return
-      }
-      self[level] = prependBindingsInArguments(bindings, self[level]);
-    }
-
-    function prependBindingsInArguments (bindings, logFunc) {
-      return function () {
-        return logFunc.apply(this, [...bindings, ...arguments])
-      }
-    }
-
-    function createWrap (self, opts, rootLogger, level) {
-      return (function (write) {
-        return function LOG () {
-          const ts = opts.timestamp();
-          const args = new Array(arguments.length);
-          const proto = (Object.getPrototypeOf && Object.getPrototypeOf(this) === _console) ? _console : this;
-          for (var i = 0; i < args.length; i++) args[i] = arguments[i];
-
-          var argsIsSerialized = false;
-          if (opts.serialize) {
-            applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize);
-            argsIsSerialized = true;
-          }
-          if (opts.asObject || opts.formatters) {
-            write.call(proto, ...asObject(this, level, args, ts, opts));
-          } else write.apply(proto, args);
-
-          if (opts.transmit) {
-            const transmitLevel = opts.transmit.level || self._level;
-            const transmitValue = levelToValue(transmitLevel, rootLogger);
-            const methodValue = levelToValue(level, rootLogger);
-            if (methodValue < transmitValue) return
-            transmit(this, {
-              ts,
-              methodLevel: level,
-              methodValue,
-              transmitValue: rootLogger.levels.values[opts.transmit.level || self._level],
-              send: opts.transmit.send,
-              val: levelToValue(self._level, rootLogger)
-            }, args, argsIsSerialized);
-          }
-        }
-      })(self[baseLogFunctionSymbol][level])
-    }
-
-    function asObject (logger, level, args, ts, opts) {
-      const {
-        level: levelFormatter,
-        log: logObjectFormatter = (obj) => obj
-      } = opts.formatters || {};
-      const argsCloned = args.slice();
-      let msg = argsCloned[0];
-      const logObject = {};
-
-      let lvl = (logger._childLevel | 0) + 1;
-      if (lvl < 1) lvl = 1;
-
-      if (ts) {
-        logObject.time = ts;
-      }
-
-      if (levelFormatter) {
-        const formattedLevel = levelFormatter(level, logger.levels.values[level]);
-        Object.assign(logObject, formattedLevel);
-      } else {
-        logObject.level = logger.levels.values[level];
-      }
-
-      if (opts.asObjectBindingsOnly) {
-        if (msg !== null && typeof msg === 'object') {
-          while (lvl-- && typeof argsCloned[0] === 'object') {
-            Object.assign(logObject, argsCloned.shift());
-          }
-        }
-
-        const formattedLogObject = logObjectFormatter(logObject);
-        return [formattedLogObject, ...argsCloned]
-      } else {
-        // deliberate, catching objects, arrays
-        if (msg !== null && typeof msg === 'object') {
-          while (lvl-- && typeof argsCloned[0] === 'object') {
-            Object.assign(logObject, argsCloned.shift());
-          }
-          msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : undefined;
-        } else if (typeof msg === 'string') msg = format(argsCloned.shift(), argsCloned);
-        if (msg !== undefined) logObject[opts.messageKey] = msg;
-
-        const formattedLogObject = logObjectFormatter(logObject);
-        return [formattedLogObject]
-      }
-    }
-
-    function applySerializers (args, serialize, serializers, stdErrSerialize) {
-      for (const i in args) {
-        if (stdErrSerialize && args[i] instanceof Error) {
-          args[i] = pino.stdSerializers.err(args[i]);
-        } else if (typeof args[i] === 'object' && !Array.isArray(args[i]) && serialize) {
-          for (const k in args[i]) {
-            if (serialize.indexOf(k) > -1 && k in serializers) {
-              args[i][k] = serializers[k](args[i][k]);
-            }
-          }
-        }
-      }
-    }
-
-    function transmit (logger, opts, args, argsIsSerialized = false) {
-      const send = opts.send;
-      const ts = opts.ts;
-      const methodLevel = opts.methodLevel;
-      const methodValue = opts.methodValue;
-      const val = opts.val;
-      const bindings = logger._logEvent.bindings;
-
-      if (!argsIsSerialized) {
-        applySerializers(
-          args,
-          logger._serialize || Object.keys(logger.serializers),
-          logger.serializers,
-          logger._stdErrSerialize === undefined ? true : logger._stdErrSerialize
-        );
-      }
-
-      logger._logEvent.ts = ts;
-      logger._logEvent.messages = args.filter(function (arg) {
-        // bindings can only be objects, so reference equality check via indexOf is fine
-        return bindings.indexOf(arg) === -1
-      });
-
-      logger._logEvent.level.label = methodLevel;
-      logger._logEvent.level.value = methodValue;
-
-      send(methodLevel, logger._logEvent, val);
-
-      logger._logEvent = createLogEventShape(bindings);
-    }
-
-    function createLogEventShape (bindings) {
-      return {
-        ts: 0,
-        messages: [],
-        bindings: bindings || [],
-        level: { label: '', value: 0 }
-      }
-    }
-
-    function asErrValue (err) {
-      const obj = {
-        type: err.constructor.name,
-        msg: err.message,
-        stack: err.stack
-      };
-      for (const key in err) {
-        if (obj[key] === undefined) {
-          obj[key] = err[key];
-        }
-      }
-      return obj
-    }
-
-    function getTimeFunction (opts) {
-      if (typeof opts.timestamp === 'function') {
-        return opts.timestamp
-      }
-      if (opts.timestamp === false) {
-        return nullTime
-      }
-      return epochTime
-    }
-
-    function mock () { return {} }
-    function passthrough (a) { return a }
-    function noop () {}
-
-    function nullTime () { return false }
-    function epochTime () { return Date.now() }
-    function unixTime () { return Math.round(Date.now() / 1000.0) }
-    function isoTime () { return new Date(Date.now()).toISOString() } // using Date.now() for testability
-
-    /* eslint-disable */
-    /* istanbul ignore next */
-    function pfGlobalThisOrFallback () {
-      function defd (o) { return typeof o !== 'undefined' && o }
-      try {
-        if (typeof globalThis !== 'undefined') return globalThis
-        Object.defineProperty(Object.prototype, 'globalThis', {
-          get: function () {
-            delete Object.prototype.globalThis;
-            return (this.globalThis = this)
-          },
-          configurable: true
-        });
-        return globalThis
-      } catch (e) {
-        return defd(self) || defd(window) || defd(this) || {}
-      }
-    }
-    /* eslint-enable */
-
-    browser.exports.default = pino;
-    var pino_1 = browser.exports.pino = pino;
-
-    const defaultOptions = {
-        name: 'bb.js',
-        useOnlyCustomLevels: false,
-        customLevels: { verbose: 25 },
-        browser: { asObject: false },
-    };
-    // Options must be exposed so they can be provided to threads upon creation
-    // This way we ensure all loggers are spawned with the same options
-    let logOptions;
-    let logger;
-    function initLogger({ level = 'info' } = { level: 'info', useStdErr: false }) {
-        if (logger) {
-            return logger;
-        }
-        logOptions = { level, useStdErr: false };
-        logger = pino_1({ ...defaultOptions, level });
-    }
-    function createDebugLogger(name) {
-        initLogger();
-        const sublogger = logger.child({
-            name,
-        });
-        return (msg) => {
-            sublogger.debug(msg);
-        };
-    }
-
-    async function createThreadWorker() {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        const worker = new Worker(new URL(/* @vite-ignore */ "/assets/thread.worker-I9-Z0yRJ.js", self.location.href), { type: 'module' });
-        worker.postMessage({ log: logOptions });
-        await new Promise(resolve => readinessListener(worker, resolve));
-        return worker;
-    }
-
-    const randomBytes = (len) => {
-        const getWebCrypto = () => {
-            if (typeof window !== 'undefined' && window.crypto)
-                return window.crypto;
-            if (typeof globalThis !== 'undefined' && globalThis.crypto)
-                return globalThis.crypto;
-            return undefined;
-        };
-        const crypto = getWebCrypto();
-        if (!crypto) {
-            throw new Error('randomBytes UnsupportedEnvironment');
-        }
-        const buf = new Uint8Array(len);
-        // limit of Crypto.getRandomValues()
-        // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
-        const MAX_BYTES = 65536;
-        if (len > MAX_BYTES) {
-            // this is the max bytes crypto.getRandomValues
-            // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
-            for (let generated = 0; generated < len; generated += MAX_BYTES) {
-                // buffer.slice automatically checks if the end is past the end of
-                // the buffer so we don't have to here
-                crypto.getRandomValues(buf.subarray(generated, generated + MAX_BYTES));
-            }
-        }
-        else {
-            crypto.getRandomValues(buf);
-        }
-        return buf;
-    };
-
-    /**
-     * Base implementation of BarretenbergWasm.
-     * Contains code that is common to the "main thread" implementation and the "child thread" implementation.
-     */
-    class BarretenbergWasmBase {
-        constructor() {
-            this.memStore = {};
-            this.logger = createDebugLogger('bb_wasm_base');
-        }
-        getImportObj(memory) {
-            /* eslint-disable camelcase */
-            const importObj = {
-                // We need to implement a part of the wasi api:
-                // https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md
-                // We literally only need to support random_get, everything else is noop implementated in barretenberg.wasm.
-                wasi_snapshot_preview1: {
-                    random_get: (out, length) => {
-                        out = out >>> 0;
-                        const randomData = randomBytes(length);
-                        const mem = this.getMemory();
-                        mem.set(randomData, out);
-                    },
-                    clock_time_get: (a1, a2, out) => {
-                        out = out >>> 0;
-                        const ts = BigInt(new Date().getTime()) * 1000000n;
-                        const view = new DataView(this.getMemory().buffer);
-                        view.setBigUint64(out, ts, true);
-                    },
-                    proc_exit: () => {
-                        this.logger('PANIC: proc_exit was called.');
-                        throw new Error();
-                    },
-                },
-                // These are functions implementations for imports we've defined are needed.
-                // The native C++ build defines these in a module called "env". We must implement TypeScript versions here.
-                env: {
-                    /**
-                     * The 'info' call we use for logging in C++, calls this under the hood.
-                     * The native code will just print to std:err (to avoid std::cout which is used for IPC).
-                     * Here we just emit the log line for the client to decide what to do with.
-                     */
-                    logstr: (addr) => {
-                        const str = this.stringFromAddress(addr);
-                        const m = this.getMemory();
-                        const str2 = `${str} (mem: ${(m.length / (1024 * 1024)).toFixed(2)}MiB)`;
-                        this.logger(str2);
-                    },
-                    throw_or_abort_impl: (addr) => {
-                        const str = this.stringFromAddress(addr);
-                        throw new Error(str);
-                    },
-                    get_data: (keyAddr, outBufAddr) => {
-                        const key = this.stringFromAddress(keyAddr);
-                        outBufAddr = outBufAddr >>> 0;
-                        const data = this.memStore[key];
-                        if (!data) {
-                            this.logger(`get_data miss ${key}`);
-                            return;
-                        }
-                        // this.logger(`get_data hit ${key} size: ${data.length} dest: ${outBufAddr}`);
-                        // this.logger(Buffer.from(data.slice(0, 64)).toString('hex'));
-                        this.writeMemory(outBufAddr, data);
-                    },
-                    set_data: (keyAddr, dataAddr, dataLength) => {
-                        const key = this.stringFromAddress(keyAddr);
-                        dataAddr = dataAddr >>> 0;
-                        this.memStore[key] = this.getMemorySlice(dataAddr, dataAddr + dataLength);
-                        // this.logger(`set_data: ${key} length: ${dataLength}`);
-                    },
-                    memory,
-                },
-            };
-            /* eslint-enable camelcase */
-            return importObj;
-        }
-        exports() {
-            return this.instance.exports;
-        }
-        /**
-         * When returning values from the WASM, use >>> operator to convert signed representation to unsigned representation.
-         */
-        call(name, ...args) {
-            if (!this.exports()[name]) {
-                throw new Error(`WASM function ${name} not found.`);
-            }
-            try {
-                return this.exports()[name](...args) >>> 0;
-            }
-            catch (err) {
-                const message = `WASM function ${name} aborted, error: ${err}`;
-                this.logger(message);
-                this.logger(err.stack);
-                throw err;
-            }
-        }
-        memSize() {
-            return this.getMemory().length;
-        }
-        /**
-         * Returns a copy of the data, not a view.
-         */
-        getMemorySlice(start, end) {
-            return this.getMemory().subarray(start, end).slice();
-        }
-        writeMemory(offset, arr) {
-            const mem = this.getMemory();
-            mem.set(arr, offset);
-        }
-        // PRIVATE METHODS
-        getMemory() {
-            return new Uint8Array(this.memory.buffer);
-        }
-        stringFromAddress(addr) {
-            addr = addr >>> 0;
-            const m = this.getMemory();
-            let i = addr;
-            for (; m[i] !== 0; ++i)
-                ;
-            const textDecoder = new TextDecoder('ascii');
-            return textDecoder.decode(m.slice(addr, i));
-        }
-    }
-
-    /**
-     * Keeps track of heap allocations so they can be easily freed.
-     * The WASM memory layout has 1024 bytes of unused "scratch" space at the start (addresses 0-1023).
-     * We can leverage this for IO rather than making expensive bb_malloc bb_free calls.
-     * Heap allocations will be created for input/output args that don't fit into the scratch space.
-     * Input and output args can use the same scratch space as it's assume all input reads will be performed before any
-     * output writes are performed.
-     */
-    class HeapAllocator {
-        constructor(wasm) {
-            this.wasm = wasm;
-            this.allocs = [];
-            this.inScratchRemaining = 1024;
-            this.outScratchRemaining = 1024;
-        }
-        getInputs(buffers) {
-            return buffers.map(bufOrNum => {
-                if (typeof bufOrNum === 'object') {
-                    if (bufOrNum.length <= this.inScratchRemaining) {
-                        const ptr = (this.inScratchRemaining -= bufOrNum.length);
-                        this.wasm.writeMemory(ptr, bufOrNum);
-                        return ptr;
-                    }
-                    else {
-                        const ptr = this.wasm.call('bbmalloc', bufOrNum.length);
-                        this.wasm.writeMemory(ptr, bufOrNum);
-                        this.allocs.push(ptr);
-                        return ptr;
-                    }
-                }
-                else {
-                    return bufOrNum;
-                }
-            });
-        }
-        getOutputPtrs(outLens) {
-            return outLens.map(len => {
-                // If the obj is variable length, we need a 4 byte ptr to write the serialized data address to.
-                // WARNING: 4 only works with WASM as it has 32 bit memory.
-                const size = len || 4;
-                if (size <= this.outScratchRemaining) {
-                    return (this.outScratchRemaining -= size);
-                }
-                else {
-                    const ptr = this.wasm.call('bbmalloc', size);
-                    this.allocs.push(ptr);
-                    return ptr;
-                }
-            });
-        }
-        addOutputPtr(ptr) {
-            if (ptr >= 1024) {
-                this.allocs.push(ptr);
-            }
-        }
-        freeAll() {
-            for (const ptr of this.allocs) {
-                this.wasm.call('bbfree', ptr);
-            }
-        }
-    }
-
-    /**
-     * This is the "main thread" implementation of BarretenbergWasm.
-     * It spawns a bunch of "child thread" implementations.
-     * In a browser context, this still runs on a worker, as it will block waiting on child threads.
-     */
-    class BarretenbergWasmMain extends BarretenbergWasmBase {
-        constructor() {
-            super(...arguments);
-            this.workers = [];
-            this.remoteWasms = [];
-            this.nextWorker = 0;
-            this.nextThreadId = 1;
-        }
-        getNumThreads() {
-            return this.workers.length + 1;
-        }
-        /**
-         * Init as main thread. Spawn child threads.
-         */
-        async init(module, threads = Math.min(getNumCpu(), BarretenbergWasmMain.MAX_THREADS), logger = createDebugLogger('bb_wasm'), initial = 32, maximum = this.getDefaultMaximumMemoryPages()) {
-            this.logger = logger;
-            const initialMb = (initial * 2 ** 16) / (1024 * 1024);
-            const maxMb = (maximum * 2 ** 16) / (1024 * 1024);
-            const shared = getSharedMemoryAvailable();
-            this.logger(`Initializing bb wasm: initial memory ${initial} pages ${initialMb}MiB; ` +
-                `max memory: ${maximum} pages, ${maxMb}MiB; ` +
-                `threads: ${threads}; shared memory: ${shared}`);
-            this.memory = new WebAssembly.Memory({ initial, maximum, shared });
-            const instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
-            this.instance = instance;
-            // Init all global/static data.
-            this.call('_initialize');
-            // Create worker threads. Create 1 less than requested, as main thread counts as a thread.
-            if (threads > 1) {
-                this.logger(`Creating ${threads} worker threads`);
-                this.workers = await Promise.all(Array.from({ length: threads - 1 }).map(createThreadWorker));
-                this.remoteWasms = await Promise.all(this.workers.map((getRemoteBarretenbergWasm)));
-                await Promise.all(this.remoteWasms.map(w => w.initThread(module, this.memory)));
-            }
-        }
-        getDefaultMaximumMemoryPages() {
-            // iOS browser is very aggressive with memory. Check if running in browser and on iOS
-            // We at any rate expect the mobile iOS browser to kill us >=1GB, so we don't set a maximum higher than that.
-            if (typeof window !== 'undefined' && /iPad|iPhone/.test(navigator.userAgent)) {
-                return 2 ** 14;
-            }
-            return 2 ** 16;
-        }
-        /**
-         * Called on main thread. Signals child threads to gracefully exit.
-         */
-        async destroy() {
-            await Promise.all(this.workers.map(w => w.terminate()));
-        }
-        getImportObj(memory) {
-            const baseImports = super.getImportObj(memory);
-            /* eslint-disable camelcase */
-            return {
-                ...baseImports,
-                wasi: {
-                    'thread-spawn': (arg) => {
-                        arg = arg >>> 0;
-                        const id = this.nextThreadId++;
-                        const worker = this.nextWorker++ % this.remoteWasms.length;
-                        // this.logger(`spawning thread ${id} on worker ${worker} with arg ${arg >>> 0}`);
-                        this.remoteWasms[worker].call('wasi_thread_start', id, arg).catch(this.logger);
-                        // this.remoteWasms[worker].postMessage({ msg: 'thread', data: { id, arg } });
-                        return id;
-                    },
-                },
-                env: {
-                    ...baseImports.env,
-                    env_hardware_concurrency: () => {
-                        // If there are no workers (we're already running as a worker, or the main thread requested no workers)
-                        // then we return 1, which should cause any algos using threading to just not create a thread.
-                        return this.remoteWasms.length + 1;
-                    },
-                },
-            };
-            /* eslint-enable camelcase */
-        }
-        callWasmExport(funcName, inArgs, outLens) {
-            const alloc = new HeapAllocator(this);
-            const inPtrs = alloc.getInputs(inArgs);
-            const outPtrs = alloc.getOutputPtrs(outLens);
-            this.call(funcName, ...inPtrs, ...outPtrs);
-            const outArgs = this.getOutputArgs(outLens, outPtrs, alloc);
-            alloc.freeAll();
-            return outArgs;
-        }
-        getOutputArgs(outLens, outPtrs, alloc) {
-            return outLens.map((len, i) => {
-                if (len) {
-                    return this.getMemorySlice(outPtrs[i], outPtrs[i] + len);
-                }
-                const slice = this.getMemorySlice(outPtrs[i], outPtrs[i] + 4);
-                const ptr = new DataView(slice.buffer, slice.byteOffset, slice.byteLength).getUint32(0, true);
-                // Add our heap buffer to the dealloc list.
-                alloc.addOutputPtr(ptr);
-                // The length will be found in the first 4 bytes of the buffer, big endian. See to_heap_buffer.
-                const lslice = this.getMemorySlice(ptr, ptr + 4);
-                const length = new DataView(lslice.buffer, lslice.byteOffset, lslice.byteLength).getUint32(0, false);
-                return this.getMemorySlice(ptr + 4, ptr + 4 + length);
-            });
-        }
-        cbindCall(cbind, inputBuffer) {
-            const outputSizePtr = this.call('bbmalloc', 4);
-            const outputMsgpackPtr = this.call('bbmalloc', 4);
-            const inputPtr = this.call('bbmalloc', inputBuffer.length);
-            this.writeMemory(inputPtr, inputBuffer);
-            this.call(cbind, inputPtr, inputBuffer.length, outputMsgpackPtr, outputSizePtr);
-            const readPtr32 = (ptr32) => {
-                const dataView = new DataView(this.getMemorySlice(ptr32, ptr32 + 4).buffer);
-                return dataView.getUint32(0, true);
-            };
-            const encodedResult = this.getMemorySlice(readPtr32(outputMsgpackPtr), readPtr32(outputMsgpackPtr) + readPtr32(outputSizePtr));
-            this.call('bbfree', inputPtr);
-            this.call('bbfree', outputSizePtr);
-            this.call('bbfree', outputMsgpackPtr);
-            return encodedResult;
-        }
-    }
-    BarretenbergWasmMain.MAX_THREADS = 32;
-
-    addEventListener('message', e => {
-        if (e.data.log) {
-            initLogger(e.data.log);
-        }
-    });
-    expose(new BarretenbergWasmMain());
-    postMessage(Ready);
-
-})();