voting_schemes-electionguard 0.24.2 → 0.24.4

data/public/assets/electionguard/pyodide.js

@@ -2,270 +2,366 @@
  * The main bootstrap script for loading pyodide.
  */
 
-var languagePluginLoader = new Promise((resolve, reject) => {
-  // Note: PYODIDE_BASE_URL is an environement variable replaced in
+/**
+ * The :ref:`js-api-pyodide` module object. Must be present as a global variable
+ * called
+ * ``pyodide`` in order for package loading to work properly.
+ *
+ * @type Object
+ */
+globalThis.pyodide = {};
+
+/**
+ * Load the main Pyodide wasm module and initialize it. When finished stores the
+ * Pyodide module as a global object called ``pyodide``.
+ * @param {string} config.indexURL - The URL from which Pyodide will load
+ * packages
+ * @returns The Pyodide module.
+ * @async
+ */
+globalThis.loadPyodide = async function(config = {}) {
+  if (globalThis.__pyodideLoading) {
+    if (globalThis.languagePluginURL) {
+      throw new Error(
+          "Pyodide is already loading because languagePluginURL is defined.");
+    } else {
+      throw new Error("Pyodide is already loading.");
+    }
+  }
+  globalThis.__pyodideLoading = true;
+  let Module = {};
+  // Note: PYODIDE_BASE_URL is an environment variable replaced in
   // in this template in the Makefile. It's recommended to always set
-  // languagePluginUrl in any case.
-  var baseURL = self.languagePluginUrl || './';
-  baseURL = baseURL.substr(0, baseURL.lastIndexOf('/')) + '/';
+  // indexURL in any case.
+  let baseURL = config.indexURL || "./";
+  if (baseURL.endsWith(".js")) {
+    baseURL = baseURL.substr(0, baseURL.lastIndexOf('/'));
+  }
+  if (!baseURL.endsWith("/")) {
+    baseURL += '/';
+  }
 
   ////////////////////////////////////////////////////////////
   // Package loading
-  let loadedPackages = {};
-  var loadPackagePromise = new Promise((resolve) => resolve());
+  const DEFAULT_CHANNEL = "default channel";
+
   // Regexp for validating package name and URI
-  var package_name_regexp = '[a-z0-9_][a-z0-9_\-]*'
-  var package_uri_regexp =
-      new RegExp('^https?://.*?(' + package_name_regexp + ').js$', 'i');
-  var package_name_regexp = new RegExp('^' + package_name_regexp + '$', 'i');
-
-  let _uri_to_package_name = (package_uri) => {
-    // Generate a unique package name from URI
-
-    if (package_name_regexp.test(package_uri)) {
-      return package_uri;
-    } else if (package_uri_regexp.test(package_uri)) {
-      let match = package_uri_regexp.exec(package_uri);
-      // Get the regexp group corresponding to the package name
+  const package_uri_regexp = /^.*?([^\/]*)\.js$/;
+
+  function _uri_to_package_name(package_uri) {
+    let match = package_uri_regexp.exec(package_uri);
+    if (match) {
       return match[1];
-    } else {
-      return null;
     }
   };
 
-  // clang-format off
-  let preloadWasm = () => {
-    // On Chrome, we have to instantiate wasm asynchronously. Since that
-    // can't be done synchronously within the call to dlopen, we instantiate
-    // every .so that comes our way up front, caching it in the
-    // `preloadedWasm` dictionary.
-
-    let promise = new Promise((resolve) => resolve());
-    let FS = pyodide._module.FS;
-
-    function recurseDir(rootpath) {
-      let dirs;
-      try {
-        dirs = FS.readdir(rootpath);
-      } catch {
-        return;
-      }
-      for (let entry of dirs) {
-        if (entry.startsWith('.')) {
-          continue;
-        }
-        const path = rootpath + entry;
-        if (entry.endsWith('.so')) {
-          if (Module['preloadedWasm'][path] === undefined) {
-            promise = promise
-              .then(() => Module['loadWebAssemblyModule'](
-                FS.readFile(path), {loadAsync: true}))
-              .then((module) => {
-                Module['preloadedWasm'][path] = module;
-              });
-          }
-        } else if (FS.isDir(FS.lookupPath(path).node.mode)) {
-          recurseDir(path + '/');
-        }
-      }
-    }
-
-    recurseDir('/');
-
-    return promise;
-  }
-  // clang-format on
-
-  function loadScript(url, onload, onerror) {
-    if (self.document) { // browser
+  let loadScript;
+  if (self.document) { // browser
+    loadScript = (url) => new Promise((res, rej) => {
       const script = self.document.createElement('script');
       script.src = url;
-      script.onload = (e) => { onload(); };
-      script.onerror = (e) => { onerror(); };
+      script.onload = res;
+      script.onerror = rej;
       self.document.head.appendChild(script);
-    } else if (self.importScripts) { // webworker
-      try {
-        self.importScripts(url);
-        onload();
-      } catch {
-        onerror();
-      }
-    }
-  }
-
-  let _loadPackage = (names, messageCallback, errorCallback) => {
-    if (messageCallback == undefined) {
-      messageCallback = () => {};
-    }
-    if (errorCallback == undefined) {
-      errorCallback = () => {};
-    }
-    let _messageCallback = (msg) => {
-      console.log(msg);
-      messageCallback(msg);
-    };
-    let _errorCallback = (errMsg) => {
-      console.error(errMsg);
-      errorCallback(errMsg);
+    });
+  } else if (self.importScripts) { // webworker
+    loadScript = async (url) => {  // This is async only for consistency
+      self.importScripts(url);
     };
+  } else {
+    throw new Error("Cannot determine runtime environment");
+  }
 
-    // DFS to find all dependencies of the requested packages
-    let packages = self.pyodide._module.packages.dependencies;
-    let loadedPackages = self.pyodide.loadedPackages;
-    let queue = [].concat(names || []);
-    let toLoad = {};
-    while (queue.length) {
-      let package_uri = queue.pop();
-
-      const pkg = _uri_to_package_name(package_uri);
+  function recursiveDependencies(names, _messageCallback, errorCallback,
+                                 sharedLibsOnly) {
+    const packages = Module.packages.dependencies;
+    const loadedPackages = Module.loadedPackages;
+    const sharedLibraries = Module.packages.shared_library;
+    const toLoad = new Map();
 
-      if (pkg == null) {
-        _errorCallback(`Invalid package name or URI '${package_uri}'`);
+    const addPackage = (pkg) => {
+      if (toLoad.has(pkg)) {
         return;
-      } else if (pkg == package_uri) {
-        package_uri = 'default channel';
       }
-
-      if (pkg in loadedPackages) {
-        if (package_uri != loadedPackages[pkg]) {
-          _errorCallback(`URI mismatch, attempting to load package ` +
-                         `${pkg} from ${package_uri} while it is already ` +
-                         `loaded from ${loadedPackages[pkg]}!`);
-          return;
-        } else {
-          _messageCallback(`${pkg} already loaded from ${loadedPackages[pkg]}`)
-        }
-      } else if (pkg in toLoad) {
-        if (package_uri != toLoad[pkg]) {
-          _errorCallback(`URI mismatch, attempting to load package ` +
-                         `${pkg} from ${package_uri} while it is already ` +
-                         `being loaded from ${toLoad[pkg]}!`);
-          return;
+      toLoad.set(pkg, DEFAULT_CHANNEL);
+      // If the package is already loaded, we don't add dependencies, but warn
+      // the user later. This is especially important if the loaded package is
+      // from a custom url, in which case adding dependencies is wrong.
+      if (loadedPackages[pkg] !== undefined) {
+        return;
+      }
+      for (let dep of packages[pkg]) {
+        addPackage(dep);
+      }
+    };
+    for (let name of names) {
+      const pkgname = _uri_to_package_name(name);
+      if (pkgname !== undefined) {
+        if (toLoad.has(pkgname) && toLoad.get(pkgname) !== name) {
+          errorCallback(`Loading same package ${pkgname} from ${name} and ${
+              toLoad.get(pkgname)}`);
+          continue;
         }
+        toLoad.set(pkgname, name);
+      } else if (name in packages) {
+        addPackage(name);
       } else {
-        console.log(
-            `${pkg} to be loaded from ${package_uri}`); // debug level info.
-
-        toLoad[pkg] = package_uri;
-        if (packages.hasOwnProperty(pkg)) {
-          packages[pkg].forEach((subpackage) => {
-            if (!(subpackage in loadedPackages) && !(subpackage in toLoad)) {
-              queue.push(subpackage);
-            }
-          });
-        } else {
-          _errorCallback(`Unknown package '${pkg}'`);
+        errorCallback(`Skipping unknown package '${name}'`);
+      }
+    }
+    if (sharedLibsOnly) {
+      let onlySharedLibs = new Map();
+      for (let c of toLoad) {
+        if (c[0] in sharedLibraries) {
+          onlySharedLibs.set(c[0], toLoad.get(c[0]));
         }
       }
+      return onlySharedLibs;
     }
+    return toLoad;
+  }
 
-    self.pyodide._module.locateFile = (path) => {
+  async function _loadPackage(names, messageCallback, errorCallback) {
+    // toLoad is a map pkg_name => pkg_uri
+    let toLoad = recursiveDependencies(names, messageCallback, errorCallback);
+
+    // locateFile is the function used by the .js file to locate the .data
+    // file given the filename
+    Module.locateFile = (path) => {
       // handle packages loaded from custom URLs
       let pkg = path.replace(/\.data$/, "");
-      if (pkg in toLoad) {
-        let package_uri = toLoad[pkg];
-        if (package_uri != 'default channel') {
+      if (toLoad.has(pkg)) {
+        let package_uri = toLoad.get(pkg);
+        if (package_uri != DEFAULT_CHANNEL) {
           return package_uri.replace(/\.js$/, ".data");
         };
       };
       return baseURL + path;
     };
 
-    let promise = new Promise((resolve, reject) => {
-      if (Object.keys(toLoad).length === 0) {
-        resolve('No new packages to load');
-        return;
-      }
-
-      let packageList = Array.from(Object.keys(toLoad));
-      _messageCallback(`Loading ${packageList.join(', ')}`)
+    if (toLoad.size === 0) {
+      return Promise.resolve('No new packages to load');
+    } else {
+      let packageNames = Array.from(toLoad.keys()).join(', ');
+      messageCallback(`Loading ${packageNames}`);
+    }
 
-      // monitorRunDependencies is called at the beginning and the end of each
-      // package being loaded. We know we are done when it has been called
-      // exactly "toLoad * 2" times.
-      var packageCounter = Object.keys(toLoad).length * 2;
+    // If running in main browser thread, try to catch errors thrown when
+    // running a script. Since the script is added via a script tag, there is
+    // no good way to capture errors from the script only, so try to capture
+    // all errors them.
+    //
+    // windowErrorPromise rejects when any exceptions is thrown in the process
+    // of loading a script. The promise never resolves, and we combine it
+    // with other promises via Promise.race.
+    let windowErrorHandler;
+    let windowErrorPromise;
+    if (self.document) {
+      windowErrorPromise = new Promise((_res, rej) => {
+        windowErrorHandler = e => {
+          errorCallback(
+              "Unhandled error. We don't know what it is or whether it is related to 'loadPackage' but out of an abundance of caution we will assume that loading failed.");
+          errorCallback(e);
+          rej(e.message);
+        };
+        self.addEventListener('error', windowErrorHandler);
+      });
+    } else {
+      // This should be a promise that never resolves
+      windowErrorPromise = new Promise(() => {});
+    }
 
-      self.pyodide._module.monitorRunDependencies = () => {
-        packageCounter--;
-        if (packageCounter === 0) {
-          for (let pkg in toLoad) {
-            self.pyodide.loadedPackages[pkg] = toLoad[pkg];
-          }
-          delete self.pyodide._module.monitorRunDependencies;
-          self.removeEventListener('error', windowErrorHandler);
-
-          let resolveMsg = `Loaded `;
-          if (packageList.length > 0) {
-            resolveMsg += packageList.join(', ');
-          } else {
-            resolveMsg += 'no packages'
-          }
+    // This is a collection of promises that resolve when the package's JS file
+    // is loaded. The promises already handle error and never fail.
+    let scriptPromises = [];
+
+    for (let [pkg, uri] of toLoad) {
+      let loaded = Module.loadedPackages[pkg];
+      if (loaded !== undefined) {
+        // If uri is from the DEFAULT_CHANNEL, we assume it was added as a
+        // depedency, which was previously overridden.
+        if (loaded === uri || uri === DEFAULT_CHANNEL) {
+          messageCallback(`${pkg} already loaded from ${loaded}`);
+          continue;
+        } else {
+          errorCallback(
+              `URI mismatch, attempting to load package ${pkg} from ${uri} ` +
+              `while it is already loaded from ${
+                  loaded}. To override a dependency, ` +
+              `load the custom package first.`);
+          continue;
+        }
+      }
+      let scriptSrc = uri === DEFAULT_CHANNEL ? `${baseURL}${pkg}.js` : uri;
+      messageCallback(`Loading ${pkg} from ${scriptSrc}`);
+      scriptPromises.push(loadScript(scriptSrc).catch(() => {
+        errorCallback(`Couldn't load package from URL ${scriptSrc}`);
+        toLoad.delete(pkg);
+      }));
+    }
 
-          if (!isFirefox) {
-            preloadWasm().then(() => {
-              console.log(resolveMsg);
-              resolve(resolveMsg);
-            });
-          } else {
-            console.log(resolveMsg);
-            resolve(resolveMsg);
+    // When the JS loads, it synchronously adds a runDependency to emscripten.
+    // It then loads the data file, and removes the runDependency from
+    // emscripten. This function returns a promise that resolves when there are
+    // no pending runDependencies.
+    function waitRunDependency() {
+      const promise = new Promise(r => {
+        Module.monitorRunDependencies = (n) => {
+          if (n === 0) {
+            r();
           }
-        }
-      };
+        };
+      });
+      // If there are no pending dependencies left, monitorRunDependencies will
+      // never be called. Since we can't check the number of dependencies,
+      // manually trigger a call.
+      Module.addRunDependency("dummy");
+      Module.removeRunDependency("dummy");
+      return promise;
+    }
 
-      // Add a handler for any exceptions that are thrown in the process of
-      // loading a package
-      var windowErrorHandler = (err) => {
-        delete self.pyodide._module.monitorRunDependencies;
+    // We must start waiting for runDependencies *after* all the JS files are
+    // loaded, since the number of runDependencies may happen to equal zero
+    // between package files loading.
+    let successPromise = Promise.all(scriptPromises).then(waitRunDependency);
+    try {
+      await Promise.race([ successPromise, windowErrorPromise ]);
+    } finally {
+      delete Module.monitorRunDependencies;
+      if (windowErrorHandler) {
         self.removeEventListener('error', windowErrorHandler);
-        // Set up a new Promise chain, since this one failed
-        loadPackagePromise = new Promise((resolve) => resolve());
-        reject(err.message);
-      };
-      self.addEventListener('error', windowErrorHandler);
-
-      for (let pkg in toLoad) {
-        let scriptSrc;
-        let package_uri = toLoad[pkg];
-        if (package_uri == 'default channel') {
-          scriptSrc = `${baseURL}${pkg}.js`;
-        } else {
-          scriptSrc = `${package_uri}`;
-        }
-        _messageCallback(`Loading ${pkg} from ${scriptSrc}`)
-        loadScript(scriptSrc, () => {}, () => {
-          // If the package_uri fails to load, call monitorRunDependencies twice
-          // (so packageCounter will still hit 0 and finish loading), and remove
-          // the package from toLoad so we don't mark it as loaded, and remove
-          // the package from packageList so we don't say that it was loaded.
-          _errorCallback(`Couldn't load package from URL ${scriptSrc}`);
-          delete toLoad[pkg];
-          let packageListIndex = packageList.indexOf(pkg);
-          if (packageListIndex !== -1) {
-            packageList.splice(packageListIndex, 1);
-          }
-          for (let i = 0; i < 2; i++) {
-            self.pyodide._module.monitorRunDependencies();
-          }
-        });
       }
+    }
 
-      // We have to invalidate Python's import caches, or it won't
-      // see the new files. This is done here so it happens in parallel
-      // with the fetching over the network.
-      self.pyodide.runPython('import importlib as _importlib\n' +
-                             '_importlib.invalidate_caches()\n');
-    });
+    let packageList = [];
+    for (let [pkg, uri] of toLoad) {
+      Module.loadedPackages[pkg] = uri;
+      packageList.push(pkg);
+    }
+
+    let resolveMsg;
+    if (packageList.length > 0) {
+      let packageNames = packageList.join(', ');
+      resolveMsg = `Loaded ${packageNames}`;
+    } else {
+      resolveMsg = 'No packages loaded';
+    }
+
+    Module.reportUndefinedSymbols();
+
+    messageCallback(resolveMsg);
 
-    return promise;
+    // We have to invalidate Python's import caches, or it won't
+    // see the new files.
+    Module.runPythonSimple('import importlib\n' +
+                           'importlib.invalidate_caches()\n');
   };
 
-  let loadPackage = (names, messageCallback, errorCallback) => {
-    /* We want to make sure that only one loadPackage invocation runs at any
-     * given time, so this creates a "chain" of promises. */
-    loadPackagePromise = loadPackagePromise.then(
-        () => _loadPackage(names, messageCallback, errorCallback));
-    return loadPackagePromise;
+  // This is a promise that is resolved iff there are no pending package loads.
+  // It never fails.
+  let loadPackageChain = Promise.resolve();
+
+  /**
+   *
+   * The list of packages that Pyodide has loaded.
+   * Use ``Object.keys(pyodide.loadedPackages)`` to get the list of names of
+   * loaded packages, and ``pyodide.loadedPackages[package_name]`` to access
+   * install location for a particular ``package_name``.
+   *
+   * @type {object}
+   */
+  Module.loadedPackages = {};
+
+  /**
+   * Load a package or a list of packages over the network. This installs the
+   * package in the virtual filesystem. The package needs to be imported from
+   * Python before it can be used.
+   * @param {String | Array | PyProxy} names Either a single package name or URL
+   * or a list of them. URLs can be absolute or relative. The URLs must have
+   * file name
+   * ``<package-name>.js`` and there must be a file called
+   * ``<package-name>.data`` in the same directory. The argument can be a
+   * ``PyProxy`` of a list, in which case the list will be converted to
+   * Javascript and the ``PyProxy`` will be destroyed.
+   * @param {function} messageCallback A callback, called with progress messages
+   *    (optional)
+   * @param {function} errorCallback A callback, called with error/warning
+   *    messages (optional)
+   * @async
+   */
+  Module.loadPackage = async function(names, messageCallback, errorCallback) {
+    if (Module.isPyProxy(names)) {
+      let temp;
+      try {
+        temp = names.toJs();
+      } finally {
+        names.destroy();
+      }
+      names = temp;
+    }
+
+    if (!Array.isArray(names)) {
+      names = [ names ];
+    }
+    // get shared library packages and load those first
+    // otherwise bad things happen with linking them in firefox.
+    let sharedLibraryNames = [];
+    try {
+      let sharedLibraryPackagesToLoad =
+          recursiveDependencies(names, messageCallback, errorCallback, true);
+      for (let pkg of sharedLibraryPackagesToLoad) {
+        sharedLibraryNames.push(pkg[0]);
+      }
+    } catch (e) {
+      // do nothing - let the main load throw any errors
+    }
+    // override the load plugin so that it imports any dlls also
+    // this only needs to be done for shared library packages because
+    // we assume that if a package depends on a shared library
+    // it needs to have access to it.
+    // not needed for so in standard module because those are linked together
+    // correctly, it is only where linking goes across modules that it needs to
+    // be done. Hence we only put this extra preload plugin in during the shared
+    // library load
+    let oldPlugin;
+    for (let p in Module.preloadPlugins) {
+      if (Module.preloadPlugins[p].canHandle("test.so")) {
+        oldPlugin = Module.preloadPlugins[p];
+        break;
+      }
+    }
+    let dynamicLoadHandler = {
+      get : function(obj, prop) {
+        if (prop === 'handle') {
+          return function(bytes, name) {
+            obj[prop].apply(obj, arguments);
+            this["asyncWasmLoadPromise"] =
+                this["asyncWasmLoadPromise"].then(function() {
+                  Module.loadDynamicLibrary(name,
+                                            {global : true, nodelete : true})
+                });
+          }
+        } else {
+          return obj[prop];
+        }
+      }
+    };
+    var loadPluginOverride = new Proxy(oldPlugin, dynamicLoadHandler);
+    // restore the preload plugin
+    Module.preloadPlugins.unshift(loadPluginOverride);
+
+    let promise = loadPackageChain.then(
+        () => _loadPackage(sharedLibraryNames, messageCallback || console.log,
+                           errorCallback || console.error));
+    loadPackageChain = loadPackageChain.then(() => promise.catch(() => {}));
+    await promise;
+    Module.preloadPlugins.shift(loadPluginOverride);
+
+    promise = loadPackageChain.then(
+        () => _loadPackage(names, messageCallback || console.log,
+                           errorCallback || console.error));
+    loadPackageChain = loadPackageChain.then(() => promise.catch(() => {}));
+    await promise;
   };
 
   ////////////////////////////////////////////////////////////
@@ -292,27 +388,35 @@ var languagePluginLoader = new Promise((resolve, reject) => {
     if (recursionLimit > 1000) {
       recursionLimit = 1000;
     }
-    pyodide.runPython(
+    pyodide.runPythonSimple(
         `import sys; sys.setrecursionlimit(int(${recursionLimit}))`);
   };
 
   ////////////////////////////////////////////////////////////
   // Rearrange namespace for public API
+  // clang-format off
   let PUBLIC_API = [
     'globals',
+    'pyodide_py',
+    'version',
     'loadPackage',
+    'loadPackagesFromImports',
     'loadedPackages',
+    'isPyProxy',
     'pyimport',
-    'repr',
     'runPython',
     'runPythonAsync',
-    'checkABI',
-    'version',
-    'autocomplete',
+    'registerJsModule',
+    'unregisterJsModule',
+    'setInterruptBuffer',
+    'toPy',
+    'PythonError',
   ];
+  // clang-format on
 
   function makePublicAPI(module, public_api) {
-    var namespace = {_module : module};
+    let namespace = {_module : module};
+    module.public_api = namespace;
     for (let name of public_api) {
       namespace[name] = module[name];
     }
@@ -321,120 +425,464 @@ var languagePluginLoader = new Promise((resolve, reject) => {
 
   ////////////////////////////////////////////////////////////
   // Loading Pyodide
-  let Module = {};
-  self.Module = Module;
 
   Module.noImageDecoding = true;
   Module.noAudioDecoding = true;
-  Module.noWasmDecoding = true;
+  Module.noWasmDecoding =
+      false; // we preload wasm using the built in plugin now
   Module.preloadedWasm = {};
-  let isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') > -1;
-
-  Module.checkABI = function(ABI_number) {
-    if (ABI_number !== parseInt('1')) {
-      var ABI_mismatch_exception =
-          `ABI numbers differ. Expected 1, got ${
-              ABI_number}`;
-      console.error(ABI_mismatch_exception);
-      throw ABI_mismatch_exception;
+
+  let fatal_error_occurred = false;
+  Module.fatal_error = function(e) {
+    if (fatal_error_occurred) {
+      console.error("Recursive call to fatal_error. Inner error was:");
+      console.error(e);
+      return;
     }
-    return true;
+    fatal_error_occurred = true;
+    console.error("Pyodide has suffered a fatal error. " +
+                  "Please report this to the Pyodide maintainers.");
+    console.error("The cause of the fatal error was:")
+    console.error(e);
+    try {
+      let fd_stdout = 1;
+      Module.__Py_DumpTraceback(fd_stdout,
+                                Module._PyGILState_GetThisThreadState());
+      for (let key of PUBLIC_API) {
+        if (key === "version") {
+          continue;
+        }
+        Object.defineProperty(Module.public_api, key, {
+          enumerable : true,
+          configurable : true,
+          get : () => {
+            throw new Error(
+                "Pyodide already fatally failed and can no longer be used.");
+          }
+        });
+      }
+      if (Module.on_fatal) {
+        Module.on_fatal(e);
+      }
+    } catch (e) {
+      console.error("Another error occurred while handling the fatal error:");
+      console.error(e);
+    }
+    throw e;
   };
 
-  Module.autocomplete = function(path) {
-    var pyodide_module = Module.pyimport("pyodide");
-    return pyodide_module.get_completions(path);
+  /**
+   * An alias to the Python :py:mod:`pyodide` package.
+   *
+   * You can use this to call functions defined in the Pyodide Python package
+   * from Javascript.
+   *
+   * @type {PyProxy}
+   */
+  Module.pyodide_py = {}; // actually defined in runPythonSimple below
+
+  /**
+   *
+   * An alias to the global Python namespace.
+   *
+   * For example, to access a variable called ``foo`` in the Python global
+   * scope, use ``pyodide.globals.get("foo")``
+   *
+   * @type {PyProxy}
+   */
+  Module.globals = {}; // actually defined in runPythonSimple below
+
+  // clang-format off
+  /**
+   * A Javascript error caused by a Python exception.
+   *
+   * In order to reduce the risk of large memory leaks, the ``PythonError``
+   * contains no reference to the Python exception that caused it. You can find
+   * the actual Python exception that caused this error as `sys.last_value
+   * <https://docs.python.org/3/library/sys.html#sys.last_value>`_.
+   *
+   * See :ref:`type-translations-errors` for more information.
+   *
+   * .. admonition:: Avoid Stack Frames
+   *    :class: warning
+   *
+   *    If you make a :any:`PyProxy` of ``sys.last_value``, you should be
+   *    especially careful to :any:`destroy() <PyProxy.destroy>` it when you are
+   *    done. You may leak a large amount of memory including the local
+   *    variables of all the stack frames in the traceback if you don't. The
+   *    easiest way is to only handle the exception in Python.
+   *
+   * @class
+   */
+  Module.PythonError = class PythonError {
+    // actually defined in error_handling.c. TODO: would be good to move this
+    // documentation and the definition of PythonError to error_handling.js
+    constructor(){
+      /**
+       * The Python traceback.
+       * @type {string}
+       */
+      this.message;
+    }
   };
+  // clang-format on
 
-  Module.locateFile = (path) => baseURL + path;
-  var postRunPromise = new Promise((resolve, reject) => {
-    Module.postRun = () => {
-      delete self.Module;
-      fetch(`${baseURL}packages.json`)
-          .then((response) => response.json())
-          .then((json) => {
-            fixRecursionLimit(self.pyodide);
-            self.pyodide.globals =
-                self.pyodide.runPython('import sys\nsys.modules["__main__"]');
-            self.pyodide = makePublicAPI(self.pyodide, PUBLIC_API);
-            self.pyodide._module.packages = json;
-            if (self.iodide !== undefined) {
-              // Perform some completions immediately so there isn't a delay on
-              // the first call to autocomplete
-              self.pyodide.runPython('import pyodide');
-              self.pyodide.runPython('pyodide.get_completions("")');
-            }
-            resolve();
-          });
-    };
-  });
+  /**
+   *
+   * The Pyodide version.
+   *
+   * It can be either the exact release version (e.g. ``0.1.0``), or
+   * the latest release version followed by the number of commits since, and
+   * the git hash of the current commit (e.g. ``0.1.0-1-bd84646``).
+   *
+   * @type {string}
+   */
+  Module.version = ""; // Hack to make jsdoc behave
+
+  /**
+   * Run Python code in the simplest way possible. The primary purpose of this
+   * method is for bootstrapping. It is also useful for debugging: If the Python
+   * interpreter is initialized successfully then it should be possible to use
+   * this method to run Python code even if everything else in the Pyodide
+   * `core` module fails.
+   *
+   * The differences are:
+   *    1. `runPythonSimple` doesn't return anything (and so won't leak
+   *        PyProxies)
+   *    2. `runPythonSimple` doesn't require access to any state on the
+   *       Javascript `pyodide` module.
+   *    3. `runPython` uses `pyodide.eval_code`, whereas `runPythonSimple` uses
+   *       `PyRun_String` which is the C API for `eval` / `exec`.
+   *    4. `runPythonSimple` runs with `globals` a separate dict which is called
+   *       `init_dict` (keeps global state private)
+   *    5. `runPythonSimple` doesn't dedent the argument
+   *
+   * When `core` initialization is completed, the globals for `runPythonSimple`
+   * is made available as `Module.init_dict`.
+   *
+   * @private
+   */
+  Module.runPythonSimple = function(code) {
+    let code_c_string = Module.stringToNewUTF8(code);
+    let errcode;
+    try {
+      errcode = Module._run_python_simple_inner(code_c_string);
+    } catch (e) {
+      Module.fatal_error(e);
+    } finally {
+      Module._free(code_c_string);
+    }
+    if (errcode === -1) {
+      Module._pythonexc2js();
+    }
+  };
 
-  var dataLoadPromise = new Promise((resolve, reject) => {
-    Module.monitorRunDependencies =
-        (n) => {
-          if (n === 0) {
-            delete Module.monitorRunDependencies;
-            resolve();
-          }
-        }
-  });
-
-  Promise.all([ postRunPromise, dataLoadPromise ]).then(() => resolve());
-
-  const data_script_src = `${baseURL}pyodide.asm.data.js`;
-  loadScript(data_script_src, () => {
-    const scriptSrc = `${baseURL}pyodide.asm.js`;
-    loadScript(scriptSrc, () => {
-      // The emscripten module needs to be at this location for the core
-      // filesystem to install itself. Once that's complete, it will be replaced
-      // by the call to `makePublicAPI` with a more limited public API.
-      self.pyodide = pyodide(Module);
-      self.pyodide.loadedPackages = {};
-      self.pyodide.loadPackage = loadPackage;
-    }, () => {});
-  }, () => {});
+  /**
+   * Runs a string of Python code from Javascript.
+   *
+   * The last part of the string may be an expression, in which case, its value
+   * is returned.
+   *
+   * @param {string} code Python code to evaluate
+   * @param {dict} globals An optional Python dictionary to use as the globals.
+   *        Defaults to :any:`pyodide.globals`. Uses the Python API
+   *        :any:`pyodide.eval_code` to evaluate the code.
+   * @returns The result of the Python code translated to Javascript. See the
+   *          documentation for :any:`pyodide.eval_code` for more info.
+   */
+  Module.runPython = function(code, globals = Module.globals) {
+    return Module.pyodide_py.eval_code(code, globals);
+  };
 
-  ////////////////////////////////////////////////////////////
-  // Iodide-specific functionality, that doesn't make sense
-  // if not using with Iodide.
-  if (self.iodide !== undefined) {
-    // Load the custom CSS for Pyodide
-    let link = document.createElement('link');
-    link.rel = 'stylesheet';
-    link.type = 'text/css';
-    link.href = `${baseURL}renderedhtml.css`;
-    document.getElementsByTagName('head')[0].appendChild(link);
-
-    // Add a custom output handler for Python objects
-    self.iodide.addOutputRenderer({
-      shouldRender : (val) => {
-        return (typeof val === 'function' &&
-                pyodide._module.PyProxy.isPyProxy(val));
-      },
-
-      render : (val) => {
-        let div = document.createElement('div');
-        div.className = 'rendered_html';
-        var element;
-        if (val._repr_html_ !== undefined) {
-          let result = val._repr_html_();
-          if (typeof result === 'string') {
-            div.appendChild(new DOMParser()
-                                .parseFromString(result, 'text/html')
-                                .body.firstChild);
-            element = div;
-          } else {
-            element = result;
-          }
-        } else {
-          let pre = document.createElement('pre');
-          pre.textContent = val.toString();
-          div.appendChild(pre);
-          element = div;
-        }
-        return element.outerHTML;
+  // clang-format off
+  /**
+   * Inspect a Python code chunk and use :js:func:`pyodide.loadPackage` to
+   * install any known packages that the code chunk imports. Uses the Python API
+   * :func:`pyodide.find\_imports` to inspect the code.
+   *
+   * For example, given the following code as input
+   *
+   * .. code-block:: python
+   *
+   *    import numpy as np x = np.array([1, 2, 3])
+   *
+   * :js:func:`loadPackagesFromImports` will call
+   * ``pyodide.loadPackage(['numpy'])``. See also :js:func:`runPythonAsync`.
+   *
+   * @param {string} code The code to inspect.
+   * @param {Function} messageCallback The ``messageCallback`` argument of
+   * :any:`pyodide.loadPackage` (optional).
+   * @param {Function} errorCallback The ``errorCallback`` argument of
+   * :any:`pyodide.loadPackage` (optional).
+   * @async
+   */
+  Module.loadPackagesFromImports = async function(code, messageCallback, errorCallback) {
+    let imports = Module.pyodide_py.find_imports(code).toJs();
+    if (imports.length === 0) {
+      return;
+    }
+    let packageNames = Module.packages.import_name_to_package_name;
+    let packages = new Set();
+    for (let name of imports) {
+      if (name in packageNames) {
+        packages.add(packageNames[name]);
       }
-    });
-  }
-});
-languagePluginLoader
+    }
+    if (packages.size) {
+      await Module.loadPackage(
+        Array.from(packages.keys()), messageCallback, errorCallback
+      );
+    }
+  };
+  // clang-format on
+
+  /**
+   * Access a Python object in the global namespace from Javascript.
+   *
+   * @deprecated This function will be removed in version 0.18.0. Use
+   *    :any:`pyodide.globals.get('key') <pyodide.globals>` instead.
+   *
+   * @param {string} name Python variable name
+   * @returns The Python object translated to Javascript.
+   */
+  Module.pyimport = name => {
+    console.warn(
+        "Access to the Python global namespace via pyodide.pyimport is deprecated and " +
+        "will be removed in version 0.18.0. Use pyodide.globals.get('key') instead.");
+    return Module.globals.get(name);
+  };
+
+  /**
+   * Runs Python code, possibly asynchronously loading any known packages that
+   * the code imports. For example, given the following code
+   *
+   * .. code-block:: python
+   *
+   *    import numpy as np
+   *    x = np.array([1, 2, 3])
+   *
+   * Pyodide will first call :any:`pyodide.loadPackage(['numpy'])
+   * <pyodide.loadPackage>`, and then run the code using the Python API
+   * :any:`pyodide.eval_code_async`, returning the result. The code is compiled
+   * with `PyCF_ALLOW_TOP_LEVEL_AWAIT
+   * <https://docs.python.org/3/library/ast.html?highlight=pycf_allow_top_level_await#ast.PyCF_ALLOW_TOP_LEVEL_AWAIT>`_.
+   *
+   * For example:
+   *
+   * .. code-block:: pyodide
+   *
+   *    let result = await pyodide.runPythonAsync(`
+   *        # numpy will automatically be loaded by loadPackagesFromImports
+   *        import numpy as np
+   *        # we can use top level await
+   *        from js import fetch
+   *        response = await fetch("./packages.json")
+   *        packages = await response.json()
+   *        # If final statement is an expression, its value is returned to
+   * Javascript len(packages.dependencies.object_keys())
+   *    `);
+   *    console.log(result); // 72
+   *
+   * @param {string} code Python code to evaluate
+   * @param {Function} messageCallback The ``messageCallback`` argument of
+   * :any:`pyodide.loadPackage`.
+   * @param {Function} errorCallback The ``errorCallback`` argument of
+   * :any:`pyodide.loadPackage`.
+   * @returns The result of the Python code translated to Javascript.
+   * @async
+   */
+  Module.runPythonAsync = async function(code, messageCallback, errorCallback) {
+    await Module.loadPackagesFromImports(code, messageCallback, errorCallback);
+    let coroutine = Module.pyodide_py.eval_code_async(code, Module.globals);
+    try {
+      let result = await coroutine;
+      return result;
+    } finally {
+      coroutine.destroy();
+    }
+  };
+
+  // clang-format off
+  /**
+   * Registers the Javascript object ``module`` as a Javascript module named
+   * ``name``. This module can then be imported from Python using the standard
+   * Python import system. If another module by the same name has already been
+   * imported, this won't have much effect unless you also delete the imported
+   * module from ``sys.modules``. This calls the ``pyodide_py`` API
+   * :func:`pyodide.register_js_module`.
+   *
+   * @param {string} name Name of the Javascript module to add
+   * @param {object} module Javascript object backing the module
+   */
+  Module.registerJsModule = function(name, module) {
+    Module.pyodide_py.register_js_module(name, module);
+  };
+
+  /**
+   * Unregisters a Javascript module with given name that has been previously
+   * registered with :js:func:`pyodide.registerJsModule` or
+   * :func:`pyodide.register_js_module`. If a Javascript module with that name
+   * does not already exist, will throw an error. Note that if the module has
+   * already been imported, this won't have much effect unless you also delete
+   * the imported module from ``sys.modules``. This calls the ``pyodide_py`` API
+   * :func:`pyodide.unregister_js_module`.
+   *
+   * @param {string} name Name of the Javascript module to remove
+   */
+  Module.unregisterJsModule = function(name) {
+    Module.pyodide_py.unregister_js_module(name);
+  };
+  // clang-format on
+
+  /**
+   * Convert the Javascript object to a Python object as best as possible.
+   *
+   * This is similar to :any:`JsProxy.to_py` but for use from Javascript. If the
+   * object is immutable or a :any:`PyProxy`, it will be returned unchanged. If
+   * the object cannot be converted into Python, it will be returned unchanged.
+   *
+   * See :ref:`type-translations-jsproxy-to-py` for more information.
+   *
+   * @param {*} obj
+   * @param {number} depth Optional argument to limit the depth of the
+   * conversion.
+   * @returns {PyProxy} The object converted to Python.
+   */
+  Module.toPy = function(obj, depth = -1) {
+    // No point in converting these, it'd be dumb to proxy them so they'd just
+    // get converted back by `js2python` at the end
+    // clang-format off
+    switch (typeof obj) {
+      case "string":
+      case "number":
+      case "boolean":
+      case "bigint":
+      case "undefined":
+        return obj;
+    }
+    // clang-format on
+    if (!obj || Module.isPyProxy(obj)) {
+      return obj;
+    }
+    let obj_id = 0;
+    let py_result = 0;
+    let result = 0;
+    try {
+      obj_id = Module.hiwire.new_value(obj);
+      py_result = Module.__js2python_convert(obj_id, new Map(), depth);
+      // clang-format off
+      if(py_result === 0){
+        // clang-format on
+        Module._pythonexc2js();
+      }
+      if (Module._JsProxy_Check(py_result)) {
+        // Oops, just created a JsProxy. Return the original object.
+        return obj;
+        // return Module.pyproxy_new(py_result);
+      }
+      result = Module._python2js(py_result);
+      // clang-format off
+      if (result === 0) {
+        // clang-format on
+        Module._pythonexc2js();
+      }
+    } finally {
+      Module.hiwire.decref(obj_id);
+      Module._Py_DecRef(py_result);
+    }
+    return Module.hiwire.pop_value(result);
+  };
+  /**
+   * Is the argument a :any:`PyProxy`?
+   * @param jsobj {any} Object to test.
+   * @returns {bool} Is ``jsobj`` a :any:`PyProxy`?
+   */
+  Module.isPyProxy = function(jsobj) {
+    return !!jsobj && jsobj.$$ !== undefined && jsobj.$$.type === 'PyProxy';
+  };
+
+  Module.locateFile = (path) => baseURL + path;
+
+  let moduleLoaded = new Promise(r => Module.postRun = r);
+
+  const scriptSrc = `${baseURL}pyodide.asm.js`;
+
+  await loadScript(scriptSrc);
+
+  // _createPyodideModule is specified in the Makefile by the linker flag:
+  // `-s EXPORT_NAME="'_createPyodideModule'"`
+  await _createPyodideModule(Module);
+
+  // There is some work to be done between the module being "ready" and postRun
+  // being called.
+  await moduleLoaded;
+
+  // Bootstrap step: `runPython` needs access to `Module.globals` and
+  // `Module.pyodide_py`. Use `runPythonSimple` to add these. runPythonSimple
+  // doesn't dedent the argument so the indentation matters.
+  Module.runPythonSimple(`
+def temp(Module):
+  import pyodide
+  import __main__
+  import builtins
+
+  globals = __main__.__dict__
+  globals.update(builtins.__dict__)
+
+  Module.version = pyodide.__version__
+  Module.globals = globals
+  Module.builtins = builtins.__dict__
+  Module.pyodide_py = pyodide
+`);
+
+  Module.saveState = () => Module.pyodide_py._state.save_state();
+  Module.restoreState = (state) =>
+      Module.pyodide_py._state.restore_state(state);
+
+  Module.init_dict.get("temp")(Module);
+  // Module.runPython works starting from here!
+
+  // Wrap "globals" in a special Proxy that allows `pyodide.globals.x` access.
+  // TODO: Should we have this?
+  Module.globals = Module.wrapNamespace(Module.globals);
+
+  let response = await fetch(`${baseURL}packages.json`);
+  Module.packages = await response.json();
+
+  fixRecursionLimit(Module);
+  let pyodide = makePublicAPI(Module, PUBLIC_API);
+  Module.registerJsModule("js", globalThis);
+  Module.registerJsModule("pyodide_js", pyodide);
+  globalThis.pyodide = pyodide;
+  return pyodide;
+};
+
+if (globalThis.languagePluginUrl) {
+  console.warn(
+      "languagePluginUrl is deprecated and will be removed in version 0.18.0, " +
+      "instead use loadPyodide({ indexURL : <some_url>})");
+
+  /**
+   * A deprecated parameter that specifies the Pyodide ``indexURL``. If present,
+   * Pyodide will automatically invoke
+   * ``loadPyodide({indexURL : languagePluginUrl})``
+   * and will store the resulting promise in
+   * :any:`globalThis.languagePluginLoader`. Use :any:`loadPyodide`
+   * directly instead of defining this.
+   *
+   * @type String
+   * @deprecated Will be removed in version 0.18.0
+   */
+  globalThis.languagePluginUrl;
+
+  /**
+   * A deprecated promise that resolves to ``undefined`` when Pyodide is
+   * finished loading. Only created if :any:`languagePluginUrl` is
+   * defined. Instead use :any:`loadPyodide`.
+   *
+   * @type Promise
+   * @deprecated Will be removed in version 0.18.0
+   */
+  globalThis.languagePluginLoader =
+      loadPyodide({indexURL : globalThis.languagePluginUrl});
+}