@voter-protocol/noir-prover 0.1.2 → 0.1.3

package/dist/assets/thread.worker-I9-Z0yRJ.js

@@ -1,1201 +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 threadLogger() {
-        return console.log;
-    }
-    function killSelf() {
-        self.close();
-    }
-    // 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 };
-
-    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 },
-    };
-    let logger;
-    function initLogger({ level = 'info' } = { level: 'info', useStdErr: false }) {
-        if (logger) {
-            return logger;
-        }
-        logger = pino_1({ ...defaultOptions, level });
-    }
-    function createDebugLogger(name) {
-        initLogger();
-        const sublogger = logger.child({
-            name,
-        });
-        return (msg) => {
-            sublogger.debug(msg);
-        };
-    }
-
-    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));
-        }
-    }
-
-    class BarretenbergWasmThread extends BarretenbergWasmBase {
-        /**
-         * Init as worker thread.
-         */
-        async initThread(module, memory) {
-            this.logger = threadLogger() || this.logger;
-            this.memory = memory;
-            this.instance = await WebAssembly.instantiate(module, this.getImportObj(this.memory));
-        }
-        destroy() {
-            killSelf();
-        }
-        getImportObj(memory) {
-            const baseImports = super.getImportObj(memory);
-            /* eslint-disable camelcase */
-            return {
-                ...baseImports,
-                wasi: {
-                    'thread-spawn': () => {
-                        this.logger('PANIC: threads cannot spawn threads!');
-                        this.logger(new Error().stack);
-                        killSelf();
-                    },
-                },
-                // 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: {
-                    ...baseImports.env,
-                    env_hardware_concurrency: () => {
-                        // We return 1, which should cause any algos using threading to just not create a thread.
-                        return 1;
-                    },
-                },
-            };
-            /* eslint-enable camelcase */
-        }
-    }
-
-    addEventListener('message', e => {
-        if (e.data.log) {
-            initLogger(e.data.log);
-        }
-    });
-    expose(new BarretenbergWasmThread());
-    postMessage(Ready);
-
-})();