Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

7 files changed, 4548 insertions, 0 deletions

diff --git a/toolkit/components/translations/bergamot-translator/LICENSE b/toolkit/components/translations/bergamot-translator/LICENSE
new file mode 100644
index 0000000000..a612ad9813
--- /dev/null
+++ b/toolkit/components/translations/bergamot-translator/LICENSE
@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.
diff --git a/toolkit/components/translations/bergamot-translator/bergamot-translator.js b/toolkit/components/translations/bergamot-translator/bergamot-translator.js
new file mode 100644
index 0000000000..c50eb32dff
--- /dev/null
+++ b/toolkit/components/translations/bergamot-translator/bergamot-translator.js
@@ -0,0 +1,3509 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+function loadBergamot(Module) {
+  var BERGAMOT_VERSION_FULL = "v0.4.5+05a8778";
+  null;
+
+  var Module = typeof Module != "undefined" ? Module : {};
+
+  var moduleOverrides = Object.assign({}, Module);
+
+  var arguments_ = [];
+
+  var thisProgram = "./this.program";
+
+  var quit_ = (status, toThrow) => {
+    throw toThrow;
+  };
+
+  var ENVIRONMENT_IS_WEB = typeof window == "object";
+
+  var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
+
+  var ENVIRONMENT_IS_NODE =
+    typeof process == "object" &&
+    typeof process.versions == "object" &&
+    typeof process.versions.node == "string";
+
+  var scriptDirectory = "";
+
+  function locateFile(path) {
+    if (Module.locateFile) {
+      return Module.locateFile(path, scriptDirectory);
+    }
+    return scriptDirectory + path;
+  }
+
+  var read_, readAsync, readBinary, setWindowTitle;
+
+  if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+    if (ENVIRONMENT_IS_WORKER) {
+      scriptDirectory = self.location.href;
+    } else if (typeof document != "undefined" && document.currentScript) {
+      scriptDirectory = document.currentScript.src;
+    }
+    if (scriptDirectory.indexOf("blob:") !== 0) {
+      scriptDirectory = scriptDirectory.substr(
+        0,
+        scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1
+      );
+    } else {
+      scriptDirectory = "";
+    }
+    {
+      read_ = url => {
+        var xhr = new XMLHttpRequest();
+        xhr.open("GET", url, false);
+        xhr.send(null);
+        return xhr.responseText;
+      };
+      if (ENVIRONMENT_IS_WORKER) {
+        readBinary = url => {
+          var xhr = new XMLHttpRequest();
+          xhr.open("GET", url, false);
+          xhr.responseType = "arraybuffer";
+          xhr.send(null);
+          return new Uint8Array(xhr.response);
+        };
+      }
+      readAsync = (url, onload, onerror) => {
+        var xhr = new XMLHttpRequest();
+        xhr.open("GET", url, true);
+        xhr.responseType = "arraybuffer";
+        xhr.onload = () => {
+          if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
+            onload(xhr.response);
+            return;
+          }
+          onerror();
+        };
+        xhr.onerror = onerror;
+        xhr.send(null);
+      };
+    }
+    setWindowTitle = title => (document.title = title);
+  } else {
+  }
+
+  var out = Module.print || console.log.bind(console);
+
+  var err = Module.printErr || console.warn.bind(console);
+
+  Object.assign(Module, moduleOverrides);
+
+  moduleOverrides = null;
+
+  if (Module.arguments) {
+    arguments_ = Module.arguments;
+  }
+
+  if (Module.thisProgram) {
+    thisProgram = Module.thisProgram;
+  }
+
+  if (Module.quit) {
+    quit_ = Module.quit;
+  }
+
+  var tempRet0 = 0;
+
+  var setTempRet0 = value => {
+    tempRet0 = value;
+  };
+
+  var wasmBinary;
+
+  if (Module.wasmBinary) {
+    wasmBinary = Module.wasmBinary;
+  }
+
+  var noExitRuntime = Module.noExitRuntime || true;
+
+  if (typeof WebAssembly != "object") {
+    abort("no native wasm support detected");
+  }
+
+  var wasmMemory;
+
+  var ABORT = false;
+
+  var EXITSTATUS;
+
+  function assert(condition, text) {
+    if (!condition) {
+      abort(text);
+    }
+  }
+
+  var UTF8Decoder =
+    typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined;
+
+  function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {
+    var endIdx = idx + maxBytesToRead;
+    var endPtr = idx;
+    while (heapOrArray[endPtr] && !(endPtr >= endIdx)) {
+      ++endPtr;
+    }
+    if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+      return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+    }
+    var str = "";
+    while (idx < endPtr) {
+      var u0 = heapOrArray[idx++];
+      if (!(u0 & 128)) {
+        str += String.fromCharCode(u0);
+        continue;
+      }
+      var u1 = heapOrArray[idx++] & 63;
+      if ((u0 & 224) == 192) {
+        str += String.fromCharCode(((u0 & 31) << 6) | u1);
+        continue;
+      }
+      var u2 = heapOrArray[idx++] & 63;
+      if ((u0 & 240) == 224) {
+        u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+      } else {
+        u0 =
+          ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
+      }
+      if (u0 < 65536) {
+        str += String.fromCharCode(u0);
+      } else {
+        var ch = u0 - 65536;
+        str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+      }
+    }
+
+    return str;
+  }
+
+  function UTF8ToString(ptr, maxBytesToRead) {
+    return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
+  }
+
+  function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
+    if (!(maxBytesToWrite > 0)) {
+      return 0;
+    }
+    var startIdx = outIdx;
+    var endIdx = outIdx + maxBytesToWrite - 1;
+    for (var i = 0; i < str.length; ++i) {
+      var u = str.charCodeAt(i);
+      if (u >= 55296 && u <= 57343) {
+        var u1 = str.charCodeAt(++i);
+        u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
+      }
+      if (u <= 127) {
+        if (outIdx >= endIdx) {
+          break;
+        }
+        heap[outIdx++] = u;
+      } else if (u <= 2047) {
+        if (outIdx + 1 >= endIdx) {
+          break;
+        }
+        heap[outIdx++] = 192 | (u >> 6);
+        heap[outIdx++] = 128 | (u & 63);
+      } else if (u <= 65535) {
+        if (outIdx + 2 >= endIdx) {
+          break;
+        }
+        heap[outIdx++] = 224 | (u >> 12);
+        heap[outIdx++] = 128 | ((u >> 6) & 63);
+        heap[outIdx++] = 128 | (u & 63);
+      } else {
+        if (outIdx + 3 >= endIdx) {
+          break;
+        }
+        heap[outIdx++] = 240 | (u >> 18);
+        heap[outIdx++] = 128 | ((u >> 12) & 63);
+        heap[outIdx++] = 128 | ((u >> 6) & 63);
+        heap[outIdx++] = 128 | (u & 63);
+      }
+    }
+    heap[outIdx] = 0;
+    return outIdx - startIdx;
+  }
+
+  function stringToUTF8(str, outPtr, maxBytesToWrite) {
+    return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+  }
+
+  function lengthBytesUTF8(str) {
+    var len = 0;
+    for (var i = 0; i < str.length; ++i) {
+      var u = str.charCodeAt(i);
+      if (u >= 55296 && u <= 57343) {
+        u = (65536 + ((u & 1023) << 10)) | (str.charCodeAt(++i) & 1023);
+      }
+      if (u <= 127) {
+        ++len;
+      } else if (u <= 2047) {
+        len += 2;
+      } else if (u <= 65535) {
+        len += 3;
+      } else {
+        len += 4;
+      }
+    }
+    return len;
+  }
+
+  var UTF16Decoder =
+    typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : undefined;
+
+  function UTF16ToString(ptr, maxBytesToRead) {
+    var endPtr = ptr;
+    var idx = endPtr >> 1;
+    var maxIdx = idx + maxBytesToRead / 2;
+    while (!(idx >= maxIdx) && HEAPU16[idx]) {
+      ++idx;
+    }
+    endPtr = idx << 1;
+    if (endPtr - ptr > 32 && UTF16Decoder) {
+      return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
+    }
+    var str = "";
+    for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
+      var codeUnit = HEAP16[(ptr + i * 2) >> 1];
+      if (codeUnit == 0) {
+        break;
+      }
+      str += String.fromCharCode(codeUnit);
+    }
+    return str;
+  }
+
+  function stringToUTF16(str, outPtr, maxBytesToWrite) {
+    if (maxBytesToWrite === undefined) {
+      maxBytesToWrite = 2147483647;
+    }
+    if (maxBytesToWrite < 2) {
+      return 0;
+    }
+    maxBytesToWrite -= 2;
+    var startPtr = outPtr;
+    var numCharsToWrite =
+      maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+    for (var i = 0; i < numCharsToWrite; ++i) {
+      var codeUnit = str.charCodeAt(i);
+      HEAP16[outPtr >> 1] = codeUnit;
+      outPtr += 2;
+    }
+    HEAP16[outPtr >> 1] = 0;
+    return outPtr - startPtr;
+  }
+
+  function lengthBytesUTF16(str) {
+    return str.length * 2;
+  }
+
+  function UTF32ToString(ptr, maxBytesToRead) {
+    var i = 0;
+    var str = "";
+    while (!(i >= maxBytesToRead / 4)) {
+      var utf32 = HEAP32[(ptr + i * 4) >> 2];
+      if (utf32 == 0) {
+        break;
+      }
+      ++i;
+      if (utf32 >= 65536) {
+        var ch = utf32 - 65536;
+        str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
+      } else {
+        str += String.fromCharCode(utf32);
+      }
+    }
+    return str;
+  }
+
+  function stringToUTF32(str, outPtr, maxBytesToWrite) {
+    if (maxBytesToWrite === undefined) {
+      maxBytesToWrite = 2147483647;
+    }
+    if (maxBytesToWrite < 4) {
+      return 0;
+    }
+    var startPtr = outPtr;
+    var endPtr = startPtr + maxBytesToWrite - 4;
+    for (var i = 0; i < str.length; ++i) {
+      var codeUnit = str.charCodeAt(i);
+      if (codeUnit >= 55296 && codeUnit <= 57343) {
+        var trailSurrogate = str.charCodeAt(++i);
+        codeUnit =
+          (65536 + ((codeUnit & 1023) << 10)) | (trailSurrogate & 1023);
+      }
+      HEAP32[outPtr >> 2] = codeUnit;
+      outPtr += 4;
+      if (outPtr + 4 > endPtr) {
+        break;
+      }
+    }
+    HEAP32[outPtr >> 2] = 0;
+    return outPtr - startPtr;
+  }
+
+  function lengthBytesUTF32(str) {
+    var len = 0;
+    for (var i = 0; i < str.length; ++i) {
+      var codeUnit = str.charCodeAt(i);
+      if (codeUnit >= 55296 && codeUnit <= 57343) {
+        ++i;
+      }
+      len += 4;
+    }
+    return len;
+  }
+
+  function allocateUTF8(str) {
+    var size = lengthBytesUTF8(str) + 1;
+    var ret = _malloc(size);
+    if (ret) {
+      stringToUTF8Array(str, HEAP8, ret, size);
+    }
+    return ret;
+  }
+
+  function writeArrayToMemory(array, buffer) {
+    HEAP8.set(array, buffer);
+  }
+
+  function writeAsciiToMemory(str, buffer, dontAddNull) {
+    for (var i = 0; i < str.length; ++i) {
+      HEAP8[buffer++ >> 0] = str.charCodeAt(i);
+    }
+    if (!dontAddNull) {
+      HEAP8[buffer >> 0] = 0;
+    }
+  }
+
+  var buffer, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+
+  function updateGlobalBufferAndViews(buf) {
+    const mb = (buf.byteLength / 1_000_000).toFixed();
+    Module.print(`Growing wasm buffer to ${mb}MB (${buf.byteLength} bytes).`);
+
+    buffer = buf;
+    Module.HEAP8 = HEAP8 = new Int8Array(buf);
+    Module.HEAP16 = HEAP16 = new Int16Array(buf);
+    Module.HEAP32 = HEAP32 = new Int32Array(buf);
+    Module.HEAPU8 = HEAPU8 = new Uint8Array(buf);
+    Module.HEAPU16 = HEAPU16 = new Uint16Array(buf);
+    Module.HEAPU32 = HEAPU32 = new Uint32Array(buf);
+    Module.HEAPF32 = HEAPF32 = new Float32Array(buf);
+    Module.HEAPF64 = HEAPF64 = new Float64Array(buf);
+  }
+
+  var INITIAL_MEMORY = Module.INITIAL_MEMORY || 16777216;
+
+  if (Module.wasmMemory) {
+    wasmMemory = Module.wasmMemory;
+  } else {
+    wasmMemory = new WebAssembly.Memory({
+      initial: INITIAL_MEMORY / 65536,
+      maximum: 2147483648 / 65536,
+    });
+  }
+
+  if (wasmMemory) {
+    buffer = wasmMemory.buffer;
+  }
+
+  INITIAL_MEMORY = buffer.byteLength;
+
+  updateGlobalBufferAndViews(buffer);
+
+  var wasmTable;
+
+  var __ATPRERUN__ = [];
+
+  var __ATINIT__ = [];
+
+  var __ATPOSTRUN__ = [];
+
+  var runtimeInitialized = false;
+
+  function keepRuntimeAlive() {
+    return noExitRuntime;
+  }
+
+  function preRun() {
+    if (Module.preRun) {
+      if (typeof Module.preRun == "function") {
+        Module.preRun = [Module.preRun];
+      }
+      while (Module.preRun.length) {
+        addOnPreRun(Module.preRun.shift());
+      }
+    }
+    callRuntimeCallbacks(__ATPRERUN__);
+  }
+
+  function initRuntime() {
+    runtimeInitialized = true;
+    callRuntimeCallbacks(__ATINIT__);
+  }
+
+  function postRun() {
+    if (Module.postRun) {
+      if (typeof Module.postRun == "function") {
+        Module.postRun = [Module.postRun];
+      }
+      while (Module.postRun.length) {
+        addOnPostRun(Module.postRun.shift());
+      }
+    }
+    callRuntimeCallbacks(__ATPOSTRUN__);
+  }
+
+  function addOnPreRun(cb) {
+    __ATPRERUN__.unshift(cb);
+  }
+
+  function addOnInit(cb) {
+    __ATINIT__.unshift(cb);
+  }
+
+  function addOnPostRun(cb) {
+    __ATPOSTRUN__.unshift(cb);
+  }
+
+  var runDependencies = 0;
+
+  var runDependencyWatcher = null;
+
+  var dependenciesFulfilled = null;
+
+  function addRunDependency(id) {
+    runDependencies++;
+    if (Module.monitorRunDependencies) {
+      Module.monitorRunDependencies(runDependencies);
+    }
+  }
+
+  function removeRunDependency(id) {
+    runDependencies--;
+    if (Module.monitorRunDependencies) {
+      Module.monitorRunDependencies(runDependencies);
+    }
+    if (runDependencies == 0) {
+      if (runDependencyWatcher !== null) {
+        clearInterval(runDependencyWatcher);
+        runDependencyWatcher = null;
+      }
+      if (dependenciesFulfilled) {
+        var callback = dependenciesFulfilled;
+        dependenciesFulfilled = null;
+        callback();
+      }
+    }
+  }
+
+  Module.preloadedImages = {};
+
+  Module.preloadedAudios = {};
+
+  function abort(what) {
+    {
+      if (Module.onAbort) {
+        Module.onAbort(what);
+      }
+    }
+    what = "Aborted(" + what + ")";
+    err(what);
+    ABORT = true;
+    EXITSTATUS = 1;
+    what += ". Build with -s ASSERTIONS=1 for more info.";
+    var e = new WebAssembly.RuntimeError(what);
+    throw e;
+  }
+
+  var dataURIPrefix = "data:application/octet-stream;base64,";
+
+  function isDataURI(filename) {
+    return filename.startsWith(dataURIPrefix);
+  }
+
+  var wasmBinaryFile;
+
+  wasmBinaryFile = "bergamot-translator-worker.wasm";
+
+  if (!isDataURI(wasmBinaryFile)) {
+    wasmBinaryFile = locateFile(wasmBinaryFile);
+  }
+
+  function getBinary(file) {
+    try {
+      if (file == wasmBinaryFile && wasmBinary) {
+        return new Uint8Array(wasmBinary);
+      }
+      if (readBinary) {
+        return readBinary(file);
+      }
+      throw "both async and sync fetching of the wasm failed";
+    } catch (err) {
+      abort(err);
+    }
+  }
+
+  function getBinaryPromise() {
+    if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+      if (typeof fetch == "function") {
+        return fetch(wasmBinaryFile, {
+          credentials: "same-origin",
+        })
+          .then(function (response) {
+            if (!response.ok) {
+              throw (
+                "failed to load wasm binary file at '" + wasmBinaryFile + "'"
+              );
+            }
+            return response.arrayBuffer();
+          })
+          .catch(function () {
+            return getBinary(wasmBinaryFile);
+          });
+      }
+    }
+    return Promise.resolve().then(function () {
+      return getBinary(wasmBinaryFile);
+    });
+  }
+
+  function createWasm() {
+    var info = {
+      env: asmLibraryArg,
+      wasm_gemm: createWasmGemm(),
+      wasi_snapshot_preview1: asmLibraryArg,
+    };
+    function receiveInstance(instance, module) {
+      var exports = instance.exports;
+      Module.asm = exports;
+      wasmTable = Module.asm.__indirect_function_table;
+      addOnInit(Module.asm.__wasm_call_ctors);
+      exportAsmFunctions(exports);
+      removeRunDependency("wasm-instantiate");
+    }
+    addRunDependency("wasm-instantiate");
+    function receiveInstantiationResult(result) {
+      receiveInstance(result.instance);
+    }
+    function instantiateArrayBuffer(receiver) {
+      return getBinaryPromise()
+        .then(function (binary) {
+          return WebAssembly.instantiate(binary, info);
+        })
+        .then(function (instance) {
+          return instance;
+        })
+        .then(receiver, function (reason) {
+          err("failed to asynchronously prepare wasm: " + reason);
+          abort(reason);
+        });
+    }
+    function instantiateAsync() {
+      if (
+        !wasmBinary &&
+        typeof WebAssembly.instantiateStreaming == "function" &&
+        !isDataURI(wasmBinaryFile) &&
+        typeof fetch == "function"
+      ) {
+        return fetch(wasmBinaryFile, {
+          credentials: "same-origin",
+        }).then(function (response) {
+          var result = WebAssembly.instantiateStreaming(response, info);
+          return result.then(receiveInstantiationResult, function (reason) {
+            err("wasm streaming compile failed: " + reason);
+            err("falling back to ArrayBuffer instantiation");
+            return instantiateArrayBuffer(receiveInstantiationResult);
+          });
+        });
+      }
+      return instantiateArrayBuffer(receiveInstantiationResult);
+    }
+    if (Module.instantiateWasm) {
+      try {
+        var exports = Module.instantiateWasm(info, receiveInstance);
+        return exports;
+      } catch (e) {
+        err("Module.instantiateWasm callback failed with error: " + e);
+        return false;
+      }
+    }
+    instantiateAsync();
+    return {};
+  }
+
+  function callRuntimeCallbacks(callbacks) {
+    while (callbacks.length) {
+      var callback = callbacks.shift();
+      if (typeof callback == "function") {
+        callback(Module);
+        continue;
+      }
+      var func = callback.func;
+      if (typeof func == "number") {
+        if (callback.arg === undefined) {
+          getWasmTableEntry(func)();
+        } else {
+          getWasmTableEntry(func)(callback.arg);
+        }
+      } else {
+        func(callback.arg === undefined ? null : callback.arg);
+      }
+    }
+  }
+
+  function asmjsMangle(x) {
+    var unmangledSymbols = ["stackAlloc", "stackSave", "stackRestore"];
+    return x.indexOf("dynCall_") == 0 || unmangledSymbols.includes(x)
+      ? x
+      : "_" + x;
+  }
+
+  function exportAsmFunctions(asm) {
+    var global_object = this;
+    for (var __exportedFunc in asm) {
+      var jsname = asmjsMangle(__exportedFunc);
+      global_object[jsname] = Module[jsname] = asm[__exportedFunc];
+    }
+  }
+
+  var wasmTableMirror = [];
+
+  function getWasmTableEntry(funcPtr) {
+    var func = wasmTableMirror[funcPtr];
+    if (!func) {
+      if (funcPtr >= wasmTableMirror.length) {
+        wasmTableMirror.length = funcPtr + 1;
+      }
+      wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+    }
+    return func;
+  }
+
+  function ___assert_fail(condition, filename, line, func) {
+    abort(
+      "Assertion failed: " +
+        UTF8ToString(condition) +
+        ", at: " +
+        [
+          filename ? UTF8ToString(filename) : "unknown filename",
+          line,
+          func ? UTF8ToString(func) : "unknown function",
+        ]
+    );
+  }
+
+  function ___cxa_allocate_exception(size) {
+    return _malloc(size + 16) + 16;
+  }
+
+  var exceptionCaught = [];
+
+  var exceptionLast = 0;
+
+  var uncaughtExceptionCount = 0;
+
+  function ___cxa_rethrow() {
+    var catchInfo = exceptionCaught.pop();
+    if (!catchInfo) {
+      abort("no exception to throw");
+    }
+    var info = catchInfo.get_exception_info();
+    var ptr = catchInfo.get_base_ptr();
+    if (!info.get_rethrown()) {
+      exceptionCaught.push(catchInfo);
+      info.set_rethrown(true);
+      info.set_caught(false);
+      uncaughtExceptionCount++;
+    } else {
+      catchInfo.free();
+    }
+    exceptionLast = ptr;
+    throw ptr;
+  }
+
+  function ExceptionInfo(excPtr) {
+    this.excPtr = excPtr;
+    this.ptr = excPtr - 16;
+    this.set_type = function (type) {
+      HEAP32[(this.ptr + 4) >> 2] = type;
+    };
+    this.get_type = function () {
+      return HEAP32[(this.ptr + 4) >> 2];
+    };
+    this.set_destructor = function (destructor) {
+      HEAP32[(this.ptr + 8) >> 2] = destructor;
+    };
+    this.get_destructor = function () {
+      return HEAP32[(this.ptr + 8) >> 2];
+    };
+    this.set_refcount = function (refcount) {
+      HEAP32[this.ptr >> 2] = refcount;
+    };
+    this.set_caught = function (caught) {
+      caught = caught ? 1 : 0;
+      HEAP8[(this.ptr + 12) >> 0] = caught;
+    };
+    this.get_caught = function () {
+      return HEAP8[(this.ptr + 12) >> 0] != 0;
+    };
+    this.set_rethrown = function (rethrown) {
+      rethrown = rethrown ? 1 : 0;
+      HEAP8[(this.ptr + 13) >> 0] = rethrown;
+    };
+    this.get_rethrown = function () {
+      return HEAP8[(this.ptr + 13) >> 0] != 0;
+    };
+    this.init = function (type, destructor) {
+      this.set_type(type);
+      this.set_destructor(destructor);
+      this.set_refcount(0);
+      this.set_caught(false);
+      this.set_rethrown(false);
+    };
+    this.add_ref = function () {
+      var value = HEAP32[this.ptr >> 2];
+      HEAP32[this.ptr >> 2] = value + 1;
+    };
+    this.release_ref = function () {
+      var prev = HEAP32[this.ptr >> 2];
+      HEAP32[this.ptr >> 2] = prev - 1;
+      return prev === 1;
+    };
+  }
+
+  function ___cxa_throw(ptr, type, destructor) {
+    var info = new ExceptionInfo(ptr);
+    info.init(type, destructor);
+    exceptionLast = ptr;
+    uncaughtExceptionCount++;
+    throw ptr;
+  }
+
+  var SYSCALLS = {
+    buffers: [null, [], []],
+    printChar(stream, curr) {
+      var buffer = SYSCALLS.buffers[stream];
+      if (curr === 0 || curr === 10) {
+        (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
+        buffer.length = 0;
+      } else {
+        buffer.push(curr);
+      }
+    },
+    varargs: undefined,
+    get() {
+      SYSCALLS.varargs += 4;
+      var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
+      return ret;
+    },
+    getStr(ptr) {
+      var ret = UTF8ToString(ptr);
+      return ret;
+    },
+    get64(low, high) {
+      return low;
+    },
+  };
+
+  function ___syscall_faccessat(dirfd, path, amode, flags) {
+    path = SYSCALLS.getStr(path);
+    path = SYSCALLS.calculateAt(dirfd, path);
+    return SYSCALLS.doAccess(path, amode);
+  }
+
+  function ___syscall_fcntl64(fd, cmd, varargs) {
+    SYSCALLS.varargs = varargs;
+    return 0;
+  }
+
+  function ___syscall_fstat64(fd, buf) {}
+
+  function ___syscall_getcwd(buf, size) {}
+
+  function ___syscall_ioctl(fd, op, varargs) {
+    SYSCALLS.varargs = varargs;
+    return 0;
+  }
+
+  function ___syscall_lstat64(path, buf) {}
+
+  function ___syscall_newfstatat(dirfd, path, buf, flags) {}
+
+  function ___syscall_openat(dirfd, path, flags, varargs) {
+    SYSCALLS.varargs = varargs;
+  }
+
+  function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) {}
+
+  function ___syscall_rmdir(path) {}
+
+  function ___syscall_stat64(path, buf) {}
+
+  function ___syscall_unlinkat(dirfd, path, flags) {}
+
+  var structRegistrations = {};
+
+  function runDestructors(destructors) {
+    while (destructors.length) {
+      var ptr = destructors.pop();
+      var del = destructors.pop();
+      del(ptr);
+    }
+  }
+
+  function simpleReadValueFromPointer(pointer) {
+    return this.fromWireType(HEAPU32[pointer >> 2]);
+  }
+
+  var awaitingDependencies = {};
+
+  var registeredTypes = {};
+
+  var typeDependencies = {};
+
+  var char_0 = 48;
+
+  var char_9 = 57;
+
+  function makeLegalFunctionName(name) {
+    if (undefined === name) {
+      return "_unknown";
+    }
+    name = name.replace(/[^a-zA-Z0-9_]/g, "$");
+    var f = name.charCodeAt(0);
+    if (f >= char_0 && f <= char_9) {
+      return "_" + name;
+    }
+    return name;
+  }
+
+  function createNamedFunction(name, body) {
+    name = makeLegalFunctionName(name);
+    return function () {
+      null;
+      return body.apply(this, arguments);
+    };
+  }
+
+  function extendError(baseErrorType, errorName) {
+    var errorClass = createNamedFunction(errorName, function (message) {
+      this.name = errorName;
+      this.message = message;
+      var stack = new Error(message).stack;
+      if (stack !== undefined) {
+        this.stack =
+          this.toString() + "\n" + stack.replace(/^Error(:[^\n]*)?\n/, "");
+      }
+    });
+    errorClass.prototype = Object.create(baseErrorType.prototype);
+    errorClass.prototype.constructor = errorClass;
+    errorClass.prototype.toString = function () {
+      if (this.message === undefined) {
+        return this.name;
+      }
+      return this.name + ": " + this.message;
+    };
+    return errorClass;
+  }
+
+  var InternalError = undefined;
+
+  function throwInternalError(message) {
+    throw new InternalError(message);
+  }
+
+  function whenDependentTypesAreResolved(
+    myTypes,
+    dependentTypes,
+    getTypeConverters
+  ) {
+    myTypes.forEach(function (type) {
+      typeDependencies[type] = dependentTypes;
+    });
+    function onComplete(typeConverters) {
+      var myTypeConverters = getTypeConverters(typeConverters);
+      if (myTypeConverters.length !== myTypes.length) {
+        throwInternalError("Mismatched type converter count");
+      }
+      for (var i = 0; i < myTypes.length; ++i) {
+        registerType(myTypes[i], myTypeConverters[i]);
+      }
+    }
+    var typeConverters = new Array(dependentTypes.length);
+    var unregisteredTypes = [];
+    var registered = 0;
+    dependentTypes.forEach((dt, i) => {
+      if (registeredTypes.hasOwnProperty(dt)) {
+        typeConverters[i] = registeredTypes[dt];
+      } else {
+        unregisteredTypes.push(dt);
+        if (!awaitingDependencies.hasOwnProperty(dt)) {
+          awaitingDependencies[dt] = [];
+        }
+        awaitingDependencies[dt].push(() => {
+          typeConverters[i] = registeredTypes[dt];
+          ++registered;
+          if (registered === unregisteredTypes.length) {
+            onComplete(typeConverters);
+          }
+        });
+      }
+    });
+    if (0 === unregisteredTypes.length) {
+      onComplete(typeConverters);
+    }
+  }
+
+  function __embind_finalize_value_object(structType) {
+    var reg = structRegistrations[structType];
+    delete structRegistrations[structType];
+    var rawConstructor = reg.rawConstructor;
+    var rawDestructor = reg.rawDestructor;
+    var fieldRecords = reg.fields;
+    var fieldTypes = fieldRecords
+      .map(field => field.getterReturnType)
+      .concat(fieldRecords.map(field => field.setterArgumentType));
+    whenDependentTypesAreResolved([structType], fieldTypes, fieldTypes => {
+      var fields = {};
+      fieldRecords.forEach((field, i) => {
+        var fieldName = field.fieldName;
+        var getterReturnType = fieldTypes[i];
+        var getter = field.getter;
+        var getterContext = field.getterContext;
+        var setterArgumentType = fieldTypes[i + fieldRecords.length];
+        var setter = field.setter;
+        var setterContext = field.setterContext;
+        fields[fieldName] = {
+          read: ptr => {
+            return getterReturnType.fromWireType(getter(getterContext, ptr));
+          },
+          write: (ptr, o) => {
+            var destructors = [];
+            setter(
+              setterContext,
+              ptr,
+              setterArgumentType.toWireType(destructors, o)
+            );
+            runDestructors(destructors);
+          },
+        };
+      });
+      return [
+        {
+          name: reg.name,
+          fromWireType: function (ptr) {
+            var rv = {};
+            for (var i in fields) {
+              rv[i] = fields[i].read(ptr);
+            }
+            rawDestructor(ptr);
+            return rv;
+          },
+          toWireType: function (destructors, o) {
+            for (var fieldName in fields) {
+              if (!(fieldName in o)) {
+                throw new TypeError('Missing field:  "' + fieldName + '"');
+              }
+            }
+            var ptr = rawConstructor();
+            for (fieldName in fields) {
+              fields[fieldName].write(ptr, o[fieldName]);
+            }
+            if (destructors !== null) {
+              destructors.push(rawDestructor, ptr);
+            }
+            return ptr;
+          },
+          argPackAdvance: 8,
+          readValueFromPointer: simpleReadValueFromPointer,
+          destructorFunction: rawDestructor,
+        },
+      ];
+    });
+  }
+
+  function __embind_register_bigint(
+    primitiveType,
+    name,
+    size,
+    minRange,
+    maxRange
+  ) {}
+
+  function getShiftFromSize(size) {
+    switch (size) {
+      case 1:
+        return 0;
+
+      case 2:
+        return 1;
+
+      case 4:
+        return 2;
+
+      case 8:
+        return 3;
+
+      default:
+        throw new TypeError("Unknown type size: " + size);
+    }
+  }
+
+  function embind_init_charCodes() {
+    var codes = new Array(256);
+    for (var i = 0; i < 256; ++i) {
+      codes[i] = String.fromCharCode(i);
+    }
+    embind_charCodes = codes;
+  }
+
+  var embind_charCodes = undefined;
+
+  function readLatin1String(ptr) {
+    var ret = "";
+    var c = ptr;
+    while (HEAPU8[c]) {
+      ret += embind_charCodes[HEAPU8[c++]];
+    }
+    return ret;
+  }
+
+  var BindingError = undefined;
+
+  function throwBindingError(message) {
+    throw new BindingError(message);
+  }
+
+  function registerType(rawType, registeredInstance, options = {}) {
+    if (!("argPackAdvance" in registeredInstance)) {
+      throw new TypeError(
+        "registerType registeredInstance requires argPackAdvance"
+      );
+    }
+    var name = registeredInstance.name;
+    if (!rawType) {
+      throwBindingError(
+        'type "' + name + '" must have a positive integer typeid pointer'
+      );
+    }
+    if (registeredTypes.hasOwnProperty(rawType)) {
+      if (options.ignoreDuplicateRegistrations) {
+        return;
+      }
+      throwBindingError("Cannot register type '" + name + "' twice");
+    }
+    registeredTypes[rawType] = registeredInstance;
+    delete typeDependencies[rawType];
+    if (awaitingDependencies.hasOwnProperty(rawType)) {
+      var callbacks = awaitingDependencies[rawType];
+      delete awaitingDependencies[rawType];
+      callbacks.forEach(cb => cb());
+    }
+  }
+
+  function __embind_register_bool(rawType, name, size, trueValue, falseValue) {
+    var shift = getShiftFromSize(size);
+    name = readLatin1String(name);
+    registerType(rawType, {
+      name,
+      fromWireType: function (wt) {
+        return !!wt;
+      },
+      toWireType: function (destructors, o) {
+        return o ? trueValue : falseValue;
+      },
+      argPackAdvance: 8,
+      readValueFromPointer: function (pointer) {
+        var heap;
+        if (size === 1) {
+          heap = HEAP8;
+        } else if (size === 2) {
+          heap = HEAP16;
+        } else if (size === 4) {
+          heap = HEAP32;
+        } else {
+          throw new TypeError("Unknown boolean type size: " + name);
+        }
+        return this.fromWireType(heap[pointer >> shift]);
+      },
+      destructorFunction: null,
+    });
+  }
+
+  function ClassHandle_isAliasOf(other) {
+    if (!(this instanceof ClassHandle)) {
+      return false;
+    }
+    if (!(other instanceof ClassHandle)) {
+      return false;
+    }
+    var leftClass = this.$$.ptrType.registeredClass;
+    var left = this.$$.ptr;
+    var rightClass = other.$$.ptrType.registeredClass;
+    var right = other.$$.ptr;
+    while (leftClass.baseClass) {
+      left = leftClass.upcast(left);
+      leftClass = leftClass.baseClass;
+    }
+    while (rightClass.baseClass) {
+      right = rightClass.upcast(right);
+      rightClass = rightClass.baseClass;
+    }
+    return leftClass === rightClass && left === right;
+  }
+
+  function shallowCopyInternalPointer(o) {
+    return {
+      count: o.count,
+      deleteScheduled: o.deleteScheduled,
+      preservePointerOnDelete: o.preservePointerOnDelete,
+      ptr: o.ptr,
+      ptrType: o.ptrType,
+      smartPtr: o.smartPtr,
+      smartPtrType: o.smartPtrType,
+    };
+  }
+
+  function throwInstanceAlreadyDeleted(obj) {
+    function getInstanceTypeName(handle) {
+      return handle.$$.ptrType.registeredClass.name;
+    }
+    throwBindingError(getInstanceTypeName(obj) + " instance already deleted");
+  }
+
+  var finalizationRegistry = false;
+
+  function detachFinalizer(handle) {}
+
+  function runDestructor($$) {
+    if ($$.smartPtr) {
+      $$.smartPtrType.rawDestructor($$.smartPtr);
+    } else {
+      $$.ptrType.registeredClass.rawDestructor($$.ptr);
+    }
+  }
+
+  function releaseClassHandle($$) {
+    $$.count.value -= 1;
+    var toDelete = 0 === $$.count.value;
+    if (toDelete) {
+      runDestructor($$);
+    }
+  }
+
+  function downcastPointer(ptr, ptrClass, desiredClass) {
+    if (ptrClass === desiredClass) {
+      return ptr;
+    }
+    if (undefined === desiredClass.baseClass) {
+      return null;
+    }
+    var rv = downcastPointer(ptr, ptrClass, desiredClass.baseClass);
+    if (rv === null) {
+      return null;
+    }
+    return desiredClass.downcast(rv);
+  }
+
+  var registeredPointers = {};
+
+  function getInheritedInstanceCount() {
+    return Object.keys(registeredInstances).length;
+  }
+
+  function getLiveInheritedInstances() {
+    var rv = [];
+    for (var k in registeredInstances) {
+      if (registeredInstances.hasOwnProperty(k)) {
+        rv.push(registeredInstances[k]);
+      }
+    }
+    return rv;
+  }
+
+  var deletionQueue = [];
+
+  function flushPendingDeletes() {
+    while (deletionQueue.length) {
+      var obj = deletionQueue.pop();
+      obj.$$.deleteScheduled = false;
+      obj.delete();
+    }
+  }
+
+  var delayFunction = undefined;
+
+  function setDelayFunction(fn) {
+    delayFunction = fn;
+    if (deletionQueue.length && delayFunction) {
+      delayFunction(flushPendingDeletes);
+    }
+  }
+
+  function init_embind() {
+    Module.getInheritedInstanceCount = getInheritedInstanceCount;
+    Module.getLiveInheritedInstances = getLiveInheritedInstances;
+    Module.flushPendingDeletes = flushPendingDeletes;
+    Module.setDelayFunction = setDelayFunction;
+  }
+
+  var registeredInstances = {};
+
+  function getBasestPointer(class_, ptr) {
+    if (ptr === undefined) {
+      throwBindingError("ptr should not be undefined");
+    }
+    while (class_.baseClass) {
+      ptr = class_.upcast(ptr);
+      class_ = class_.baseClass;
+    }
+    return ptr;
+  }
+
+  function getInheritedInstance(class_, ptr) {
+    ptr = getBasestPointer(class_, ptr);
+    return registeredInstances[ptr];
+  }
+
+  function makeClassHandle(prototype, record) {
+    if (!record.ptrType || !record.ptr) {
+      throwInternalError("makeClassHandle requires ptr and ptrType");
+    }
+    var hasSmartPtrType = !!record.smartPtrType;
+    var hasSmartPtr = !!record.smartPtr;
+    if (hasSmartPtrType !== hasSmartPtr) {
+      throwInternalError("Both smartPtrType and smartPtr must be specified");
+    }
+    record.count = {
+      value: 1,
+    };
+    return attachFinalizer(
+      Object.create(prototype, {
+        $$: {
+          value: record,
+        },
+      })
+    );
+  }
+
+  function RegisteredPointer_fromWireType(ptr) {
+    var rawPointer = this.getPointee(ptr);
+    if (!rawPointer) {
+      this.destructor(ptr);
+      return null;
+    }
+    var registeredInstance = getInheritedInstance(
+      this.registeredClass,
+      rawPointer
+    );
+    if (undefined !== registeredInstance) {
+      if (0 === registeredInstance.$$.count.value) {
+        registeredInstance.$$.ptr = rawPointer;
+        registeredInstance.$$.smartPtr = ptr;
+        return registeredInstance.clone();
+      }
+      var rv = registeredInstance.clone();
+      this.destructor(ptr);
+      return rv;
+    }
+    function makeDefaultHandle() {
+      if (this.isSmartPointer) {
+        return makeClassHandle(this.registeredClass.instancePrototype, {
+          ptrType: this.pointeeType,
+          ptr: rawPointer,
+          smartPtrType: this,
+          smartPtr: ptr,
+        });
+      }
+      return makeClassHandle(this.registeredClass.instancePrototype, {
+        ptrType: this,
+        ptr,
+      });
+    }
+    var actualType = this.registeredClass.getActualType(rawPointer);
+    var registeredPointerRecord = registeredPointers[actualType];
+    if (!registeredPointerRecord) {
+      return makeDefaultHandle.call(this);
+    }
+    var toType;
+    if (this.isConst) {
+      toType = registeredPointerRecord.constPointerType;
+    } else {
+      toType = registeredPointerRecord.pointerType;
+    }
+    var dp = downcastPointer(
+      rawPointer,
+      this.registeredClass,
+      toType.registeredClass
+    );
+    if (dp === null) {
+      return makeDefaultHandle.call(this);
+    }
+    if (this.isSmartPointer) {
+      return makeClassHandle(toType.registeredClass.instancePrototype, {
+        ptrType: toType,
+        ptr: dp,
+        smartPtrType: this,
+        smartPtr: ptr,
+      });
+    }
+    return makeClassHandle(toType.registeredClass.instancePrototype, {
+      ptrType: toType,
+      ptr: dp,
+    });
+  }
+
+  function attachFinalizer(handle) {
+    if ("undefined" === typeof FinalizationRegistry) {
+      attachFinalizer = handle => handle;
+      return handle;
+    }
+    finalizationRegistry = new FinalizationRegistry(info => {
+      releaseClassHandle(info.$$);
+    });
+    attachFinalizer = handle => {
+      var $$ = handle.$$;
+      var hasSmartPtr = !!$$.smartPtr;
+      if (hasSmartPtr) {
+        var info = {
+          $$,
+        };
+        finalizationRegistry.register(handle, info, handle);
+      }
+      return handle;
+    };
+    detachFinalizer = handle => finalizationRegistry.unregister(handle);
+    return attachFinalizer(handle);
+  }
+
+  function ClassHandle_clone() {
+    if (!this.$$.ptr) {
+      throwInstanceAlreadyDeleted(this);
+    }
+    if (this.$$.preservePointerOnDelete) {
+      this.$$.count.value += 1;
+      return this;
+    }
+    var clone = attachFinalizer(
+      Object.create(Object.getPrototypeOf(this), {
+        $$: {
+          value: shallowCopyInternalPointer(this.$$),
+        },
+      })
+    );
+    clone.$$.count.value += 1;
+    clone.$$.deleteScheduled = false;
+    return clone;
+  }
+
+  function ClassHandle_delete() {
+    if (!this.$$.ptr) {
+      throwInstanceAlreadyDeleted(this);
+    }
+    if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+      throwBindingError("Object already scheduled for deletion");
+    }
+    detachFinalizer(this);
+    releaseClassHandle(this.$$);
+    if (!this.$$.preservePointerOnDelete) {
+      this.$$.smartPtr = undefined;
+      this.$$.ptr = undefined;
+    }
+  }
+
+  function ClassHandle_isDeleted() {
+    return !this.$$.ptr;
+  }
+
+  function ClassHandle_deleteLater() {
+    if (!this.$$.ptr) {
+      throwInstanceAlreadyDeleted(this);
+    }
+    if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+      throwBindingError("Object already scheduled for deletion");
+    }
+    deletionQueue.push(this);
+    if (deletionQueue.length === 1 && delayFunction) {
+      delayFunction(flushPendingDeletes);
+    }
+    this.$$.deleteScheduled = true;
+    return this;
+  }
+
+  function init_ClassHandle() {
+    ClassHandle.prototype.isAliasOf = ClassHandle_isAliasOf;
+    ClassHandle.prototype.clone = ClassHandle_clone;
+    ClassHandle.prototype.delete = ClassHandle_delete;
+    ClassHandle.prototype.isDeleted = ClassHandle_isDeleted;
+    ClassHandle.prototype.deleteLater = ClassHandle_deleteLater;
+  }
+
+  function ClassHandle() {}
+
+  function ensureOverloadTable(proto, methodName, humanName) {
+    if (undefined === proto[methodName].overloadTable) {
+      var prevFunc = proto[methodName];
+      proto[methodName] = function () {
+        if (!proto[methodName].overloadTable.hasOwnProperty(arguments.length)) {
+          throwBindingError(
+            "Function '" +
+              humanName +
+              "' called with an invalid number of arguments (" +
+              arguments.length +
+              ") - expects one of (" +
+              proto[methodName].overloadTable +
+              ")!"
+          );
+        }
+        return proto[methodName].overloadTable[arguments.length].apply(
+          this,
+          arguments
+        );
+      };
+      proto[methodName].overloadTable = [];
+      proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+    }
+  }
+
+  function exposePublicSymbol(name, value, numArguments) {
+    if (Module.hasOwnProperty(name)) {
+      if (
+        undefined === numArguments ||
+        (undefined !== Module[name].overloadTable &&
+          undefined !== Module[name].overloadTable[numArguments])
+      ) {
+        throwBindingError("Cannot register public name '" + name + "' twice");
+      }
+      ensureOverloadTable(Module, name, name);
+      if (Module.hasOwnProperty(numArguments)) {
+        throwBindingError(
+          "Cannot register multiple overloads of a function with the same number of arguments (" +
+            numArguments +
+            ")!"
+        );
+      }
+      Module[name].overloadTable[numArguments] = value;
+    } else {
+      Module[name] = value;
+      if (undefined !== numArguments) {
+        Module[name].numArguments = numArguments;
+      }
+    }
+  }
+
+  function RegisteredClass(
+    name,
+    constructor,
+    instancePrototype,
+    rawDestructor,
+    baseClass,
+    getActualType,
+    upcast,
+    downcast
+  ) {
+    this.name = name;
+    this.constructor = constructor;
+    this.instancePrototype = instancePrototype;
+    this.rawDestructor = rawDestructor;
+    this.baseClass = baseClass;
+    this.getActualType = getActualType;
+    this.upcast = upcast;
+    this.downcast = downcast;
+    this.pureVirtualFunctions = [];
+  }
+
+  function upcastPointer(ptr, ptrClass, desiredClass) {
+    while (ptrClass !== desiredClass) {
+      if (!ptrClass.upcast) {
+        throwBindingError(
+          "Expected null or instance of " +
+            desiredClass.name +
+            ", got an instance of " +
+            ptrClass.name
+        );
+      }
+      ptr = ptrClass.upcast(ptr);
+      ptrClass = ptrClass.baseClass;
+    }
+    return ptr;
+  }
+
+  function constNoSmartPtrRawPointerToWireType(destructors, handle) {
+    if (handle === null) {
+      if (this.isReference) {
+        throwBindingError("null is not a valid " + this.name);
+      }
+      return 0;
+    }
+    if (!handle.$$) {
+      throwBindingError(
+        'Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name
+      );
+    }
+    if (!handle.$$.ptr) {
+      throwBindingError(
+        "Cannot pass deleted object as a pointer of type " + this.name
+      );
+    }
+    var handleClass = handle.$$.ptrType.registeredClass;
+    var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+    return ptr;
+  }
+
+  function genericPointerToWireType(destructors, handle) {
+    var ptr;
+    if (handle === null) {
+      if (this.isReference) {
+        throwBindingError("null is not a valid " + this.name);
+      }
+      if (this.isSmartPointer) {
+        ptr = this.rawConstructor();
+        if (destructors !== null) {
+          destructors.push(this.rawDestructor, ptr);
+        }
+        return ptr;
+      }
+      return 0;
+    }
+    if (!handle.$$) {
+      throwBindingError(
+        'Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name
+      );
+    }
+    if (!handle.$$.ptr) {
+      throwBindingError(
+        "Cannot pass deleted object as a pointer of type " + this.name
+      );
+    }
+    if (!this.isConst && handle.$$.ptrType.isConst) {
+      throwBindingError(
+        "Cannot convert argument of type " +
+          (handle.$$.smartPtrType
+            ? handle.$$.smartPtrType.name
+            : handle.$$.ptrType.name) +
+          " to parameter type " +
+          this.name
+      );
+    }
+    var handleClass = handle.$$.ptrType.registeredClass;
+    ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+    if (this.isSmartPointer) {
+      if (undefined === handle.$$.smartPtr) {
+        throwBindingError("Passing raw pointer to smart pointer is illegal");
+      }
+      switch (this.sharingPolicy) {
+        case 0:
+          if (handle.$$.smartPtrType === this) {
+            ptr = handle.$$.smartPtr;
+          } else {
+            throwBindingError(
+              "Cannot convert argument of type " +
+                (handle.$$.smartPtrType
+                  ? handle.$$.smartPtrType.name
+                  : handle.$$.ptrType.name) +
+                " to parameter type " +
+                this.name
+            );
+          }
+          break;
+
+        case 1:
+          ptr = handle.$$.smartPtr;
+          break;
+
+        case 2:
+          if (handle.$$.smartPtrType === this) {
+            ptr = handle.$$.smartPtr;
+          } else {
+            var clonedHandle = handle.clone();
+            ptr = this.rawShare(
+              ptr,
+              Emval.toHandle(function () {
+                clonedHandle.delete();
+              })
+            );
+            if (destructors !== null) {
+              destructors.push(this.rawDestructor, ptr);
+            }
+          }
+          break;
+
+        default:
+          throwBindingError("Unsupporting sharing policy");
+      }
+    }
+    return ptr;
+  }
+
+  function nonConstNoSmartPtrRawPointerToWireType(destructors, handle) {
+    if (handle === null) {
+      if (this.isReference) {
+        throwBindingError("null is not a valid " + this.name);
+      }
+      return 0;
+    }
+    if (!handle.$$) {
+      throwBindingError(
+        'Cannot pass "' + _embind_repr(handle) + '" as a ' + this.name
+      );
+    }
+    if (!handle.$$.ptr) {
+      throwBindingError(
+        "Cannot pass deleted object as a pointer of type " + this.name
+      );
+    }
+    if (handle.$$.ptrType.isConst) {
+      throwBindingError(
+        "Cannot convert argument of type " +
+          handle.$$.ptrType.name +
+          " to parameter type " +
+          this.name
+      );
+    }
+    var handleClass = handle.$$.ptrType.registeredClass;
+    var ptr = upcastPointer(handle.$$.ptr, handleClass, this.registeredClass);
+    return ptr;
+  }
+
+  function RegisteredPointer_getPointee(ptr) {
+    if (this.rawGetPointee) {
+      ptr = this.rawGetPointee(ptr);
+    }
+    return ptr;
+  }
+
+  function RegisteredPointer_destructor(ptr) {
+    if (this.rawDestructor) {
+      this.rawDestructor(ptr);
+    }
+  }
+
+  function RegisteredPointer_deleteObject(handle) {
+    if (handle !== null) {
+      handle.delete();
+    }
+  }
+
+  function init_RegisteredPointer() {
+    RegisteredPointer.prototype.getPointee = RegisteredPointer_getPointee;
+    RegisteredPointer.prototype.destructor = RegisteredPointer_destructor;
+    RegisteredPointer.prototype.argPackAdvance = 8;
+    RegisteredPointer.prototype.readValueFromPointer =
+      simpleReadValueFromPointer;
+    RegisteredPointer.prototype.deleteObject = RegisteredPointer_deleteObject;
+    RegisteredPointer.prototype.fromWireType = RegisteredPointer_fromWireType;
+  }
+
+  function RegisteredPointer(
+    name,
+    registeredClass,
+    isReference,
+    isConst,
+    isSmartPointer,
+    pointeeType,
+    sharingPolicy,
+    rawGetPointee,
+    rawConstructor,
+    rawShare,
+    rawDestructor
+  ) {
+    this.name = name;
+    this.registeredClass = registeredClass;
+    this.isReference = isReference;
+    this.isConst = isConst;
+    this.isSmartPointer = isSmartPointer;
+    this.pointeeType = pointeeType;
+    this.sharingPolicy = sharingPolicy;
+    this.rawGetPointee = rawGetPointee;
+    this.rawConstructor = rawConstructor;
+    this.rawShare = rawShare;
+    this.rawDestructor = rawDestructor;
+    if (!isSmartPointer && registeredClass.baseClass === undefined) {
+      if (isConst) {
+        this.toWireType = constNoSmartPtrRawPointerToWireType;
+        this.destructorFunction = null;
+      } else {
+        this.toWireType = nonConstNoSmartPtrRawPointerToWireType;
+        this.destructorFunction = null;
+      }
+    } else {
+      this.toWireType = genericPointerToWireType;
+    }
+  }
+
+  function replacePublicSymbol(name, value, numArguments) {
+    if (!Module.hasOwnProperty(name)) {
+      throwInternalError("Replacing nonexistant public symbol");
+    }
+    if (
+      undefined !== Module[name].overloadTable &&
+      undefined !== numArguments
+    ) {
+      Module[name].overloadTable[numArguments] = value;
+    } else {
+      Module[name] = value;
+      Module[name].argCount = numArguments;
+    }
+  }
+
+  function dynCallLegacy(sig, ptr, args) {
+    var f = Module["dynCall_" + sig];
+    return args && args.length
+      ? f.apply(null, [ptr].concat(args))
+      : f.call(null, ptr);
+  }
+
+  function dynCall(sig, ptr, args) {
+    if (sig.includes("j")) {
+      return dynCallLegacy(sig, ptr, args);
+    }
+    return getWasmTableEntry(ptr).apply(null, args);
+  }
+
+  function getDynCaller(sig, ptr) {
+    var argCache = [];
+    return function () {
+      argCache.length = 0;
+      Object.assign(argCache, arguments);
+      return dynCall(sig, ptr, argCache);
+    };
+  }
+
+  function embind__requireFunction(signature, rawFunction) {
+    signature = readLatin1String(signature);
+    function makeDynCaller() {
+      if (signature.includes("j")) {
+        return getDynCaller(signature, rawFunction);
+      }
+      return getWasmTableEntry(rawFunction);
+    }
+    var fp = makeDynCaller();
+    if (typeof fp != "function") {
+      throwBindingError(
+        "unknown function pointer with signature " +
+          signature +
+          ": " +
+          rawFunction
+      );
+    }
+    return fp;
+  }
+
+  var UnboundTypeError = undefined;
+
+  function getTypeName(type) {
+    var ptr = ___getTypeName(type);
+    var rv = readLatin1String(ptr);
+    _free(ptr);
+    return rv;
+  }
+
+  function throwUnboundTypeError(message, types) {
+    var unboundTypes = [];
+    var seen = {};
+    function visit(type) {
+      if (seen[type]) {
+        return;
+      }
+      if (registeredTypes[type]) {
+        return;
+      }
+      if (typeDependencies[type]) {
+        typeDependencies[type].forEach(visit);
+        return;
+      }
+      unboundTypes.push(type);
+      seen[type] = true;
+    }
+    types.forEach(visit);
+    throw new UnboundTypeError(
+      message + ": " + unboundTypes.map(getTypeName).join([", "])
+    );
+  }
+
+  function __embind_register_class(
+    rawType,
+    rawPointerType,
+    rawConstPointerType,
+    baseClassRawType,
+    getActualTypeSignature,
+    getActualType,
+    upcastSignature,
+    upcast,
+    downcastSignature,
+    downcast,
+    name,
+    destructorSignature,
+    rawDestructor
+  ) {
+    name = readLatin1String(name);
+    getActualType = embind__requireFunction(
+      getActualTypeSignature,
+      getActualType
+    );
+    if (upcast) {
+      upcast = embind__requireFunction(upcastSignature, upcast);
+    }
+    if (downcast) {
+      downcast = embind__requireFunction(downcastSignature, downcast);
+    }
+    rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
+    var legalFunctionName = makeLegalFunctionName(name);
+    exposePublicSymbol(legalFunctionName, function () {
+      throwUnboundTypeError(
+        "Cannot construct " + name + " due to unbound types",
+        [baseClassRawType]
+      );
+    });
+    whenDependentTypesAreResolved(
+      [rawType, rawPointerType, rawConstPointerType],
+      baseClassRawType ? [baseClassRawType] : [],
+      function (base) {
+        base = base[0];
+        var baseClass;
+        var basePrototype;
+        if (baseClassRawType) {
+          baseClass = base.registeredClass;
+          basePrototype = baseClass.instancePrototype;
+        } else {
+          basePrototype = ClassHandle.prototype;
+        }
+        var constructor = createNamedFunction(legalFunctionName, function () {
+          if (Object.getPrototypeOf(this) !== instancePrototype) {
+            throw new BindingError("Use 'new' to construct " + name);
+          }
+          if (undefined === registeredClass.constructor_body) {
+            throw new BindingError(name + " has no accessible constructor");
+          }
+          var body = registeredClass.constructor_body[arguments.length];
+          if (undefined === body) {
+            throw new BindingError(
+              "Tried to invoke ctor of " +
+                name +
+                " with invalid number of parameters (" +
+                arguments.length +
+                ") - expected (" +
+                Object.keys(registeredClass.constructor_body).toString() +
+                ") parameters instead!"
+            );
+          }
+          return body.apply(this, arguments);
+        });
+        var instancePrototype = Object.create(basePrototype, {
+          constructor: {
+            value: constructor,
+          },
+        });
+        constructor.prototype = instancePrototype;
+        var registeredClass = new RegisteredClass(
+          name,
+          constructor,
+          instancePrototype,
+          rawDestructor,
+          baseClass,
+          getActualType,
+          upcast,
+          downcast
+        );
+        var referenceConverter = new RegisteredPointer(
+          name,
+          registeredClass,
+          true,
+          false,
+          false
+        );
+        var pointerConverter = new RegisteredPointer(
+          name + "*",
+          registeredClass,
+          false,
+          false,
+          false
+        );
+        var constPointerConverter = new RegisteredPointer(
+          name + " const*",
+          registeredClass,
+          false,
+          true,
+          false
+        );
+        registeredPointers[rawType] = {
+          pointerType: pointerConverter,
+          constPointerType: constPointerConverter,
+        };
+        replacePublicSymbol(legalFunctionName, constructor);
+        return [referenceConverter, pointerConverter, constPointerConverter];
+      }
+    );
+  }
+
+  function heap32VectorToArray(count, firstElement) {
+    var array = [];
+    for (var i = 0; i < count; i++) {
+      array.push(HEAP32[(firstElement >> 2) + i]);
+    }
+    return array;
+  }
+
+  function __embind_register_class_constructor(
+    rawClassType,
+    argCount,
+    rawArgTypesAddr,
+    invokerSignature,
+    invoker,
+    rawConstructor
+  ) {
+    assert(argCount > 0);
+    var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+    invoker = embind__requireFunction(invokerSignature, invoker);
+    whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+      classType = classType[0];
+      var humanName = "constructor " + classType.name;
+      if (undefined === classType.registeredClass.constructor_body) {
+        classType.registeredClass.constructor_body = [];
+      }
+      if (
+        undefined !== classType.registeredClass.constructor_body[argCount - 1]
+      ) {
+        throw new BindingError(
+          "Cannot register multiple constructors with identical number of parameters (" +
+            (argCount - 1) +
+            ") for class '" +
+            classType.name +
+            "'! Overload resolution is currently only performed using the parameter count, not actual type info!"
+        );
+      }
+      classType.registeredClass.constructor_body[argCount - 1] = () => {
+        throwUnboundTypeError(
+          "Cannot construct " + classType.name + " due to unbound types",
+          rawArgTypes
+        );
+      };
+      whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+        argTypes.splice(1, 0, null);
+        classType.registeredClass.constructor_body[argCount - 1] =
+          craftInvokerFunction(
+            humanName,
+            argTypes,
+            null,
+            invoker,
+            rawConstructor
+          );
+        return [];
+      });
+      return [];
+    });
+  }
+
+  function craftInvokerFunction(
+    humanName,
+    argTypes,
+    classType,
+    cppInvokerFunc,
+    cppTargetFunc
+  ) {
+    var argCount = argTypes.length;
+    if (argCount < 2) {
+      throwBindingError(
+        "argTypes array size mismatch! Must at least get return value and 'this' types!"
+      );
+    }
+    var isClassMethodFunc = argTypes[1] !== null && classType !== null;
+    var needsDestructorStack = false;
+    for (var i = 1; i < argTypes.length; ++i) {
+      if (
+        argTypes[i] !== null &&
+        argTypes[i].destructorFunction === undefined
+      ) {
+        needsDestructorStack = true;
+        break;
+      }
+    }
+    var returns = argTypes[0].name !== "void";
+    var expectedArgCount = argCount - 2;
+    var argsWired = new Array(expectedArgCount);
+    var invokerFuncArgs = [];
+    var destructors = [];
+    return function () {
+      if (arguments.length !== expectedArgCount) {
+        throwBindingError(
+          "function " +
+            humanName +
+            " called with " +
+            arguments.length +
+            " arguments, expected " +
+            expectedArgCount +
+            " args!"
+        );
+      }
+      destructors.length = 0;
+      var thisWired;
+      invokerFuncArgs.length = isClassMethodFunc ? 2 : 1;
+      invokerFuncArgs[0] = cppTargetFunc;
+      if (isClassMethodFunc) {
+        thisWired = argTypes[1].toWireType(destructors, this);
+        invokerFuncArgs[1] = thisWired;
+      }
+      for (var i = 0; i < expectedArgCount; ++i) {
+        argsWired[i] = argTypes[i + 2].toWireType(destructors, arguments[i]);
+        invokerFuncArgs.push(argsWired[i]);
+      }
+      var rv = cppInvokerFunc.apply(null, invokerFuncArgs);
+      function onDone(rv) {
+        if (needsDestructorStack) {
+          runDestructors(destructors);
+        } else {
+          for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; i++) {
+            var param = i === 1 ? thisWired : argsWired[i - 2];
+            if (argTypes[i].destructorFunction !== null) {
+              argTypes[i].destructorFunction(param);
+            }
+          }
+        }
+        if (returns) {
+          return argTypes[0].fromWireType(rv);
+        }
+      }
+      return onDone(rv);
+    };
+  }
+
+  function __embind_register_class_function(
+    rawClassType,
+    methodName,
+    argCount,
+    rawArgTypesAddr,
+    invokerSignature,
+    rawInvoker,
+    context,
+    isPureVirtual
+  ) {
+    var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+    methodName = readLatin1String(methodName);
+    rawInvoker = embind__requireFunction(invokerSignature, rawInvoker);
+    whenDependentTypesAreResolved([], [rawClassType], function (classType) {
+      classType = classType[0];
+      var humanName = classType.name + "." + methodName;
+      if (methodName.startsWith("@@")) {
+        methodName = Symbol[methodName.substring(2)];
+      }
+      if (isPureVirtual) {
+        classType.registeredClass.pureVirtualFunctions.push(methodName);
+      }
+      function unboundTypesHandler() {
+        throwUnboundTypeError(
+          "Cannot call " + humanName + " due to unbound types",
+          rawArgTypes
+        );
+      }
+      var proto = classType.registeredClass.instancePrototype;
+      var method = proto[methodName];
+      if (
+        undefined === method ||
+        (undefined === method.overloadTable &&
+          method.className !== classType.name &&
+          method.argCount === argCount - 2)
+      ) {
+        unboundTypesHandler.argCount = argCount - 2;
+        unboundTypesHandler.className = classType.name;
+        proto[methodName] = unboundTypesHandler;
+      } else {
+        ensureOverloadTable(proto, methodName, humanName);
+        proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
+      }
+      whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+        var memberFunction = craftInvokerFunction(
+          humanName,
+          argTypes,
+          classType,
+          rawInvoker,
+          context
+        );
+        if (undefined === proto[methodName].overloadTable) {
+          memberFunction.argCount = argCount - 2;
+          proto[methodName] = memberFunction;
+        } else {
+          proto[methodName].overloadTable[argCount - 2] = memberFunction;
+        }
+        return [];
+      });
+      return [];
+    });
+  }
+
+  var emval_free_list = [];
+
+  var emval_handle_array = [
+    {},
+    {
+      value: undefined,
+    },
+    {
+      value: null,
+    },
+    {
+      value: true,
+    },
+    {
+      value: false,
+    },
+  ];
+
+  function __emval_decref(handle) {
+    if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
+      emval_handle_array[handle] = undefined;
+      emval_free_list.push(handle);
+    }
+  }
+
+  function count_emval_handles() {
+    var count = 0;
+    for (var i = 5; i < emval_handle_array.length; ++i) {
+      if (emval_handle_array[i] !== undefined) {
+        ++count;
+      }
+    }
+    return count;
+  }
+
+  function get_first_emval() {
+    for (var i = 5; i < emval_handle_array.length; ++i) {
+      if (emval_handle_array[i] !== undefined) {
+        return emval_handle_array[i];
+      }
+    }
+    return null;
+  }
+
+  function init_emval() {
+    Module.count_emval_handles = count_emval_handles;
+    Module.get_first_emval = get_first_emval;
+  }
+
+  var Emval = {
+    toValue: handle => {
+      if (!handle) {
+        throwBindingError("Cannot use deleted val. handle = " + handle);
+      }
+      return emval_handle_array[handle].value;
+    },
+    toHandle: value => {
+      switch (value) {
+        case undefined:
+          return 1;
+
+        case null:
+          return 2;
+
+        case true:
+          return 3;
+
+        case false:
+          return 4;
+
+        default: {
+          var handle = emval_free_list.length
+            ? emval_free_list.pop()
+            : emval_handle_array.length;
+          emval_handle_array[handle] = {
+            refcount: 1,
+            value,
+          };
+          return handle;
+        }
+      }
+    },
+  };
+
+  function __embind_register_emval(rawType, name) {
+    name = readLatin1String(name);
+    registerType(rawType, {
+      name,
+      fromWireType: function (handle) {
+        var rv = Emval.toValue(handle);
+        __emval_decref(handle);
+        return rv;
+      },
+      toWireType: function (destructors, value) {
+        return Emval.toHandle(value);
+      },
+      argPackAdvance: 8,
+      readValueFromPointer: simpleReadValueFromPointer,
+      destructorFunction: null,
+    });
+  }
+
+  function _embind_repr(v) {
+    if (v === null) {
+      return "null";
+    }
+    var t = typeof v;
+    if (t === "object" || t === "array" || t === "function") {
+      return v.toString();
+    }
+    return "" + v;
+  }
+
+  function floatReadValueFromPointer(name, shift) {
+    switch (shift) {
+      case 2:
+        return function (pointer) {
+          return this.fromWireType(HEAPF32[pointer >> 2]);
+        };
+
+      case 3:
+        return function (pointer) {
+          return this.fromWireType(HEAPF64[pointer >> 3]);
+        };
+
+      default:
+        throw new TypeError("Unknown float type: " + name);
+    }
+  }
+
+  function __embind_register_float(rawType, name, size) {
+    var shift = getShiftFromSize(size);
+    name = readLatin1String(name);
+    registerType(rawType, {
+      name,
+      fromWireType: function (value) {
+        return value;
+      },
+      toWireType: function (destructors, value) {
+        return value;
+      },
+      argPackAdvance: 8,
+      readValueFromPointer: floatReadValueFromPointer(name, shift),
+      destructorFunction: null,
+    });
+  }
+
+  function integerReadValueFromPointer(name, shift, signed) {
+    switch (shift) {
+      case 0:
+        return signed
+          ? function readS8FromPointer(pointer) {
+              return HEAP8[pointer];
+            }
+          : function readU8FromPointer(pointer) {
+              return HEAPU8[pointer];
+            };
+
+      case 1:
+        return signed
+          ? function readS16FromPointer(pointer) {
+              return HEAP16[pointer >> 1];
+            }
+          : function readU16FromPointer(pointer) {
+              return HEAPU16[pointer >> 1];
+            };
+
+      case 2:
+        return signed
+          ? function readS32FromPointer(pointer) {
+              return HEAP32[pointer >> 2];
+            }
+          : function readU32FromPointer(pointer) {
+              return HEAPU32[pointer >> 2];
+            };
+
+      default:
+        throw new TypeError("Unknown integer type: " + name);
+    }
+  }
+
+  function __embind_register_integer(
+    primitiveType,
+    name,
+    size,
+    minRange,
+    maxRange
+  ) {
+    name = readLatin1String(name);
+    if (maxRange === -1) {
+      maxRange = 4294967295;
+    }
+    var shift = getShiftFromSize(size);
+    var fromWireType = value => value;
+    if (minRange === 0) {
+      var bitshift = 32 - 8 * size;
+      fromWireType = value => (value << bitshift) >>> bitshift;
+    }
+    var isUnsignedType = name.includes("unsigned");
+    var checkAssertions = (value, toTypeName) => {};
+    var toWireType;
+    if (isUnsignedType) {
+      toWireType = function (destructors, value) {
+        checkAssertions(value, this.name);
+        return value >>> 0;
+      };
+    } else {
+      toWireType = function (destructors, value) {
+        checkAssertions(value, this.name);
+        return value;
+      };
+    }
+    registerType(primitiveType, {
+      name,
+      fromWireType: fromWireType,
+      toWireType: toWireType,
+      argPackAdvance: 8,
+      readValueFromPointer: integerReadValueFromPointer(
+        name,
+        shift,
+        minRange !== 0
+      ),
+      destructorFunction: null,
+    });
+  }
+
+  function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+    var typeMapping = [
+      Int8Array,
+      Uint8Array,
+      Int16Array,
+      Uint16Array,
+      Int32Array,
+      Uint32Array,
+      Float32Array,
+      Float64Array,
+    ];
+    var TA = typeMapping[dataTypeIndex];
+    function decodeMemoryView(handle) {
+      handle = handle >> 2;
+      var heap = HEAPU32;
+      var size = heap[handle];
+      var data = heap[handle + 1];
+      return new TA(buffer, data, size);
+    }
+    name = readLatin1String(name);
+    registerType(
+      rawType,
+      {
+        name,
+        fromWireType: decodeMemoryView,
+        argPackAdvance: 8,
+        readValueFromPointer: decodeMemoryView,
+      },
+      {
+        ignoreDuplicateRegistrations: true,
+      }
+    );
+  }
+
+  function __embind_register_smart_ptr(
+    rawType,
+    rawPointeeType,
+    name,
+    sharingPolicy,
+    getPointeeSignature,
+    rawGetPointee,
+    constructorSignature,
+    rawConstructor,
+    shareSignature,
+    rawShare,
+    destructorSignature,
+    rawDestructor
+  ) {
+    name = readLatin1String(name);
+    rawGetPointee = embind__requireFunction(getPointeeSignature, rawGetPointee);
+    rawConstructor = embind__requireFunction(
+      constructorSignature,
+      rawConstructor
+    );
+    rawShare = embind__requireFunction(shareSignature, rawShare);
+    rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
+    whenDependentTypesAreResolved(
+      [rawType],
+      [rawPointeeType],
+      function (pointeeType) {
+        pointeeType = pointeeType[0];
+        var registeredPointer = new RegisteredPointer(
+          name,
+          pointeeType.registeredClass,
+          false,
+          false,
+          true,
+          pointeeType,
+          sharingPolicy,
+          rawGetPointee,
+          rawConstructor,
+          rawShare,
+          rawDestructor
+        );
+        return [registeredPointer];
+      }
+    );
+  }
+
+  function __embind_register_std_string(rawType, name) {
+    name = readLatin1String(name);
+    var stdStringIsUTF8 = name === "std::string";
+    registerType(rawType, {
+      name,
+      fromWireType: function (value) {
+        var length = HEAPU32[value >> 2];
+        var str;
+        if (stdStringIsUTF8) {
+          var decodeStartPtr = value + 4;
+          for (var i = 0; i <= length; ++i) {
+            var currentBytePtr = value + 4 + i;
+            if (i == length || HEAPU8[currentBytePtr] == 0) {
+              var maxRead = currentBytePtr - decodeStartPtr;
+              var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
+              if (str === undefined) {
+                str = stringSegment;
+              } else {
+                str += String.fromCharCode(0);
+                str += stringSegment;
+              }
+              decodeStartPtr = currentBytePtr + 1;
+            }
+          }
+        } else {
+          var a = new Array(length);
+          for (var i = 0; i < length; ++i) {
+            a[i] = String.fromCharCode(HEAPU8[value + 4 + i]);
+          }
+          str = a.join("");
+        }
+        _free(value);
+        return str;
+      },
+      toWireType: function (destructors, value) {
+        if (value instanceof ArrayBuffer) {
+          value = new Uint8Array(value);
+        }
+        var getLength;
+        var valueIsOfTypeString = typeof value == "string";
+        if (
+          !(
+            valueIsOfTypeString ||
+            value instanceof Uint8Array ||
+            value instanceof Uint8ClampedArray ||
+            value instanceof Int8Array
+          )
+        ) {
+          throwBindingError("Cannot pass non-string to std::string");
+        }
+        if (stdStringIsUTF8 && valueIsOfTypeString) {
+          getLength = () => lengthBytesUTF8(value);
+        } else {
+          getLength = () => value.length;
+        }
+        var length = getLength();
+        var ptr = _malloc(4 + length + 1);
+        HEAPU32[ptr >> 2] = length;
+        if (stdStringIsUTF8 && valueIsOfTypeString) {
+          stringToUTF8(value, ptr + 4, length + 1);
+        } else if (valueIsOfTypeString) {
+          for (var i = 0; i < length; ++i) {
+            var charCode = value.charCodeAt(i);
+            if (charCode > 255) {
+              _free(ptr);
+              throwBindingError(
+                "String has UTF-16 code units that do not fit in 8 bits"
+              );
+            }
+            HEAPU8[ptr + 4 + i] = charCode;
+          }
+        } else {
+          for (var i = 0; i < length; ++i) {
+            HEAPU8[ptr + 4 + i] = value[i];
+          }
+        }
+        if (destructors !== null) {
+          destructors.push(_free, ptr);
+        }
+        return ptr;
+      },
+      argPackAdvance: 8,
+      readValueFromPointer: simpleReadValueFromPointer,
+      destructorFunction(ptr) {
+        _free(ptr);
+      },
+    });
+  }
+
+  function __embind_register_std_wstring(rawType, charSize, name) {
+    name = readLatin1String(name);
+    var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
+    if (charSize === 2) {
+      decodeString = UTF16ToString;
+      encodeString = stringToUTF16;
+      lengthBytesUTF = lengthBytesUTF16;
+      getHeap = () => HEAPU16;
+      shift = 1;
+    } else if (charSize === 4) {
+      decodeString = UTF32ToString;
+      encodeString = stringToUTF32;
+      lengthBytesUTF = lengthBytesUTF32;
+      getHeap = () => HEAPU32;
+      shift = 2;
+    }
+    registerType(rawType, {
+      name,
+      fromWireType: function (value) {
+        var length = HEAPU32[value >> 2];
+        var HEAP = getHeap();
+        var str;
+        var decodeStartPtr = value + 4;
+        for (var i = 0; i <= length; ++i) {
+          var currentBytePtr = value + 4 + i * charSize;
+          if (i == length || HEAP[currentBytePtr >> shift] == 0) {
+            var maxReadBytes = currentBytePtr - decodeStartPtr;
+            var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
+            if (str === undefined) {
+              str = stringSegment;
+            } else {
+              str += String.fromCharCode(0);
+              str += stringSegment;
+            }
+            decodeStartPtr = currentBytePtr + charSize;
+          }
+        }
+        _free(value);
+        return str;
+      },
+      toWireType: function (destructors, value) {
+        if (!(typeof value == "string")) {
+          throwBindingError(
+            "Cannot pass non-string to C++ string type " + name
+          );
+        }
+        var length = lengthBytesUTF(value);
+        var ptr = _malloc(4 + length + charSize);
+        HEAPU32[ptr >> 2] = length >> shift;
+        encodeString(value, ptr + 4, length + charSize);
+        if (destructors !== null) {
+          destructors.push(_free, ptr);
+        }
+        return ptr;
+      },
+      argPackAdvance: 8,
+      readValueFromPointer: simpleReadValueFromPointer,
+      destructorFunction(ptr) {
+        _free(ptr);
+      },
+    });
+  }
+
+  function __embind_register_value_object(
+    rawType,
+    name,
+    constructorSignature,
+    rawConstructor,
+    destructorSignature,
+    rawDestructor
+  ) {
+    structRegistrations[rawType] = {
+      name: readLatin1String(name),
+      rawConstructor: embind__requireFunction(
+        constructorSignature,
+        rawConstructor
+      ),
+      rawDestructor: embind__requireFunction(
+        destructorSignature,
+        rawDestructor
+      ),
+      fields: [],
+    };
+  }
+
+  function __embind_register_value_object_field(
+    structType,
+    fieldName,
+    getterReturnType,
+    getterSignature,
+    getter,
+    getterContext,
+    setterArgumentType,
+    setterSignature,
+    setter,
+    setterContext
+  ) {
+    structRegistrations[structType].fields.push({
+      fieldName: readLatin1String(fieldName),
+      getterReturnType,
+      getter: embind__requireFunction(getterSignature, getter),
+      getterContext,
+      setterArgumentType,
+      setter: embind__requireFunction(setterSignature, setter),
+      setterContext,
+    });
+  }
+
+  function __embind_register_void(rawType, name) {
+    name = readLatin1String(name);
+    registerType(rawType, {
+      isVoid: true,
+      name,
+      argPackAdvance: 0,
+      fromWireType: function () {
+        return undefined;
+      },
+      toWireType: function (destructors, o) {
+        return undefined;
+      },
+    });
+  }
+
+  function __emscripten_date_now() {
+    return Date.now();
+  }
+
+  var nowIsMonotonic = true;
+
+  function __emscripten_get_now_is_monotonic() {
+    return nowIsMonotonic;
+  }
+
+  function requireRegisteredType(rawType, humanName) {
+    var impl = registeredTypes[rawType];
+    if (undefined === impl) {
+      throwBindingError(
+        humanName + " has unknown type " + getTypeName(rawType)
+      );
+    }
+    return impl;
+  }
+
+  function __emval_lookupTypes(argCount, argTypes) {
+    var a = new Array(argCount);
+    for (var i = 0; i < argCount; ++i) {
+      a[i] = requireRegisteredType(
+        HEAP32[(argTypes >> 2) + i],
+        "parameter " + i
+      );
+    }
+    return a;
+  }
+
+  function __emval_call(handle, argCount, argTypes, argv) {
+    handle = Emval.toValue(handle);
+    var types = __emval_lookupTypes(argCount, argTypes);
+    var args = new Array(argCount);
+    for (var i = 0; i < argCount; ++i) {
+      var type = types[i];
+      args[i] = type.readValueFromPointer(argv);
+      argv += type.argPackAdvance;
+    }
+    var rv = handle.apply(undefined, args);
+    return Emval.toHandle(rv);
+  }
+
+  function __emval_incref(handle) {
+    if (handle > 4) {
+      emval_handle_array[handle].refcount += 1;
+    }
+  }
+
+  function __emval_take_value(type, argv) {
+    type = requireRegisteredType(type, "_emval_take_value");
+    var v = type.readValueFromPointer(argv);
+    return Emval.toHandle(v);
+  }
+
+  function __localtime_js(time, tmPtr) {
+    var date = new Date(HEAP32[time >> 2] * 1e3);
+    HEAP32[tmPtr >> 2] = date.getSeconds();
+    HEAP32[(tmPtr + 4) >> 2] = date.getMinutes();
+    HEAP32[(tmPtr + 8) >> 2] = date.getHours();
+    HEAP32[(tmPtr + 12) >> 2] = date.getDate();
+    HEAP32[(tmPtr + 16) >> 2] = date.getMonth();
+    HEAP32[(tmPtr + 20) >> 2] = date.getFullYear() - 1900;
+    HEAP32[(tmPtr + 24) >> 2] = date.getDay();
+    var start = new Date(date.getFullYear(), 0, 1);
+    var yday = ((date.getTime() - start.getTime()) / (1e3 * 60 * 60 * 24)) | 0;
+    HEAP32[(tmPtr + 28) >> 2] = yday;
+    HEAP32[(tmPtr + 36) >> 2] = -(date.getTimezoneOffset() * 60);
+    var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
+    var winterOffset = start.getTimezoneOffset();
+    var dst =
+      (summerOffset != winterOffset &&
+        date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
+    HEAP32[(tmPtr + 32) >> 2] = dst;
+  }
+
+  function __mmap_js(addr, len, prot, flags, fd, off, allocated, builtin) {
+    return -52;
+  }
+
+  function __munmap_js(addr, len, prot, flags, fd, offset) {}
+
+  function _tzset_impl(timezone, daylight, tzname) {
+    var currentYear = new Date().getFullYear();
+    var winter = new Date(currentYear, 0, 1);
+    var summer = new Date(currentYear, 6, 1);
+    var winterOffset = winter.getTimezoneOffset();
+    var summerOffset = summer.getTimezoneOffset();
+    var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
+    HEAP32[timezone >> 2] = stdTimezoneOffset * 60;
+    HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
+    function extractZone(date) {
+      var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/);
+      return match ? match[1] : "GMT";
+    }
+    var winterName = extractZone(winter);
+    var summerName = extractZone(summer);
+    var winterNamePtr = allocateUTF8(winterName);
+    var summerNamePtr = allocateUTF8(summerName);
+    if (summerOffset < winterOffset) {
+      HEAP32[tzname >> 2] = winterNamePtr;
+      HEAP32[(tzname + 4) >> 2] = summerNamePtr;
+    } else {
+      HEAP32[tzname >> 2] = summerNamePtr;
+      HEAP32[(tzname + 4) >> 2] = winterNamePtr;
+    }
+  }
+
+  function __tzset_js(timezone, daylight, tzname) {
+    if (__tzset_js.called) {
+      return;
+    }
+    __tzset_js.called = true;
+    _tzset_impl(timezone, daylight, tzname);
+  }
+
+  function _abort() {
+    abort("");
+  }
+
+  function _emscripten_get_heap_max() {
+    return 2147483648;
+  }
+
+  var _emscripten_get_now;
+
+  _emscripten_get_now = () => performance.now();
+
+  function _emscripten_memcpy_big(dest, src, num) {
+    HEAPU8.copyWithin(dest, src, src + num);
+  }
+
+  function emscripten_realloc_buffer(size) {
+    try {
+      wasmMemory.grow((size - buffer.byteLength + 65535) >>> 16);
+      updateGlobalBufferAndViews(wasmMemory.buffer);
+      return 1;
+    } catch (e) {}
+  }
+
+  function _emscripten_resize_heap(requestedSize) {
+    var oldSize = HEAPU8.length;
+    requestedSize = requestedSize >>> 0;
+    var maxHeapSize = _emscripten_get_heap_max();
+    if (requestedSize > maxHeapSize) {
+      return false;
+    }
+    let alignUp = (x, multiple) => x + ((multiple - (x % multiple)) % multiple);
+    for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+      var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
+      overGrownHeapSize = Math.min(
+        overGrownHeapSize,
+        requestedSize + 100663296
+      );
+      var newSize = Math.min(
+        maxHeapSize,
+        alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)
+      );
+      var replacement = emscripten_realloc_buffer(newSize);
+      if (replacement) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  var ENV = {};
+
+  function getExecutableName() {
+    return thisProgram || "./this.program";
+  }
+
+  function getEnvStrings() {
+    if (!getEnvStrings.strings) {
+      var lang =
+        (
+          (typeof navigator == "object" &&
+            navigator.languages &&
+            navigator.languages[0]) ||
+          "C"
+        ).replace("-", "_") + ".UTF-8";
+      var env = {
+        USER: "web_user",
+        LOGNAME: "web_user",
+        PATH: "/",
+        PWD: "/",
+        HOME: "/home/web_user",
+        LANG: lang,
+        _: getExecutableName(),
+      };
+      for (var x in ENV) {
+        if (ENV[x] === undefined) {
+          delete env[x];
+        } else {
+          env[x] = ENV[x];
+        }
+      }
+      var strings = [];
+      for (var x in env) {
+        strings.push(x + "=" + env[x]);
+      }
+      getEnvStrings.strings = strings;
+    }
+    return getEnvStrings.strings;
+  }
+
+  function _environ_get(__environ, environ_buf) {
+    var bufSize = 0;
+    getEnvStrings().forEach(function (string, i) {
+      var ptr = environ_buf + bufSize;
+      HEAP32[(__environ + i * 4) >> 2] = ptr;
+      writeAsciiToMemory(string, ptr);
+      bufSize += string.length + 1;
+    });
+    return 0;
+  }
+
+  function _environ_sizes_get(penviron_count, penviron_buf_size) {
+    var strings = getEnvStrings();
+    HEAP32[penviron_count >> 2] = strings.length;
+    var bufSize = 0;
+    strings.forEach(function (string) {
+      bufSize += string.length + 1;
+    });
+    HEAP32[penviron_buf_size >> 2] = bufSize;
+    return 0;
+  }
+
+  function _exit(status) {
+    exit(status);
+  }
+
+  function _fd_close(fd) {
+    return 0;
+  }
+
+  function _fd_read(fd, iov, iovcnt, pnum) {
+    var stream = SYSCALLS.getStreamFromFD(fd);
+    var num = SYSCALLS.doReadv(stream, iov, iovcnt);
+    HEAP32[pnum >> 2] = num;
+    return 0;
+  }
+
+  function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {}
+
+  function _fd_write(fd, iov, iovcnt, pnum) {
+    var num = 0;
+    for (var i = 0; i < iovcnt; i++) {
+      var ptr = HEAP32[iov >> 2];
+      var len = HEAP32[(iov + 4) >> 2];
+      iov += 8;
+      for (var j = 0; j < len; j++) {
+        SYSCALLS.printChar(fd, HEAPU8[ptr + j]);
+      }
+      num += len;
+    }
+    HEAP32[pnum >> 2] = num;
+    return 0;
+  }
+
+  function getRandomDevice() {
+    if (
+      typeof crypto == "object" &&
+      typeof crypto.getRandomValues == "function"
+    ) {
+      var randomBuffer = new Uint8Array(1);
+      return function () {
+        crypto.getRandomValues(randomBuffer);
+        return randomBuffer[0];
+      };
+    }
+    return function () {
+      abort("randomDevice");
+    };
+  }
+
+  function _getentropy(buffer, size) {
+    if (!_getentropy.randomDevice) {
+      _getentropy.randomDevice = getRandomDevice();
+    }
+    for (var i = 0; i < size; i++) {
+      HEAP8[(buffer + i) >> 0] = _getentropy.randomDevice();
+    }
+    return 0;
+  }
+
+  function _pclose() {
+    err("missing function: pclose");
+    abort(-1);
+  }
+
+  function _setTempRet0(val) {
+    setTempRet0(val);
+  }
+
+  function __isLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  }
+
+  function __arraySum(array, index) {
+    var sum = 0;
+    for (var i = 0; i <= index; sum += array[i++]) {}
+    return sum;
+  }
+
+  var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+  var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+  function __addDays(date, days) {
+    var newDate = new Date(date.getTime());
+    while (days > 0) {
+      var leap = __isLeapYear(newDate.getFullYear());
+      var currentMonth = newDate.getMonth();
+      var daysInCurrentMonth = (
+        leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR
+      )[currentMonth];
+      if (days > daysInCurrentMonth - newDate.getDate()) {
+        days -= daysInCurrentMonth - newDate.getDate() + 1;
+        newDate.setDate(1);
+        if (currentMonth < 11) {
+          newDate.setMonth(currentMonth + 1);
+        } else {
+          newDate.setMonth(0);
+          newDate.setFullYear(newDate.getFullYear() + 1);
+        }
+      } else {
+        newDate.setDate(newDate.getDate() + days);
+        return newDate;
+      }
+    }
+    return newDate;
+  }
+
+  function _strftime(s, maxsize, format, tm) {
+    var tm_zone = HEAP32[(tm + 40) >> 2];
+    var date = {
+      tm_sec: HEAP32[tm >> 2],
+      tm_min: HEAP32[(tm + 4) >> 2],
+      tm_hour: HEAP32[(tm + 8) >> 2],
+      tm_mday: HEAP32[(tm + 12) >> 2],
+      tm_mon: HEAP32[(tm + 16) >> 2],
+      tm_year: HEAP32[(tm + 20) >> 2],
+      tm_wday: HEAP32[(tm + 24) >> 2],
+      tm_yday: HEAP32[(tm + 28) >> 2],
+      tm_isdst: HEAP32[(tm + 32) >> 2],
+      tm_gmtoff: HEAP32[(tm + 36) >> 2],
+      tm_zone: tm_zone ? UTF8ToString(tm_zone) : "",
+    };
+    var pattern = UTF8ToString(format);
+    var EXPANSION_RULES_1 = {
+      "%c": "%a %b %d %H:%M:%S %Y",
+      "%D": "%m/%d/%y",
+      "%F": "%Y-%m-%d",
+      "%h": "%b",
+      "%r": "%I:%M:%S %p",
+      "%R": "%H:%M",
+      "%T": "%H:%M:%S",
+      "%x": "%m/%d/%y",
+      "%X": "%H:%M:%S",
+      "%Ec": "%c",
+      "%EC": "%C",
+      "%Ex": "%m/%d/%y",
+      "%EX": "%H:%M:%S",
+      "%Ey": "%y",
+      "%EY": "%Y",
+      "%Od": "%d",
+      "%Oe": "%e",
+      "%OH": "%H",
+      "%OI": "%I",
+      "%Om": "%m",
+      "%OM": "%M",
+      "%OS": "%S",
+      "%Ou": "%u",
+      "%OU": "%U",
+      "%OV": "%V",
+      "%Ow": "%w",
+      "%OW": "%W",
+      "%Oy": "%y",
+    };
+    for (var rule in EXPANSION_RULES_1) {
+      pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]);
+    }
+    var WEEKDAYS = [
+      "Sunday",
+      "Monday",
+      "Tuesday",
+      "Wednesday",
+      "Thursday",
+      "Friday",
+      "Saturday",
+    ];
+    var MONTHS = [
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December",
+    ];
+    function leadingSomething(value, digits, character) {
+      var str = typeof value == "number" ? value.toString() : value || "";
+      while (str.length < digits) {
+        str = character[0] + str;
+      }
+      return str;
+    }
+    function leadingNulls(value, digits) {
+      return leadingSomething(value, digits, "0");
+    }
+    function compareByDay(date1, date2) {
+      function sgn(value) {
+        return value < 0 ? -1 : value > 0 ? 1 : 0;
+      }
+      var compare;
+      if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) {
+        if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) {
+          compare = sgn(date1.getDate() - date2.getDate());
+        }
+      }
+      return compare;
+    }
+    function getFirstWeekStartDate(janFourth) {
+      switch (janFourth.getDay()) {
+        case 0:
+          return new Date(janFourth.getFullYear() - 1, 11, 29);
+
+        case 1:
+          return janFourth;
+
+        case 2:
+          return new Date(janFourth.getFullYear(), 0, 3);
+
+        case 3:
+          return new Date(janFourth.getFullYear(), 0, 2);
+
+        case 4:
+          return new Date(janFourth.getFullYear(), 0, 1);
+
+        case 5:
+          return new Date(janFourth.getFullYear() - 1, 11, 31);
+
+        case 6:
+          return new Date(janFourth.getFullYear() - 1, 11, 30);
+      }
+    }
+    function getWeekBasedYear(date) {
+      var thisDate = __addDays(
+        new Date(date.tm_year + 1900, 0, 1),
+        date.tm_yday
+      );
+      var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4);
+      var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4);
+      var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear);
+      var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear);
+      if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) {
+        if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) {
+          return thisDate.getFullYear() + 1;
+        }
+        return thisDate.getFullYear();
+      }
+      return thisDate.getFullYear() - 1;
+    }
+    var EXPANSION_RULES_2 = {
+      "%a": function (date) {
+        return WEEKDAYS[date.tm_wday].substring(0, 3);
+      },
+      "%A": function (date) {
+        return WEEKDAYS[date.tm_wday];
+      },
+      "%b": function (date) {
+        return MONTHS[date.tm_mon].substring(0, 3);
+      },
+      "%B": function (date) {
+        return MONTHS[date.tm_mon];
+      },
+      "%C": function (date) {
+        var year = date.tm_year + 1900;
+        return leadingNulls((year / 100) | 0, 2);
+      },
+      "%d": function (date) {
+        return leadingNulls(date.tm_mday, 2);
+      },
+      "%e": function (date) {
+        return leadingSomething(date.tm_mday, 2, " ");
+      },
+      "%g": function (date) {
+        return getWeekBasedYear(date).toString().substring(2);
+      },
+      "%G": function (date) {
+        return getWeekBasedYear(date);
+      },
+      "%H": function (date) {
+        return leadingNulls(date.tm_hour, 2);
+      },
+      "%I": function (date) {
+        var twelveHour = date.tm_hour;
+        if (twelveHour == 0) {
+          twelveHour = 12;
+        } else if (twelveHour > 12) {
+          twelveHour -= 12;
+        }
+        return leadingNulls(twelveHour, 2);
+      },
+      "%j": function (date) {
+        return leadingNulls(
+          date.tm_mday +
+            __arraySum(
+              __isLeapYear(date.tm_year + 1900)
+                ? __MONTH_DAYS_LEAP
+                : __MONTH_DAYS_REGULAR,
+              date.tm_mon - 1
+            ),
+          3
+        );
+      },
+      "%m": function (date) {
+        return leadingNulls(date.tm_mon + 1, 2);
+      },
+      "%M": function (date) {
+        return leadingNulls(date.tm_min, 2);
+      },
+      "%n": function () {
+        return "\n";
+      },
+      "%p": function (date) {
+        if (date.tm_hour >= 0 && date.tm_hour < 12) {
+          return "AM";
+        }
+        return "PM";
+      },
+      "%S": function (date) {
+        return leadingNulls(date.tm_sec, 2);
+      },
+      "%t": function () {
+        return "\t";
+      },
+      "%u": function (date) {
+        return date.tm_wday || 7;
+      },
+      "%U": function (date) {
+        var days = date.tm_yday + 7 - date.tm_wday;
+        return leadingNulls(Math.floor(days / 7), 2);
+      },
+      "%V": function (date) {
+        var val = Math.floor((date.tm_yday + 7 - ((date.tm_wday + 6) % 7)) / 7);
+        if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) {
+          val++;
+        }
+        if (!val) {
+          val = 52;
+          var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7;
+          if (
+            dec31 == 4 ||
+            (dec31 == 5 && __isLeapYear((date.tm_year % 400) - 1))
+          ) {
+            val++;
+          }
+        } else if (val == 53) {
+          var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7;
+          if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year))) {
+            val = 1;
+          }
+        }
+        return leadingNulls(val, 2);
+      },
+      "%w": function (date) {
+        return date.tm_wday;
+      },
+      "%W": function (date) {
+        var days = date.tm_yday + 7 - ((date.tm_wday + 6) % 7);
+        return leadingNulls(Math.floor(days / 7), 2);
+      },
+      "%y": function (date) {
+        return (date.tm_year + 1900).toString().substring(2);
+      },
+      "%Y": function (date) {
+        return date.tm_year + 1900;
+      },
+      "%z": function (date) {
+        var off = date.tm_gmtoff;
+        var ahead = off >= 0;
+        off = Math.abs(off) / 60;
+        off = (off / 60) * 100 + (off % 60);
+        return (ahead ? "+" : "-") + String("0000" + off).slice(-4);
+      },
+      "%Z": function (date) {
+        return date.tm_zone;
+      },
+      "%%": function () {
+        return "%";
+      },
+    };
+    pattern = pattern.replace(/%%/g, "\0\0");
+    for (var rule in EXPANSION_RULES_2) {
+      if (pattern.includes(rule)) {
+        pattern = pattern.replace(
+          new RegExp(rule, "g"),
+          EXPANSION_RULES_2[rule](date)
+        );
+      }
+    }
+    pattern = pattern.replace(/\0\0/g, "%");
+    var bytes = intArrayFromString(pattern, false);
+    if (bytes.length > maxsize) {
+      return 0;
+    }
+    writeArrayToMemory(bytes, s);
+    return bytes.length - 1;
+  }
+
+  function _strftime_l(s, maxsize, format, tm) {
+    return _strftime(s, maxsize, format, tm);
+  }
+
+  InternalError = Module.InternalError = extendError(Error, "InternalError");
+
+  embind_init_charCodes();
+
+  BindingError = Module.BindingError = extendError(Error, "BindingError");
+
+  init_ClassHandle();
+
+  init_embind();
+
+  init_RegisteredPointer();
+
+  UnboundTypeError = Module.UnboundTypeError = extendError(
+    Error,
+    "UnboundTypeError"
+  );
+
+  init_emval();
+
+  function intArrayFromString(stringy, dontAddNull, length) {
+    var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
+    var u8array = new Array(len);
+    var numBytesWritten = stringToUTF8Array(
+      stringy,
+      u8array,
+      0,
+      u8array.length
+    );
+    if (dontAddNull) {
+      u8array.length = numBytesWritten;
+    }
+    return u8array;
+  }
+
+  var asmLibraryArg = {
+    __assert_fail: ___assert_fail,
+    __cxa_allocate_exception: ___cxa_allocate_exception,
+    __cxa_rethrow: ___cxa_rethrow,
+    __cxa_throw: ___cxa_throw,
+    __syscall_faccessat: ___syscall_faccessat,
+    __syscall_fcntl64: ___syscall_fcntl64,
+    __syscall_fstat64: ___syscall_fstat64,
+    __syscall_getcwd: ___syscall_getcwd,
+    __syscall_ioctl: ___syscall_ioctl,
+    __syscall_lstat64: ___syscall_lstat64,
+    __syscall_newfstatat: ___syscall_newfstatat,
+    __syscall_openat: ___syscall_openat,
+    __syscall_renameat: ___syscall_renameat,
+    __syscall_rmdir: ___syscall_rmdir,
+    __syscall_stat64: ___syscall_stat64,
+    __syscall_unlinkat: ___syscall_unlinkat,
+    _embind_finalize_value_object: __embind_finalize_value_object,
+    _embind_register_bigint: __embind_register_bigint,
+    _embind_register_bool: __embind_register_bool,
+    _embind_register_class: __embind_register_class,
+    _embind_register_class_constructor: __embind_register_class_constructor,
+    _embind_register_class_function: __embind_register_class_function,
+    _embind_register_emval: __embind_register_emval,
+    _embind_register_float: __embind_register_float,
+    _embind_register_integer: __embind_register_integer,
+    _embind_register_memory_view: __embind_register_memory_view,
+    _embind_register_smart_ptr: __embind_register_smart_ptr,
+    _embind_register_std_string: __embind_register_std_string,
+    _embind_register_std_wstring: __embind_register_std_wstring,
+    _embind_register_value_object: __embind_register_value_object,
+    _embind_register_value_object_field: __embind_register_value_object_field,
+    _embind_register_void: __embind_register_void,
+    _emscripten_date_now: __emscripten_date_now,
+    _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,
+    _emval_call: __emval_call,
+    _emval_decref: __emval_decref,
+    _emval_incref: __emval_incref,
+    _emval_take_value: __emval_take_value,
+    _localtime_js: __localtime_js,
+    _mmap_js: __mmap_js,
+    _munmap_js: __munmap_js,
+    _tzset_js: __tzset_js,
+    abort: _abort,
+    emscripten_get_heap_max: _emscripten_get_heap_max,
+    emscripten_get_now: _emscripten_get_now,
+    emscripten_memcpy_big: _emscripten_memcpy_big,
+    emscripten_resize_heap: _emscripten_resize_heap,
+    environ_get: _environ_get,
+    environ_sizes_get: _environ_sizes_get,
+    exit: _exit,
+    fd_close: _fd_close,
+    fd_read: _fd_read,
+    fd_seek: _fd_seek,
+    fd_write: _fd_write,
+    getentropy: _getentropy,
+    memory: wasmMemory,
+    pclose: _pclose,
+    setTempRet0: _setTempRet0,
+    strftime_l: _strftime_l,
+  };
+
+  var asm = createWasm();
+
+  var calledRun;
+
+  function ExitStatus(status) {
+    this.name = "ExitStatus";
+    this.message = "Program terminated with exit(" + status + ")";
+    this.status = status;
+  }
+
+  dependenciesFulfilled = function runCaller() {
+    if (!calledRun) {
+      run();
+    }
+    if (!calledRun) {
+      dependenciesFulfilled = runCaller;
+    }
+  };
+
+  function run(args) {
+    args = args || arguments_;
+    if (runDependencies > 0) {
+      return;
+    }
+    preRun();
+    if (runDependencies > 0) {
+      return;
+    }
+    function doRun() {
+      if (calledRun) {
+        return;
+      }
+      calledRun = true;
+      Module.calledRun = true;
+      if (ABORT) {
+        return;
+      }
+      initRuntime();
+      if (Module.onRuntimeInitialized) {
+        Module.onRuntimeInitialized();
+      }
+      postRun();
+    }
+    if (Module.setStatus) {
+      Module.setStatus("Running...");
+      setTimeout(function () {
+        setTimeout(function () {
+          Module.setStatus("");
+        }, 1);
+        doRun();
+      }, 1);
+    } else {
+      doRun();
+    }
+  }
+
+  Module.run = run;
+
+  function exit(status, implicit) {
+    EXITSTATUS = status;
+    procExit(status);
+  }
+
+  function procExit(code) {
+    EXITSTATUS = code;
+    if (!keepRuntimeAlive()) {
+      if (Module.onExit) {
+        Module.onExit(code);
+      }
+      ABORT = true;
+    }
+    quit_(code, new ExitStatus(code));
+  }
+
+  if (Module.preInit) {
+    if (typeof Module.preInit == "function") {
+      Module.preInit = [Module.preInit];
+    }
+    while (Module.preInit.length) {
+      Module.preInit.pop()();
+    }
+  }
+
+  run();
+
+  /* Use an optimized gemm implementation if available, otherwise use the fallback
+   * implementation.
+   */
+  function createWasmGemm() {
+    // A map of expected gemm function to the corresponding fallback gemm function names.
+    const GEMM_TO_FALLBACK_FUNCTIONS_MAP = {
+      int8_prepare_a: "int8PrepareAFallback",
+      int8_prepare_b: "int8PrepareBFallback",
+      int8_prepare_b_from_transposed: "int8PrepareBFromTransposedFallback",
+      int8_prepare_b_from_quantized_transposed:
+        "int8PrepareBFromQuantizedTransposedFallback",
+      int8_prepare_bias: "int8PrepareBiasFallback",
+      int8_multiply_and_add_bias: "int8MultiplyAndAddBiasFallback",
+      int8_select_columns_of_b: "int8SelectColumnsOfBFallback",
+    };
+
+    // Name of the optimized gemm implementation.
+    const OPTIMIZED_GEMM = "mozIntGemm";
+
+    const optimizedGemmModule = WebAssembly[OPTIMIZED_GEMM];
+    if (!optimizedGemmModule) {
+      return fallbackGemm(GEMM_TO_FALLBACK_FUNCTIONS_MAP);
+    }
+
+    const optimizedGemmModuleExports = new WebAssembly.Instance(
+      optimizedGemmModule(),
+      { "": { memory: wasmMemory } }
+    ).exports;
+    for (let key in GEMM_TO_FALLBACK_FUNCTIONS_MAP) {
+      if (!optimizedGemmModuleExports[key]) {
+        return fallbackGemm(GEMM_TO_FALLBACK_FUNCTIONS_MAP);
+      }
+    }
+    Module.print(`Using optimized gemm (${OPTIMIZED_GEMM}) implementation`);
+    return optimizedGemmModuleExports;
+  }
+
+  // Return the fallback gemm implementation.
+  function fallbackGemm(gemmToFallbackFunctionsMap) {
+    // The fallback gemm implementation
+    const FALLBACK_GEMM = "asm";
+
+    let fallbackGemmModuleExports = {};
+    for (let key in gemmToFallbackFunctionsMap) {
+      fallbackGemmModuleExports[key] = (...a) =>
+        Module[FALLBACK_GEMM][gemmToFallbackFunctionsMap[key]](...a);
+    }
+    Module.print(`Using fallback gemm implementation`);
+    return fallbackGemmModuleExports;
+  }
+  return Module;
+}
diff --git a/toolkit/components/translations/bergamot-translator/build-bergamot.py b/toolkit/components/translations/bergamot-translator/build-bergamot.py
new file mode 100755
index 0000000000..6c55237f22
--- /dev/null
+++ b/toolkit/components/translations/bergamot-translator/build-bergamot.py
@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+"""
+Builds the Bergamot translations engine for integration with Firefox.
+
+If you wish to test the Bergamot engine locally, then uncomment the .wasm line in
+the toolkit/components/translations/jar.mn after building the file. Just make sure
+not to check the code change in.
+"""
+
+import argparse
+import multiprocessing
+import os
+import shutil
+import subprocess
+from collections import namedtuple
+
+import yaml
+
+DIR_PATH = os.path.realpath(os.path.dirname(__file__))
+THIRD_PARTY_PATH = os.path.join(DIR_PATH, "thirdparty")
+MOZ_YAML_PATH = os.path.join(DIR_PATH, "moz.yaml")
+PATCHES_PATH = os.path.join(DIR_PATH, "patches")
+BERGAMOT_PATH = os.path.join(THIRD_PARTY_PATH, "bergamot-translator")
+MARIAN_PATH = os.path.join(BERGAMOT_PATH, "3rd_party/marian-dev")
+GEMM_SCRIPT = os.path.join(BERGAMOT_PATH, "wasm/patch-artifacts-import-gemm-module.sh")
+BUILD_PATH = os.path.join(THIRD_PARTY_PATH, "build-wasm")
+EMSDK_PATH = os.path.join(THIRD_PARTY_PATH, "emsdk")
+EMSDK_ENV_PATH = os.path.join(EMSDK_PATH, "emsdk_env.sh")
+WASM_PATH = os.path.join(BUILD_PATH, "bergamot-translator-worker.wasm")
+JS_PATH = os.path.join(BUILD_PATH, "bergamot-translator-worker.js")
+FINAL_JS_PATH = os.path.join(DIR_PATH, "bergamot-translator.js")
+ROOT_PATH = os.path.join(DIR_PATH, "../../../..")
+
+# 3.1.47 had an error compiling sentencepiece.
+EMSDK_VERSION = "3.1.8"
+EMSDK_REVISION = "2346baa7bb44a4a0571cc75f1986ab9aaa35aa03"
+
+patches = [
+    (BERGAMOT_PATH, os.path.join(PATCHES_PATH, "allocation-bergamot.patch")),
+    (MARIAN_PATH, os.path.join(PATCHES_PATH, "allocation-marian.patch")),
+]
+
+parser = argparse.ArgumentParser(
+    description=__doc__,
+    # Preserves whitespace in the help text.
+    formatter_class=argparse.RawTextHelpFormatter,
+)
+parser.add_argument(
+    "--clobber", action="store_true", help="Clobber the build artifacts"
+)
+parser.add_argument(
+    "--debug",
+    action="store_true",
+    help="Build with debug symbols, useful for profiling",
+)
+
+ArgNamespace = namedtuple("ArgNamespace", ["clobber", "debug"])
+
+
+def git_clone_update(name: str, repo_path: str, repo_url: str, revision: str):
+    if not os.path.exists(repo_path):
+        print(f"\n⬇️ Clone the {name} repo into {repo_path}\n")
+        subprocess.check_call(
+            ["git", "clone", repo_url],
+            cwd=THIRD_PARTY_PATH,
+        )
+
+    local_head = subprocess.check_output(
+        ["git", "rev-parse", "HEAD"],
+        cwd=repo_path,
+        text=True,
+    ).strip()
+
+    def run(command):
+        return subprocess.check_call(command, cwd=repo_path)
+
+    if local_head != revision:
+        print(f"The head ({local_head}) and revision ({revision}) don't match.")
+        print(f"\n🔎 Fetching the latest from {name}.\n")
+        run(["git", "fetch", "--recurse-submodules"])
+
+        print(f"🛒 Checking out the revision {revision}")
+        run(["git", "checkout", revision])
+        run(["git", "submodule", "update", "--init", "--recursive"])
+
+
+def install_and_activate_emscripten(args: ArgNamespace):
+    git_clone_update(
+        name="emsdk",
+        repo_path=EMSDK_PATH,
+        repo_url="https://github.com/emscripten-core/emsdk.git",
+        revision=EMSDK_REVISION,
+    )
+
+    # Run these commands in the shell so that the configuration is saved.
+    def run_shell(command):
+        return subprocess.run(command, cwd=EMSDK_PATH, shell=True, check=True)
+
+    print(f"\n🛠️ Installing EMSDK version {EMSDK_VERSION}\n")
+    run_shell("./emsdk install " + EMSDK_VERSION)
+
+    print("\n🛠️ Activating emsdk\n")
+    run_shell("./emsdk activate " + EMSDK_VERSION)
+
+
+def install_bergamot():
+    with open(MOZ_YAML_PATH, "r", encoding="utf8") as file:
+        text = file.read()
+
+    moz_yaml = yaml.safe_load(text)
+
+    git_clone_update(
+        name="bergamot",
+        repo_path=BERGAMOT_PATH,
+        repo_url=moz_yaml["origin"]["url"],
+        revision=moz_yaml["origin"]["revision"],
+    )
+
+
+def to_human_readable(size):
+    """Convert sizes to human-readable format"""
+    size_in_mb = size / 1048576
+    return f"{size_in_mb:.2f}M ({size} bytes)"
+
+
+def apply_git_patch(repo_path, patch_path):
+    print(f"Applying patch {patch_path} to {os.path.basename(repo_path)}")
+    subprocess.check_call(["git", "apply", "--reject", patch_path], cwd=repo_path)
+
+
+def revert_git_patch(repo_path, patch_path):
+    print(f"Reverting patch {patch_path} from {os.path.basename(repo_path)}")
+    subprocess.check_call(["git", "apply", "-R", "--reject", patch_path], cwd=repo_path)
+
+
+def build_bergamot(args: ArgNamespace):
+    if args.clobber and os.path.exists(BUILD_PATH):
+        shutil.rmtree(BUILD_PATH)
+
+    if not os.path.exists(BUILD_PATH):
+        os.mkdir(BUILD_PATH)
+
+    print("\n 🖌️ Applying source code patches\n")
+    for repo_path, patch_path in patches:
+        apply_git_patch(repo_path, patch_path)
+
+    # These commands require the emsdk environment variables to be set up.
+    def run_shell(command):
+        if '"' in command or "'" in command:
+            raise Exception("This run_shell utility does not support quotes.")
+
+        return subprocess.run(
+            # "source" is not available in all shells so explicitly
+            f"bash -c 'source {EMSDK_ENV_PATH} && {command}'",
+            cwd=BUILD_PATH,
+            shell=True,
+            check=True,
+        )
+
+    try:
+        flags = ""
+        if args.debug:
+            flags = "-DCMAKE_BUILD_TYPE=RelWithDebInfo"
+
+        print("\n 🏃 Running CMake for Bergamot\n")
+        run_shell(
+            f"emcmake cmake -DCOMPILE_WASM=on -DWORMHOLE=off {flags} {BERGAMOT_PATH}"
+        )
+
+        print("\n 🏃 Building Bergamot with emmake\n")
+        run_shell(f"emmake make -j {multiprocessing.cpu_count()}")
+
+        print("\n 🪚 Patching Bergamot for gemm support\n")
+        subprocess.check_call(["bash", GEMM_SCRIPT, BUILD_PATH])
+
+        print("\n✅ Build complete\n")
+        print("  " + JS_PATH)
+        print("  " + WASM_PATH)
+
+        # Get the sizes of the build artifacts.
+        wasm_size = os.path.getsize(WASM_PATH)
+        gzip_size = int(
+            subprocess.run(
+                f"gzip -c {WASM_PATH} | wc -c",
+                check=True,
+                shell=True,
+                capture_output=True,
+            ).stdout.strip()
+        )
+        print(f"  Uncompressed wasm size: {to_human_readable(wasm_size)}")
+        print(f"  Compressed wasm size: {to_human_readable(gzip_size)}")
+    finally:
+        print("\n🖌️ Reverting the source code patches\n")
+        for repo_path, patch_path in patches[::-1]:
+            revert_git_patch(repo_path, patch_path)
+
+
+def write_final_bergamot_js_file():
+    """
+    The generated JS file requires some light patching for integration.
+    """
+
+    source = "\n".join(
+        [
+            "/* This Source Code Form is subject to the terms of the Mozilla Public",
+            " * License, v. 2.0. If a copy of the MPL was not distributed with this",
+            " * file, You can obtain one at http://mozilla.org/MPL/2.0/. */",
+            "",
+            "function loadBergamot(Module) {",
+            "",
+        ]
+    )
+
+    with open(JS_PATH, "r", encoding="utf8") as file:
+        for line in file.readlines():
+            source += "  " + line
+
+    source += "  return Module;\n}"
+
+    # Use the Module's printing.
+    source = source.replace("console.log(", "Module.print(")
+
+    # Add some instrumentation to the module's memory size.
+    source = source.replace(
+        "function updateGlobalBufferAndViews(buf) {",
+        """
+        function updateGlobalBufferAndViews(buf) {
+          const mb = (buf.byteLength / 1_000_000).toFixed();
+          Module.print(
+            `Growing wasm buffer to ${mb}MB (${buf.byteLength} bytes).`
+          );
+    """,
+    )
+
+    print("\n Formatting the final bergamot file")
+    # Create the file outside of this directory so it's not ignored by eslint.
+    temp_path = os.path.join(DIR_PATH, "../temp-bergamot.js")
+    with open(temp_path, "w", encoding="utf8") as file:
+        file.write(source)
+
+    subprocess.run(
+        f"./mach eslint --fix {temp_path}",
+        cwd=ROOT_PATH,
+        check=True,
+        shell=True,
+        capture_output=True,
+    )
+
+    print(f"\n Writing out final bergamot file: {FINAL_JS_PATH}")
+    shutil.move(temp_path, FINAL_JS_PATH)
+
+
+def main():
+    args: ArgNamespace = parser.parse_args()
+
+    if not os.path.exists(THIRD_PARTY_PATH):
+        os.mkdir(THIRD_PARTY_PATH)
+
+    install_and_activate_emscripten(args)
+    install_bergamot()
+    build_bergamot(args)
+    write_final_bergamot_js_file()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/toolkit/components/translations/bergamot-translator/moz.yaml b/toolkit/components/translations/bergamot-translator/moz.yaml
new file mode 100644
index 0000000000..23a4cc8c27
--- /dev/null
+++ b/toolkit/components/translations/bergamot-translator/moz.yaml
@@ -0,0 +1,51 @@
+# Version of this schema
+schema: 1
+
+bugzilla:
+  # Bugzilla product and component for this directory and subdirectories
+  product: Firefox
+  component: Translation
+
+# Document the source of externally hosted code
+origin:
+
+  # Short name of the package/library
+  name: bergamot-translator
+
+  description: The JavaScript emscripten worker to run Project Bergamot.
+
+  # Full URL for the package's homepage/etc
+  # Usually different from repository url
+  url: https://github.com/browsermt/bergamot-translator.git
+
+  # Human-readable identifier for this version/release
+  # Generally "version NNN", "tag SSS", "bookmark SSS"
+  release: v0.4.5
+
+  # Revision to pull in
+  # Must be a long or short commit SHA (long preferred)
+  revision: 05a87784973b6e1cc591f1f1a9a05c5873d9971e
+
+  # The package's license, where possible using the mnemonic from
+  # https://spdx.org/licenses/
+  # Multiple licenses can be specified (as a YAML list)
+  # A "LICENSE" file must exist containing the full license text
+  license: MPL-2.0
+
+  notes: >
+    The generated emscripten code contains many global variables. When updating
+    the code, paste it into the following function to protect the global scope.
+
+    ```
+    /* This Source Code Form is subject to the terms of the Mozilla Public
+     * License, v. 2.0. If a copy of the MPL was not distributed with this
+     * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+    function loadBergamot(Module) {
+      {insertCodeHere}
+      return Module;
+    }
+    ```
+
+    Then replace `console.log()` calls with `log()` calls so that logging preferences
+    are respected.
diff --git a/toolkit/components/translations/bergamot-translator/patches/allocation-bergamot.patch b/toolkit/components/translations/bergamot-translator/patches/allocation-bergamot.patch
new file mode 100644
index 0000000000..a8dca5b7e1
--- /dev/null
+++ b/toolkit/components/translations/bergamot-translator/patches/allocation-bergamot.patch
@@ -0,0 +1,26 @@
+commit dfa705777729fd084f0187a90f9712eb76ea9209
+parent 05a87784973b6e1cc591f1f1a9a05c5873d9971e
+Author: Greg Tatum <tatum.creative@gmail.com>
+Date:   Tue Nov 7 10:57:07 2023 -0600
+
+    Change allocation strategy
+    
+    This fixes an issue where the memory would grow to 500mb by pre-allocating large
+    workspaces. For some reason the "workspace" configuration for the Wasm build wasn't
+    fixing this, but hard-coding the value does. Perhaps the configuration file in Bergamot
+    is not working correctly, or it was just a mistake on the author's part. Empirically
+    this value keeps memory from growing too rapidly, and does not degrade Wasm performance.
+
+diff --git a/src/translator/translation_model.cpp b/src/translator/translation_model.cpp
+index 3f91ebb..61a299f 100644
+--- a/src/translator/translation_model.cpp
++++ b/src/translator/translation_model.cpp
+@@ -59,7 +59,7 @@ void TranslationModel::loadBackend(size_t idx) {
+   graph->setDefaultElementType(typeFromString(prec[0]));
+   graph->setDevice(device_);
+   graph->getBackend()->configureDevice(options_);
+-  graph->reserveWorkspaceMB(options_->get<size_t>("workspace"));
++  graph->reserveWorkspaceMB(5);
+ 
+   // Marian Model: Load from memoryBundle or shortList
+   if (memory_.model.size() > 0 &&
diff --git a/toolkit/components/translations/bergamot-translator/patches/allocation-marian.patch b/toolkit/components/translations/bergamot-translator/patches/allocation-marian.patch
new file mode 100644
index 0000000000..4fe2616d07
--- /dev/null
+++ b/toolkit/components/translations/bergamot-translator/patches/allocation-marian.patch
@@ -0,0 +1,25 @@
+commit 31a05b47381a5b22b57fe9af7805fa40a5c5e384
+parent 11c6ae7c46be21ef96ed10c60f28022fa968939f
+Author: Greg Tatum <tatum.creative@gmail.com>
+Date:   Mon Nov 6 14:01:32 2023 -0600
+
+    Change allocation strategy for tensors
+    
+    When tensors grow, they would pre-emptively allocate large amounts of memory, and
+    would allocate ~500mb of memory for a single translation. Adjusting this value
+    down appears to fix this issue. Empirically this value keeps memory from growing too
+    rapidly, and does not degrade Wasm performance.
+
+diff --git a/src/tensors/tensor_allocator.h b/src/tensors/tensor_allocator.h
+index e3bc79f9..66f8e44d 100644
+--- a/src/tensors/tensor_allocator.h
++++ b/src/tensors/tensor_allocator.h
+@@ -13,7 +13,7 @@ class TensorAllocator {
+ private:
+   const size_t CHUNK = 128;
+   const size_t MBYTE = 1024 * 1024;
+-  const size_t GROW = CHUNK * MBYTE;
++  const size_t GROW = MBYTE;
+   const size_t ALIGN = 256;
+ 
+   Ptr<Backend> backend_;
diff --git a/toolkit/components/translations/bergamot-translator/upload-bergamot.py b/toolkit/components/translations/bergamot-translator/upload-bergamot.py
new file mode 100755
index 0000000000..712eae0e2c
--- /dev/null
+++ b/toolkit/components/translations/bergamot-translator/upload-bergamot.py
@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+"""
+Uploads the bergamot wasm file to Remote Settings. This just uploads the build artifact,
+approval and deployment will still need to be done through Remote Settings. You must
+run ./build-bergamot.py first to generate the wasm artifact.
+
+Log in to Remote Settings via LDAP to either dev or prod:
+
+    Dev: https://remote-settings-dev.allizom.org/v1/admin
+    Prod: https://remote-settings.mozilla.org/v1/admin
+
+In the header click the little clipboard icon to get the authentication header.
+Set the BEARER_TOKEN environment variable to use the bearer token. In zsh this can
+be done privately via the command line with the `setopt HIST_IGNORE_SPACE` and
+adding a space in front of the command, e.g.
+
+` export BEARER_TOKEN="Bearer uLdb-Yafefe....2Hyl5_w"`
+"""
+
+import argparse
+import asyncio
+import json
+import os
+import pprint
+import sys
+import uuid
+from collections import namedtuple
+from textwrap import dedent
+
+import requests
+import yaml
+
+# When running upload-bergamot.py, this number should be bumped for new uploads.
+# A minor version bump means that there is no breaking change. A major version
+# bump means that the upload is a breaking change. Firefox will only download
+# records that match the TranslationsParent.BERGAMOT_MAJOR_VERSION.
+REMOTE_SETTINGS_VERSION = "1.1"
+
+COLLECTION_NAME = "translations-wasm"
+DEV_SERVER = "https://remote-settings-dev.allizom.org/v1"
+PROD_SERVER = "https://remote-settings.mozilla.org/v1"
+
+DIR_PATH = os.path.realpath(os.path.dirname(__file__))
+MOZ_YAML_PATH = os.path.join(DIR_PATH, "moz.yaml")
+THIRD_PARTY_PATH = os.path.join(DIR_PATH, "thirdparty")
+BUILD_PATH = os.path.join(THIRD_PARTY_PATH, "build-wasm")
+WASM_PATH = os.path.join(BUILD_PATH, "bergamot-translator-worker.wasm")
+ROOT_PATH = os.path.join(DIR_PATH, "../../../..")
+BROWSER_VERSION_PATH = os.path.join(ROOT_PATH, "browser/config/version.txt")
+RECORDS_PATH = "/admin/#/buckets/main-workspace/collections/translations-wasm/records"
+
+parser = argparse.ArgumentParser(
+    description=__doc__,
+    # Preserves whitespace in the help text.
+    formatter_class=argparse.RawTextHelpFormatter,
+)
+parser.add_argument("--server", help='Set to either "dev" or "prod"')
+parser.add_argument(
+    "--dry_run", action="store_true", help="Verify the login, but do not upload"
+)
+ArgNamespace = namedtuple("ArgNamespace", ["server", "dry_run"])
+
+pp = pprint.PrettyPrinter(indent=2)
+
+
+def print_error(message):
+    """This is a simple util function."""
+    red = "\033[91m"
+    reset = "\033[0m"
+    print(f"{red}Error:{reset} {message}\n", file=sys.stderr)
+
+
+class RemoteSettings:
+    """
+    After validating the arguments, this class controls the REST operations for
+    communicating with Remote Settings.
+    """
+
+    def __init__(self, server: str, bearer_token: str):
+        self.server: str = server
+        self.bearer_token: str = bearer_token
+
+        with open(MOZ_YAML_PATH, "r", encoding="utf8") as file:
+            moz_yaml_text = file.read()
+        self.moz_yaml = yaml.safe_load(moz_yaml_text)
+
+        self.version: str = REMOTE_SETTINGS_VERSION
+        if not isinstance(self.version, str):
+            print_error("The bergamot remote settings version must be a string.")
+            sys.exit(1)
+
+    async def fetch_json(self, path: str):
+        """Perfrom a simple GET operation and return the JSON results"""
+        url = self.server + path
+        response = requests.get(url, headers=self.get_headers())
+
+        if not response.ok:
+            print_error(f"❌ Failed fetching {url}\nStatus: {response.status_code}")
+            try:
+                print(response.json())
+            except Exception:
+                print_error("Unable to read response")
+            raise Exception()
+
+        return response.json()
+
+    async def verify_login(self):
+        """Before performing any operations, verify the login credentials."""
+        try:
+            json = await self.fetch_json("/")
+        except Exception:
+            print_error("Your login information could not be verified")
+            parser.print_help(sys.stderr)
+            sys.exit(0)
+
+        if "user" not in json:
+            print_error("Your bearer token has expired or is not valid.")
+            parser.print_help(sys.stderr)
+            sys.exit(1)
+
+        print(
+            f"✅ Authorized to use {self.server} as user {json['user']['profile']['email']}"
+        )
+
+    def get_headers(self):
+        return {"Authorization": self.bearer_token}
+
+    async def verify_record_version(self):
+        try:
+            main_records = await self.fetch_json(
+                f"/buckets/main/collections/{COLLECTION_NAME}/records",
+            )
+        except Exception:
+            print_error("Failed to get the main records")
+            sys.exit(1)
+
+        for record in main_records["data"]:
+            if (
+                record["name"] == "bergamot-translator"
+                and record["version"] == self.version
+            ):
+                print("Conflicting record in Remote Settings:", record)
+                print_error(
+                    dedent(
+                        f"""
+                    The version {self.version} already existed in the published records.
+                    You need to bump the major or minor version number in the moz.yaml file.
+                """
+                    )
+                )
+                sys.exit(1)
+
+        try:
+            workspace_records = await self.fetch_json(
+                f"/buckets/main-workspace/collections/{COLLECTION_NAME}/records",
+            )
+        except Exception:
+            print_error("Failed to get the workspace records")
+            sys.exit(1)
+
+        for record in workspace_records["data"]:
+            if (
+                record["name"] == "bergamot-translator"
+                and record["version"] == self.version
+            ):
+                print("Conflicting record in Remote Settings:", record)
+                print_error(
+                    dedent(
+                        f"""
+                    The version {self.version} already existed in the workspace records.
+                    You need to delete the file in the workspace before uploading again.
+
+                    {self.server + RECORDS_PATH}
+                """
+                    )
+                )
+                sys.exit(1)
+
+        print("📦 Packages in the workspace:")
+        for record in workspace_records["data"]:
+            if record["name"] == "bergamot-translator":
+                print(f'   - bergamot-translator@{record["version"]}')
+
+        print(f"✅ Version {self.version} does not conflict, ready for uploading.")
+
+    def create_record(self):
+        name = self.moz_yaml["origin"]["name"]
+        release = self.moz_yaml["origin"]["release"]
+        revision = self.moz_yaml["origin"]["revision"]
+        license = self.moz_yaml["origin"]["license"]
+        version = REMOTE_SETTINGS_VERSION
+
+        if not name or not release or not revision or not license or not version:
+            print_error("Some of the required record data is not in the moz.yaml file.")
+            sys.exit(1)
+
+        with open(BROWSER_VERSION_PATH, "r", encoding="utf8") as file:
+            fx_release = file.read().strip()
+
+        files = [
+            (
+                "attachment",
+                (
+                    os.path.basename(WASM_PATH),  # filename
+                    open(WASM_PATH, "rb"),  # file handle
+                    "application/wasm",  # mimetype
+                ),
+            )
+        ]
+
+        data = {
+            "name": name,
+            "release": release,
+            "revision": revision,
+            "license": license,
+            "version": version,
+            "fx_release": fx_release,
+            # Default to nightly and local builds.
+            "filter_expression": "env.channel == 'nightly' || env.channel == 'default'",
+        }
+
+        print("📬 Posting record")
+        print("✉️ Attachment: ", WASM_PATH)
+        print("📀 Record: ", end="")
+        pp.pprint(data)
+
+        return files, data
+
+    def upload_record(self, files, data):
+        id = str(uuid.uuid4())
+        url = f"{self.server}/buckets/main-workspace/collections/{COLLECTION_NAME}/records/{id}/attachment"
+
+        print(f"\n⬆️ POSTing the record to: {url}\n")
+        response = requests.post(
+            url,
+            headers=self.get_headers(),
+            data={"data": json.dumps(data)},
+            files=files,
+        )
+
+        if response.status_code >= 200 and response.status_code < 300:
+            print("✅ Record created:", self.server + RECORDS_PATH)
+            print("✉️ Attachment details: ", end="")
+            pp.pprint(json.loads(response.text))
+        else:
+            print_error(
+                f"Error creating record: (Error code {response.status_code})\n{response.text}"
+            )
+            raise Exception()
+
+
+async def main():
+    if len(sys.argv) == 1:
+        parser.print_help(sys.stderr)
+        sys.exit(1)
+
+    args: ArgNamespace = parser.parse_args()
+
+    bearer_token = os.environ.get("BEARER_TOKEN")
+    if not bearer_token:
+        print_error('A "BEARER_TOKEN" environment variable must be set.')
+        parser.print_help(sys.stderr)
+        sys.exit(1)
+
+    if args.server == "prod":
+        server = PROD_SERVER
+    elif args.server == "dev":
+        server = DEV_SERVER
+    else:
+        print_error('The server must either be "prod" or "dev"')
+        parser.print_help(sys.stderr)
+        sys.exit(1)
+
+    remote_settings = RemoteSettings(server, bearer_token)
+
+    await remote_settings.verify_login()
+    await remote_settings.verify_record_version()
+
+    files, data = remote_settings.create_record()
+    if args.dry_run:
+        return
+
+    remote_settings.upload_record(files, data)
+
+
+if __name__ == "__main__":
+    loop = asyncio.get_event_loop()
+    loop.run_until_complete(main())