idmission-web-sdk 2.3.99 → 2.3.101

package/dist/sdk2.umd.development.js

@@ -1,9 +1,10 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('react-dom/client'), require('platform'), require('styled-components'), require('react-dom'), require('tus-js-client'), require('prop-types'), require('mediainfo.js'), require('react-dom/server')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react', 'react-dom/client', 'platform', 'styled-components', 'react-dom', 'tus-js-client', 'prop-types', 'mediainfo.js', 'react-dom/server'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Sdk2 = {}, global.React, global.ReactDOM, global.platform, global.styled, global.ReactDOM, global.tusJsClient, global.PropTypes, global.mediainfo_js, global.server));
-})(this, (function (exports, React, ReactDOM, platform, styled, reactDom, tusJsClient, require$$0, mediainfo_js, server) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('react-dom/client'), require('platform'), require('styled-components'), require('react-dom'), require('tus-js-client'), require('prop-types'), require('react-dom/server')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', 'react-dom/client', 'platform', 'styled-components', 'react-dom', 'tus-js-client', 'prop-types', 'react-dom/server'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Sdk2 = {}, global.React, global.ReactDOM, global.platform, global.styled, global.ReactDOM, global.tusJsClient, global.PropTypes, global.server));
+})(this, (function (exports, React, ReactDOM, platform, styled, reactDom, tusJsClient, require$$0, server) { 'use strict';
 
+  var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
   function _interopNamespaceDefault(e) {
     var n = Object.create(null);
     if (e) {
@@ -211,7 +212,7 @@
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
   };
 
-  var webSdkVersion = '2.3.99';
+  var webSdkVersion = '2.3.101';
 
   function getPlatform() {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -3615,9 +3616,9 @@
   }
   var _regeneratorRuntime = /*@__PURE__*/getDefaultExportFromCjs(regenerator);
 
-  function _createForOfIteratorHelperLoose$2(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray$2(r)) || e) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-  function _unsupportedIterableToArray$2(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$2(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$2(r, a) : void 0; } }
-  function _arrayLikeToArray$2(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+  function _createForOfIteratorHelperLoose$3(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray$3(r)) || e) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+  function _unsupportedIterableToArray$3(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$3(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$3(r, a) : void 0; } }
+  function _arrayLikeToArray$3(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
   var t = self;
   function e() {
     throw Error("Invalid UTF8");
@@ -5844,7 +5845,7 @@
       height: (_hn4 = hn(e, 4)) != null ? _hn4 : 0,
       angle: 0
     }), (_en2 = en$1(t, ws, 4)) != null && _en2.g().length) {
-      for (var _iterator = _createForOfIteratorHelperLoose$2(en$1(t, ws, 4).g()), _step; !(_step = _iterator()).done;) {
+      for (var _iterator = _createForOfIteratorHelperLoose$3(en$1(t, ws, 4).g()), _step; !(_step = _iterator()).done;) {
         var _We, _We2, _We3, _un3;
         var _e16 = _step.value;
         i.keypoints.push({
@@ -5859,7 +5860,7 @@
   }
   function Qi(t) {
     var e = [];
-    for (var _iterator2 = _createForOfIteratorHelperLoose$2(rn(t, Fs, 1)), _step2; !(_step2 = _iterator2()).done;) {
+    for (var _iterator2 = _createForOfIteratorHelperLoose$3(rn(t, Fs, 1)), _step2; !(_step2 = _iterator2()).done;) {
       var _fn2, _fn3, _fn4;
       var _n14 = _step2.value;
       e.push({
@@ -5872,7 +5873,7 @@
   }
   function to(t) {
     var e = [];
-    for (var _iterator3 = _createForOfIteratorHelperLoose$2(rn(t, Ts, 1)), _step3; !(_step3 = _iterator3()).done;) {
+    for (var _iterator3 = _createForOfIteratorHelperLoose$3(rn(t, Ts, 1)), _step3; !(_step3 = _iterator3()).done;) {
       var _fn5, _fn6, _fn7;
       var _n15 = _step3.value;
       e.push({
@@ -6020,7 +6021,7 @@
     var r = new Uint32Array(e.length);
     for (var _n16 = 0; _n16 < e.length; _n16++) r[_n16] = t.i.stringToNewUTF8(e[_n16]);
     e = t.i._malloc(4 * r.length), t.i.HEAPU32.set(r, e >> 2), n(e);
-    for (var _iterator4 = _createForOfIteratorHelperLoose$2(r), _step4; !(_step4 = _iterator4()).done;) {
+    for (var _iterator4 = _createForOfIteratorHelperLoose$3(r), _step4; !(_step4 = _iterator4()).done;) {
       var _e17 = _step4.value;
       t.i._free(_e17);
     }
@@ -6386,7 +6387,7 @@
         }
         t.push(n);
       };
-      for (var _iterator7 = _createForOfIteratorHelperLoose$2(this.g), _step7; !(_step7 = _iterator7()).done;) {
+      for (var _iterator7 = _createForOfIteratorHelperLoose$3(this.g), _step7; !(_step7 = _iterator7()).done;) {
         _loop();
       }
       return new _Yo(t, this.ba(), this.K(), this.canvas, this.l, this.width, this.height);
@@ -6518,7 +6519,7 @@
           }
           t.push(n);
         };
-        for (var _iterator8 = _createForOfIteratorHelperLoose$2(this.g), _step8; !(_step8 = _iterator8()).done;) {
+        for (var _iterator8 = _createForOfIteratorHelperLoose$3(this.g), _step8; !(_step8 = _iterator8()).done;) {
           _loop2();
         }
         return new _ia(t, this.K(), this.canvas, this.l, this.width, this.height);
@@ -6998,7 +6999,7 @@
       yn(e, si, this.h);
       var n = new qr();
       Hr(n, "mediapipe.tasks.vision.face_detector.FaceDetectorGraph"), Yr(n, "IMAGE:image_in"), Yr(n, "NORM_RECT:norm_rect_in"), $r(n, "DETECTIONS:detections"), n.o(e), es$1(t, n), this.g.attachProtoVectorListener("detections", function (t, e) {
-        for (var _iterator9 = _createForOfIteratorHelperLoose$2(t), _step9; !(_step9 = _iterator9()).done;) {
+        for (var _iterator9 = _createForOfIteratorHelperLoose$3(t), _step9; !(_step9 = _iterator9()).done;) {
           var _e23 = _step9.value;
           t = Es(_e23), _this43.j.detections.push(Zi(t));
         }
@@ -7092,7 +7093,7 @@
       yn(e, di, this.h);
       var n = new qr();
       Hr(n, "mediapipe.tasks.vision.face_landmarker.FaceLandmarkerGraph"), Yr(n, "IMAGE:image_in"), Yr(n, "NORM_RECT:norm_rect"), $r(n, "NORM_LANDMARKS:face_landmarks"), n.o(e), es$1(t, n), this.g.attachProtoVectorListener("face_landmarks", function (t, e) {
-        for (var _iterator10 = _createForOfIteratorHelperLoose$2(t), _step10; !(_step10 = _iterator10()).done;) {
+        for (var _iterator10 = _createForOfIteratorHelperLoose$3(t), _step10; !(_step10 = _iterator10()).done;) {
           var _e24 = _step10.value;
           t = Ms(_e24), _this45.j.faceLandmarks.push(Qi(t));
         }
@@ -7101,7 +7102,7 @@
         _o(_this45, t);
       }), this.outputFaceBlendshapes && (rs(t, "blendshapes"), $r(n, "BLENDSHAPES:blendshapes"), this.g.attachProtoVectorListener("blendshapes", function (t, e) {
         if (_this45.outputFaceBlendshapes) {
-          for (var _iterator11 = _createForOfIteratorHelperLoose$2(t), _step11; !(_step11 = _iterator11()).done;) {
+          for (var _iterator11 = _createForOfIteratorHelperLoose$3(t), _step11; !(_step11 = _iterator11()).done;) {
             var _t$g;
             var _e25 = _step11.value;
             t = fs(_e25), _this45.j.faceBlendshapes.push(Ji((_t$g = t.g()) != null ? _t$g : []));
@@ -7112,7 +7113,7 @@
         _o(_this45, t);
       })), this.outputFacialTransformationMatrixes && (rs(t, "face_geometry"), $r(n, "FACE_GEOMETRY:face_geometry"), this.g.attachProtoVectorListener("face_geometry", function (t, e) {
         if (_this45.outputFacialTransformationMatrixes) {
-          for (var _iterator12 = _createForOfIteratorHelperLoose$2(t), _step12; !(_step12 = _iterator12()).done;) {
+          for (var _iterator12 = _createForOfIteratorHelperLoose$3(t), _step12; !(_step12 = _iterator12()).done;) {
             var _ln2, _ln3, _He;
             var _e26 = _step12.value;
             (t = en$1(ai(_e26), Ps, 2)) && _this45.j.facialTransformationMatrixes.push({
@@ -7243,11 +7244,11 @@
       e = !0;
     }
     var n = [];
-    for (var _iterator13 = _createForOfIteratorHelperLoose$2(t), _step13; !(_step13 = _iterator13()).done;) {
+    for (var _iterator13 = _createForOfIteratorHelperLoose$3(t), _step13; !(_step13 = _iterator13()).done;) {
       var _s9 = _step13.value;
       var r = fs(_s9);
       t = [];
-      for (var _iterator14 = _createForOfIteratorHelperLoose$2(r.g()), _step14; !(_step14 = _iterator14()).done;) {
+      for (var _iterator14 = _createForOfIteratorHelperLoose$3(r.g()), _step14; !(_step14 = _iterator14()).done;) {
         var _fn8, _ref9, _un4, _ref10, _un5;
         var _n24 = _step14.value;
         r = e && null != hn(_n24, 1) ? ln(hn(_n24, 1)) : -1, t.push({
@@ -7293,11 +7294,11 @@
       yn(e, Oi, this.v);
       var n = new qr();
       Hr(n, "mediapipe.tasks.vision.gesture_recognizer.GestureRecognizerGraph"), Yr(n, "IMAGE:image_in"), Yr(n, "NORM_RECT:norm_rect"), $r(n, "HAND_GESTURES:hand_gestures"), $r(n, "LANDMARKS:hand_landmarks"), $r(n, "WORLD_LANDMARKS:world_hand_landmarks"), $r(n, "HANDEDNESS:handedness"), n.o(e), es$1(t, n), this.g.attachProtoVectorListener("hand_landmarks", function (t, e) {
-        for (var _iterator15 = _createForOfIteratorHelperLoose$2(t), _step15; !(_step15 = _iterator15()).done;) {
+        for (var _iterator15 = _createForOfIteratorHelperLoose$3(t), _step15; !(_step15 = _iterator15()).done;) {
           var _e28 = _step15.value;
           t = Ms(_e28);
           var _n25 = [];
-          for (var _iterator16 = _createForOfIteratorHelperLoose$2(rn(t, Fs, 1)), _step16; !(_step16 = _iterator16()).done;) {
+          for (var _iterator16 = _createForOfIteratorHelperLoose$3(rn(t, Fs, 1)), _step16; !(_step16 = _iterator16()).done;) {
             var _fn9, _fn10, _fn11;
             var _e29 = _step16.value;
             _n25.push({
@@ -7312,11 +7313,11 @@
       }), this.g.attachEmptyPacketListener("hand_landmarks", function (t) {
         _o(_this49, t);
       }), this.g.attachProtoVectorListener("world_hand_landmarks", function (t, e) {
-        for (var _iterator17 = _createForOfIteratorHelperLoose$2(t), _step17; !(_step17 = _iterator17()).done;) {
+        for (var _iterator17 = _createForOfIteratorHelperLoose$3(t), _step17; !(_step17 = _iterator17()).done;) {
           var _e30 = _step17.value;
           t = Ls(_e30);
           var _n26 = [];
-          for (var _iterator18 = _createForOfIteratorHelperLoose$2(rn(t, Ts, 1)), _step18; !(_step18 = _iterator18()).done;) {
+          for (var _iterator18 = _createForOfIteratorHelperLoose$3(rn(t, Ts, 1)), _step18; !(_step18 = _iterator18()).done;) {
             var _fn12, _fn13, _fn14;
             var _e31 = _step18.value;
             _n26.push({
@@ -7401,7 +7402,7 @@
       yn(e, Si, this.j);
       var n = new qr();
       Hr(n, "mediapipe.tasks.vision.hand_landmarker.HandLandmarkerGraph"), Yr(n, "IMAGE:image_in"), Yr(n, "NORM_RECT:norm_rect"), $r(n, "LANDMARKS:hand_landmarks"), $r(n, "WORLD_LANDMARKS:world_hand_landmarks"), $r(n, "HANDEDNESS:handedness"), n.o(e), es$1(t, n), this.g.attachProtoVectorListener("hand_landmarks", function (t, e) {
-        for (var _iterator19 = _createForOfIteratorHelperLoose$2(t), _step19; !(_step19 = _iterator19()).done;) {
+        for (var _iterator19 = _createForOfIteratorHelperLoose$3(t), _step19; !(_step19 = _iterator19()).done;) {
           var _e32 = _step19.value;
           t = Ms(_e32), _this51.landmarks.push(Qi(t));
         }
@@ -7409,7 +7410,7 @@
       }), this.g.attachEmptyPacketListener("hand_landmarks", function (t) {
         _o(_this51, t);
       }), this.g.attachProtoVectorListener("world_hand_landmarks", function (t, e) {
-        for (var _iterator20 = _createForOfIteratorHelperLoose$2(t), _step20; !(_step20 = _iterator20()).done;) {
+        for (var _iterator20 = _createForOfIteratorHelperLoose$3(t), _step20; !(_step20 = _iterator20()).done;) {
           var _e33 = _step20.value;
           t = Ls(_e33), _this51.worldLandmarks.push(to(t));
         }
@@ -7420,11 +7421,11 @@
         var n = _this51.handedness,
           r = n.push;
         var s = [];
-        for (var _iterator21 = _createForOfIteratorHelperLoose$2(t), _step21; !(_step21 = _iterator21()).done;) {
+        for (var _iterator21 = _createForOfIteratorHelperLoose$3(t), _step21; !(_step21 = _iterator21()).done;) {
           var _e34 = _step21.value;
           t = fs(_e34);
           var _n27 = [];
-          for (var _iterator22 = _createForOfIteratorHelperLoose$2(t.g()), _step22; !(_step22 = _iterator22()).done;) {
+          for (var _iterator22 = _createForOfIteratorHelperLoose$3(t.g()), _step22; !(_step22 = _iterator22()).done;) {
             var _fn15, _ln4, _ref11, _un6, _ref12, _un7;
             var _e35 = _step22.value;
             _n27.push({
@@ -7816,7 +7817,7 @@
         dn(a, 3, !0), gn(a, 1, e.keypoint.x), gn(a, 2, e.keypoint.y), on(i, 5, oh, a);
       } else {
         if (!e.scribble) throw Error("Must provide either a keypoint or a scribble.");
-        for (var _iterator23 = _createForOfIteratorHelperLoose$2((o = new sh(), e.scribble)), _step23; !(_step23 = _iterator23()).done;) {
+        for (var _iterator23 = _createForOfIteratorHelperLoose$3((o = new sh(), e.scribble)), _step23; !(_step23 = _iterator23()).done;) {
           a = _step23.value;
           dn(e = new nh(), 3, !0), gn(e, 1, a.x), gn(e, 2, a.y), an(o, nh, e);
         }
@@ -7917,7 +7918,7 @@
       yn(e, Vi, this.h);
       var n = new qr();
       Hr(n, "mediapipe.tasks.vision.ObjectDetectorGraph"), Yr(n, "IMAGE:input_frame_gpu"), Yr(n, "NORM_RECT:norm_rect"), $r(n, "DETECTIONS:detections"), n.o(e), es$1(t, n), this.g.attachProtoVectorListener("detections", function (t, e) {
-        for (var _iterator24 = _createForOfIteratorHelperLoose$2(t), _step24; !(_step24 = _iterator24()).done;) {
+        for (var _iterator24 = _createForOfIteratorHelperLoose$3(t), _step24; !(_step24 = _iterator24()).done;) {
           var _e37 = _step24.value;
           t = Es(_e37), _this61.j.detections.push(Zi(t));
         }
@@ -8017,7 +8018,7 @@
       var n = new qr();
       Hr(n, "mediapipe.tasks.vision.pose_landmarker.PoseLandmarkerGraph"), Yr(n, "IMAGE:image_in"), Yr(n, "NORM_RECT:norm_rect"), $r(n, "NORM_LANDMARKS:normalized_landmarks"), $r(n, "WORLD_LANDMARKS:world_landmarks"), n.o(e), es$1(t, n), wo(this, t), this.g.attachProtoVectorListener("normalized_landmarks", function (t, e) {
         _this63.landmarks = [];
-        for (var _iterator25 = _createForOfIteratorHelperLoose$2(t), _step25; !(_step25 = _iterator25()).done;) {
+        for (var _iterator25 = _createForOfIteratorHelperLoose$3(t), _step25; !(_step25 = _iterator25()).done;) {
           var _e39 = _step25.value;
           t = Ms(_e39), _this63.landmarks.push(Qi(t));
         }
@@ -8026,7 +8027,7 @@
         _this63.landmarks = [], _o(_this63, t);
       }), this.g.attachProtoVectorListener("world_landmarks", function (t, e) {
         _this63.worldLandmarks = [];
-        for (var _iterator26 = _createForOfIteratorHelperLoose$2(t), _step26; !(_step26 = _iterator26()).done;) {
+        for (var _iterator26 = _createForOfIteratorHelperLoose$3(t), _step26; !(_step26 = _iterator26()).done;) {
           var _e40 = _step26.value;
           t = Ls(_e40), _this63.worldLandmarks.push(to(t));
         }
@@ -9504,9 +9505,9 @@
     return e;
   }
 
-  function _createForOfIteratorHelperLoose$1(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray$1(r)) || e) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-  function _unsupportedIterableToArray$1(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$1(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$1(r, a) : void 0; } }
-  function _arrayLikeToArray$1(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+  function _createForOfIteratorHelperLoose$2(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray$2(r)) || e) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+  function _unsupportedIterableToArray$2(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$2(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$2(r, a) : void 0; } }
+  function _arrayLikeToArray$2(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
   var consoleLogger = {
     type: 'logger',
     log: function log(args) {
@@ -10353,7 +10354,7 @@
       }
       if (!useOptionsReplaceForData) {
         data = _extends({}, data);
-        for (var _iterator = _createForOfIteratorHelperLoose$1(optionsKeys), _step; !(_step = _iterator()).done;) {
+        for (var _iterator = _createForOfIteratorHelperLoose$2(optionsKeys), _step; !(_step = _iterator()).done;) {
           var key = _step.value;
           delete data[key];
         }
@@ -14945,7 +14946,7 @@
     });
   }
 
-  var _excluded = ["enabled", "anonymousActionType", "store"],
+  var _excluded$1 = ["enabled", "anonymousActionType", "store"],
     _excluded2 = ["connection"];
   var trackedConnections = /* @__PURE__ */new Map();
   var getTrackedConnectionState = function getTrackedConnectionState(name) {
@@ -14990,7 +14991,7 @@
         enabled = _devtoolsOptions.enabled,
         anonymousActionType = _devtoolsOptions.anonymousActionType,
         store = _devtoolsOptions.store,
-        options = _objectWithoutPropertiesLoose(_devtoolsOptions, _excluded);
+        options = _objectWithoutPropertiesLoose(_devtoolsOptions, _excluded$1);
       var extensionConnector;
       try {
         extensionConnector = (enabled != null ? enabled : (undefined ? undefined.MODE : void 0) !== "production") && window.__REDUX_DEVTOOLS_EXTENSION__;
@@ -15151,9 +15152,9 @@
     if (parsed !== void 0) f(parsed);
   };
 
-  function _createForOfIteratorHelperLoose(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-  function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-  function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+  function _createForOfIteratorHelperLoose$1(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray$1(r)) || e) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+  function _unsupportedIterableToArray$1(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray$1(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray$1(r, a) : void 0; } }
+  function _arrayLikeToArray$1(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
   var isIterable = function isIterable(obj) {
     return Symbol.iterator in obj;
   };
@@ -15169,7 +15170,7 @@
     if (mapA.size !== mapB.size) {
       return false;
     }
-    for (var _iterator = _createForOfIteratorHelperLoose(mapA), _step; !(_step = _iterator()).done;) {
+    for (var _iterator = _createForOfIteratorHelperLoose$1(mapA), _step; !(_step = _iterator()).done;) {
       var _step$value = _step.value,
         key = _step$value[0],
         value = _step$value[1];
@@ -24200,23 +24201,10 @@
     return t.length > 0 ? t : undefined;
   }
 
-  function makeReadChunk(file) {
-    var _this = this;
-    return function (chunkSize, offset) {
-      return __awaiter(_this, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-          switch (_b.label) {
-            case 0:
-              _a = Uint8Array.bind;
-              return [4 /*yield*/, file.slice(offset, offset + chunkSize).arrayBuffer()];
-            case 1:
-              return [2 /*return*/, new (_a.apply(Uint8Array, [void 0, _b.sent()]))()];
-          }
-        });
-      });
-    };
-  }
+  // function makeReadChunk(file: File | Blob): ReadChunkFunc {
+  //   return async (chunkSize: number, offset: number) =>
+  //     new Uint8Array(await file.slice(offset, offset + chunkSize).arrayBuffer())
+  // }
   var signatureRecorder = null;
   var signatureChunks = [];
   var videoSignatureInitialState = {
@@ -24297,42 +24285,39 @@
           signatureRecorder.stop();
           signatureRecorder.onstop = function () {
             return __awaiter(void 0, void 0, void 0, function () {
-              var recordingStoppedAt, inferredType, blob, _a, onSignatureVideoCaptured, recordingStartRequestedAt, recordingStartedAt, firstChunkReceivedAt, signatureStartedAt, signatureEndedAt, recordingStopRequestedAt, lastChunkReceivedAt, mediaInfo;
-              var _b;
-              return __generator(this, function (_c) {
-                switch (_c.label) {
-                  case 0:
-                    recordingStoppedAt = performance.now();
-                    set({
-                      recordingStoppedAt: recordingStoppedAt
-                    });
-                    inferredType = inferBlobType(signatureChunks[0]) || (signatureRecorder === null || signatureRecorder === void 0 ? void 0 : signatureRecorder.mimeType) || 'video/mp4';
-                    blob = new Blob(signatureChunks, {
-                      type: inferredType
-                    });
-                    signatureChunks = [];
-                    signatureRecorder = null;
-                    if (!signatureData) return [2 /*return*/];
-                    _a = get(), onSignatureVideoCaptured = _a.onSignatureVideoCaptured, recordingStartRequestedAt = _a.recordingStartRequestedAt, recordingStartedAt = _a.recordingStartedAt, firstChunkReceivedAt = _a.firstChunkReceivedAt, signatureStartedAt = _a.signatureStartedAt, signatureEndedAt = _a.signatureEndedAt, recordingStopRequestedAt = _a.recordingStopRequestedAt, lastChunkReceivedAt = _a.lastChunkReceivedAt;
-                    return [4 /*yield*/, (_b = get().mediaInfo) === null || _b === void 0 ? void 0 : _b.analyzeData(blob.size, makeReadChunk(blob))];
-                  case 1:
-                    mediaInfo = _c.sent();
-                    onSignatureVideoCaptured(blob, signatureData, imageUrl !== null && imageUrl !== void 0 ? imageUrl : null, {
-                      mediaInfo: mediaInfo,
-                      mimeType: inferredType,
-                      timingData: {
-                        recordingStartRequestedAt: recordingStartRequestedAt,
-                        recordingStartedAt: recordingStartedAt,
-                        firstChunkReceivedAt: firstChunkReceivedAt,
-                        signatureStartedAt: signatureStartedAt,
-                        signatureEndedAt: signatureEndedAt,
-                        recordingStopRequestedAt: recordingStopRequestedAt,
-                        recordingStoppedAt: recordingStoppedAt,
-                        lastChunkReceivedAt: lastChunkReceivedAt
-                      }
-                    });
-                    return [2 /*return*/];
-                }
+              var recordingStoppedAt, inferredType, blob, _a, onSignatureVideoCaptured, recordingStartRequestedAt, recordingStartedAt, firstChunkReceivedAt, signatureStartedAt, signatureEndedAt, recordingStopRequestedAt, lastChunkReceivedAt;
+              return __generator(this, function (_b) {
+                recordingStoppedAt = performance.now();
+                set({
+                  recordingStoppedAt: recordingStoppedAt
+                });
+                inferredType = inferBlobType(signatureChunks[0]) || (signatureRecorder === null || signatureRecorder === void 0 ? void 0 : signatureRecorder.mimeType) || 'video/mp4';
+                blob = new Blob(signatureChunks, {
+                  type: inferredType
+                });
+                signatureChunks = [];
+                signatureRecorder = null;
+                if (!signatureData) return [2 /*return*/];
+                _a = get(), onSignatureVideoCaptured = _a.onSignatureVideoCaptured, recordingStartRequestedAt = _a.recordingStartRequestedAt, recordingStartedAt = _a.recordingStartedAt, firstChunkReceivedAt = _a.firstChunkReceivedAt, signatureStartedAt = _a.signatureStartedAt, signatureEndedAt = _a.signatureEndedAt, recordingStopRequestedAt = _a.recordingStopRequestedAt, lastChunkReceivedAt = _a.lastChunkReceivedAt;
+                // const mediaInfo = await get().mediaInfo?.analyzeData(
+                //   blob.size,
+                //   makeReadChunk(blob),
+                // )
+                onSignatureVideoCaptured(blob, signatureData, imageUrl !== null && imageUrl !== void 0 ? imageUrl : null, {
+                  // mediaInfo,
+                  mimeType: inferredType,
+                  timingData: {
+                    recordingStartRequestedAt: recordingStartRequestedAt,
+                    recordingStartedAt: recordingStartedAt,
+                    firstChunkReceivedAt: firstChunkReceivedAt,
+                    signatureStartedAt: signatureStartedAt,
+                    signatureEndedAt: signatureEndedAt,
+                    recordingStopRequestedAt: recordingStopRequestedAt,
+                    recordingStoppedAt: recordingStoppedAt,
+                    lastChunkReceivedAt: lastChunkReceivedAt
+                  }
+                });
+                return [2 /*return*/];
               });
             });
           };
@@ -24396,27 +24381,50 @@
     var frameCheckCanvas = React.useRef(null);
     React.useEffect(function () {
       if (!captureMediaInfo) return;
-      mediainfo_js.mediaInfoFactory({
-        format: 'object',
-        full: true,
-        locateFile: function locateFile(filename) {
-          return "".concat(DEFAULT_CDN_URL, "/").concat(filename);
-        }
-      }).then(function (mediaInfo) {
-        useVideoSignatureStore.setState({
-          mediaInfo: mediaInfo
+      // Use dynamic import to avoid build-time WASM loading issues
+      var loadMediaInfo = function loadMediaInfo() {
+        return __awaiter(_this, void 0, void 0, function () {
+          var mediaInfoFactory, e_1;
+          return __generator(this, function (_a) {
+            switch (_a.label) {
+              case 0:
+                _a.trys.push([0, 3,, 4]);
+                return [4 /*yield*/, Promise.resolve().then(function () { return index; })
+                // const mediaInfo =
+                ];
+              case 1:
+                mediaInfoFactory = _a.sent().mediaInfoFactory;
+                // const mediaInfo =
+                return [4 /*yield*/, mediaInfoFactory({
+                  format: 'object',
+                  full: true,
+                  locateFile: function locateFile(filename) {
+                    return "".concat(DEFAULT_CDN_URL, "/").concat(filename);
+                  }
+                })
+                // useVideoSignatureStore.setState({ mediaInfo })
+                ];
+              case 2:
+                // const mediaInfo =
+                _a.sent();
+                return [3 /*break*/, 4];
+              case 3:
+                e_1 = _a.sent();
+                warn('error loading mediaInfo', e_1);
+                return [3 /*break*/, 4];
+              case 4:
+                return [2 /*return*/];
+            }
+          });
         });
-      })["catch"](function (e) {
-        warn('error loading mediaInfo', e);
-      });
+      };
+      loadMediaInfo();
       return function () {
-        var mediaInfo = useVideoSignatureStore.getState().mediaInfo;
-        if (mediaInfo) {
-          mediaInfo.close();
-          useVideoSignatureStore.setState({
-            mediaInfo: undefined
-          });
-        }
+        // const mediaInfo = useVideoSignatureStore.getState().mediaInfo
+        // if (mediaInfo) {
+        // mediaInfo.close()
+        // useVideoSignatureStore.setState({ mediaInfo: undefined })
+        // }
       };
     }, [captureMediaInfo]);
     var signaturePadEmpty = useVideoSignatureStore().signaturePadEmpty;
@@ -29370,6 +29378,8 @@
       documentServiceUrl = _a.documentServiceUrl,
       sendBase64DocumentsInSwaggerProxy = _a.sendBase64DocumentsInSwaggerProxy,
       useDocumentServiceForLivenessChecks = _a.useDocumentServiceForLivenessChecks,
+      _c = _a.captureMediaInfo,
+      captureMediaInfo = _c === void 0 ? false : _c,
       onLoadingStarted = _a.onLoadingStarted,
       onLoadingProgress = _a.onLoadingProgress,
       onLoadingCompleted = _a.onLoadingCompleted,
@@ -29389,48 +29399,48 @@
       onCameraAccessDenied = _a.onCameraAccessDenied,
       onCameraTamperingDetected = _a.onCameraTamperingDetected,
       onLoadingOverlayDismissed = _a.onLoadingOverlayDismissed,
-      _c = _a.loadingOverlayMode,
-      loadingOverlayMode = _c === void 0 ? 'default' : _c,
+      _d = _a.loadingOverlayMode,
+      loadingOverlayMode = _d === void 0 ? 'default' : _d,
       customOverlayContent = _a.customOverlayContent,
-      _d = _a.skipSuccessScreen,
-      skipSuccessScreen = _d === void 0 ? false : _d,
-      _e = _a.captureAudio,
-      captureAudio = _e === void 0 ? false : _e,
+      _e = _a.skipSuccessScreen,
+      skipSuccessScreen = _e === void 0 ? false : _e,
+      _f = _a.captureAudio,
+      captureAudio = _f === void 0 ? false : _f,
       idCardForFaceMatch = _a.idCardForFaceMatch,
-      _f = _a.minSignaturePadPoints,
-      minSignaturePadPoints = _f === void 0 ? DEFAULT_MIN_SIGNATURE_PAD_POINTS : _f,
-      _g = _a.headTrackingDisabled,
-      headTrackingDisabled = _g === void 0 ? false : _g,
-      _h = _a.headTrackingBoundaryPercentage,
-      headTrackingBoundaryPercentage = _h === void 0 ? DEFAULT_HEAD_TRACKING_BOUNDARY_PERCENTAGE : _h,
-      _j = _a.headTrackingBoundaryType,
-      headTrackingBoundaryType = _j === void 0 ? DEFAULT_HEAD_TRACKING_BOUNDARY_TYPE : _j,
-      _k = _a.modelLoadTimeoutMs,
-      modelLoadTimeoutMs = _k === void 0 ? defaultSelfieCaptureModelLoadTimeoutMs : _k,
-      _l = _a.allowSignatureAfterLivenessCheckFailure,
-      allowSignatureAfterLivenessCheckFailure = _l === void 0 ? false : _l,
-      _m = _a.restartVideoOnSignaturePadCleared,
-      restartVideoOnSignaturePadCleared = _m === void 0 ? true : _m,
+      _g = _a.minSignaturePadPoints,
+      minSignaturePadPoints = _g === void 0 ? DEFAULT_MIN_SIGNATURE_PAD_POINTS : _g,
+      _h = _a.headTrackingDisabled,
+      headTrackingDisabled = _h === void 0 ? false : _h,
+      _j = _a.headTrackingBoundaryPercentage,
+      headTrackingBoundaryPercentage = _j === void 0 ? DEFAULT_HEAD_TRACKING_BOUNDARY_PERCENTAGE : _j,
+      _k = _a.headTrackingBoundaryType,
+      headTrackingBoundaryType = _k === void 0 ? DEFAULT_HEAD_TRACKING_BOUNDARY_TYPE : _k,
+      _l = _a.modelLoadTimeoutMs,
+      modelLoadTimeoutMs = _l === void 0 ? defaultSelfieCaptureModelLoadTimeoutMs : _l,
+      _m = _a.allowSignatureAfterLivenessCheckFailure,
+      allowSignatureAfterLivenessCheckFailure = _m === void 0 ? false : _m,
+      _o = _a.restartVideoOnSignaturePadCleared,
+      restartVideoOnSignaturePadCleared = _o === void 0 ? true : _o,
       faceLivenessProps = _a.faceLivenessProps,
-      _o = _a.skipLivenessValidation,
-      skipLivenessValidation = _o === void 0 ? false : _o,
-      _p = _a.allowManualSelfieCaptureOnLoadingError,
-      allowManualSelfieCaptureOnLoadingError = _p === void 0 ? false : _p,
+      _p = _a.skipLivenessValidation,
+      skipLivenessValidation = _p === void 0 ? false : _p,
+      _q = _a.allowManualSelfieCaptureOnLoadingError,
+      allowManualSelfieCaptureOnLoadingError = _q === void 0 ? false : _q,
       guidesComponent = _a.guidesComponent,
-      _q = _a.showFaceGuideThenSignaturePad,
-      showFaceGuideThenSignaturePad = _q === void 0 ? false : _q,
+      _r = _a.showFaceGuideThenSignaturePad,
+      showFaceGuideThenSignaturePad = _r === void 0 ? false : _r,
       minCaptureBrightnessThreshold = _a.minCaptureBrightnessThreshold,
       minCaptureRangeThreshold = _a.minCaptureRangeThreshold,
       minCaptureVarianceThreshold = _a.minCaptureVarianceThreshold,
-      _r = _a.theme,
-      theme = _r === void 0 ? 'default' : _r,
+      _s = _a.theme,
+      theme = _s === void 0 ? 'default' : _s,
       classNames = _a.classNames,
       colors = _a.colors,
       verbiage = _a.verbiage,
       geolocationEnabled = _a.geolocationEnabled,
       geolocationRequired = _a.geolocationRequired,
-      _s = _a.debugMode,
-      debugMode = _s === void 0 ? false : _s;
+      _t = _a.debugMode,
+      debugMode = _t === void 0 ? false : _t;
     useLanguage(lang);
     useDebugLogging(debugMode);
     return /*#__PURE__*/React.createElement(AuthProvider, {
@@ -29480,6 +29490,7 @@
           loadingOverlayMode: loadingOverlayMode,
           skipSuccessScreen: skipSuccessScreen,
           captureAudio: captureAudio,
+          captureMediaInfo: captureMediaInfo,
           minSignaturePadPoints: minSignaturePadPoints,
           headTrackingDisabled: headTrackingDisabled,
           headTrackingBoundaryPercentage: headTrackingBoundaryPercentage,
@@ -29502,7 +29513,7 @@
           onModelError: onModelError,
           onUserCancel: onUserCancel
         };
-      }, [onLoadingStarted, onLoadingProgress, onLoadingCompleted, onLoadingFailed, onSelfieCaptured, customOverlayContent, onLoadingOverlayDismissed, loadingOverlayMode, skipSuccessScreen, captureAudio, minSignaturePadPoints, headTrackingDisabled, headTrackingBoundaryPercentage, headTrackingBoundaryType, modelLoadTimeoutMs, faceLivenessProps, allowSignatureAfterLivenessCheckFailure, restartVideoOnSignaturePadCleared, skipLivenessValidation, allowManualSelfieCaptureOnLoadingError, guidesComponent, showFaceGuideThenSignaturePad, minCaptureBrightnessThreshold, minCaptureRangeThreshold, minCaptureVarianceThreshold, classNames, colors, debugMode, verbiage, onModelError, onUserCancel])
+      }, [onLoadingStarted, onLoadingProgress, onLoadingCompleted, onLoadingFailed, onSelfieCaptured, customOverlayContent, onLoadingOverlayDismissed, loadingOverlayMode, skipSuccessScreen, captureAudio, captureMediaInfo, minSignaturePadPoints, headTrackingDisabled, headTrackingBoundaryPercentage, headTrackingBoundaryType, modelLoadTimeoutMs, faceLivenessProps, allowSignatureAfterLivenessCheckFailure, restartVideoOnSignaturePadCleared, skipLivenessValidation, allowManualSelfieCaptureOnLoadingError, guidesComponent, showFaceGuideThenSignaturePad, minCaptureBrightnessThreshold, minCaptureRangeThreshold, minCaptureVarianceThreshold, classNames, colors, debugMode, verbiage, onModelError, onUserCancel])
     })))));
   };
 
@@ -30576,6 +30587,2724 @@
     stopAll: stopAll
   });
 
+  var _excluded = ["locateFile"];
+  function _createForOfIteratorHelperLoose(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+  function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+  function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+  function isError(error) {
+    return error !== null && typeof error === 'object' && Object.prototype.hasOwnProperty.call(error, 'message');
+  }
+  function unknownToError(error) {
+    if (isError(error)) {
+      return error;
+    }
+    return new Error(typeof error === 'string' ? error : 'Unknown error');
+  }
+
+  // DO NOT EDIT! File generated using `generate-types` script.
+
+  var INT_FIELDS = ['Active_Height', 'Active_Width', 'AudioCount', 'Audio_Channels_Total', 'BitDepth_Detected', 'BitDepth', 'BitDepth_Stored', 'Channels', 'Channels_Original', 'Chapters_Pos_Begin', 'Chapters_Pos_End', 'Comic_Position_Total', 'Count', 'DataSize', 'ElementCount', 'EPG_Positions_Begin', 'EPG_Positions_End', 'FirstPacketOrder', 'FooterSize', 'Format_Settings_GMC', 'Format_Settings_RefFrames', 'Format_Settings_SliceCount', 'FrameCount', 'FrameRate_Den', 'FrameRate_Num', 'GeneralCount', 'HeaderSize', 'Height_CleanAperture', 'Height', 'Height_Offset', 'Height_Original', 'ImageCount', 'Lines_MaxCharacterCount', 'Lines_MaxCountPerEvent', 'Matrix_Channels', 'MenuCount', 'OtherCount', 'Part_Position', 'Part_Position_Total', 'Played_Count', 'Reel_Position', 'Reel_Position_Total', 'Resolution', 'Sampled_Height', 'Sampled_Width', 'SamplingCount', 'Season_Position', 'Season_Position_Total', 'Source_FrameCount', 'Source_SamplingCount', 'Source_StreamSize_Encoded', 'Source_StreamSize', 'Status', 'Stored_Height', 'Stored_Width', 'StreamCount', 'StreamKindID', 'StreamKindPos', 'StreamSize_Demuxed', 'StreamSize_Encoded', 'StreamSize', 'TextCount', 'Track_Position', 'Track_Position_Total', 'Video0_Delay', 'VideoCount', 'Width_CleanAperture', 'Width', 'Width_Offset', 'Width_Original'];
+  var FLOAT_FIELDS = ['Active_DisplayAspectRatio', 'BitRate_Encoded', 'BitRate_Maximum', 'BitRate_Minimum', 'BitRate', 'BitRate_Nominal', 'Bits-Pixel_Frame', 'BitsPixel_Frame', 'Compression_Ratio', 'Delay', 'Delay_Original', 'DisplayAspectRatio_CleanAperture', 'DisplayAspectRatio', 'DisplayAspectRatio_Original', 'Duration_End_Command', 'Duration_End', 'Duration_FirstFrame', 'Duration_LastFrame', 'Duration', 'Duration_Start2End', 'Duration_Start_Command', 'Duration_Start', 'Events_MinDuration', 'FrameRate_Maximum', 'FrameRate_Minimum', 'FrameRate', 'FrameRate_Nominal', 'FrameRate_Original_Den', 'FrameRate_Original', 'FrameRate_Original_Num', 'FrameRate_Real', 'Interleave_Duration', 'Interleave_Preload', 'Interleave_VideoFrames', 'OverallBitRate_Maximum', 'OverallBitRate_Minimum', 'OverallBitRate', 'OverallBitRate_Nominal', 'PixelAspectRatio_CleanAperture', 'PixelAspectRatio', 'PixelAspectRatio_Original', 'SamplesPerFrame', 'SamplingRate', 'Source_Duration_FirstFrame', 'Source_Duration_LastFrame', 'Source_Duration', 'TimeStamp_FirstFrame', 'Video_Delay'];
+  var MAX_UINT32_PLUS_ONE = Math.pow(2, 32);
+  var DEFAULT_OPTIONS = {
+    coverData: false,
+    chunkSize: 256 * 1024,
+    format: 'object',
+    full: false
+  };
+  /**
+   * Wrapper for the MediaInfoLib WASM module.
+   *
+   * This class should not be instantiated directly. Use the {@link mediaInfoFactory} function
+   * to create instances of `MediaInfo`.
+   *
+   * @typeParam TFormat - The format type, defaults to `object`.
+   */
+  var MediaInfo = /*#__PURE__*/function () {
+    /** @group General Use */
+
+    /**
+     * The constructor should not be called directly, instead use {@link mediaInfoFactory}.
+     *
+     * @hidden
+     * @param mediainfoModule WASM module
+     * @param options User options
+     */
+    function MediaInfo(mediainfoModule, options) {
+      this.isAnalyzing = false;
+      this.mediainfoModule = mediainfoModule;
+      this.options = options;
+      this.mediainfoModuleInstance = this.instantiateModuleInstance();
+    }
+
+    /**
+     * Convenience method for analyzing a buffer chunk by chunk.
+     *
+     * @param size Return total buffer size in bytes.
+     * @param readChunk Read chunk of data and return an {@link Uint8Array}.
+     * @group General Use
+     */
+
+    /**
+     * Convenience method for analyzing a buffer chunk by chunk.
+     *
+     * @param size Return total buffer size in bytes.
+     * @param readChunk Read chunk of data and return an {@link Uint8Array}.
+     * @param callback Function that is called once the processing is done
+     * @group General Use
+     */
+    var _proto = MediaInfo.prototype;
+    _proto.analyzeData = function analyzeData(size, readChunk, callback) {
+      var _this = this;
+      // Support promise signature
+      if (callback === undefined) {
+        return new Promise(function (resolve, reject) {
+          var resultCb = function resultCb(result, error) {
+            _this.isAnalyzing = false;
+            if (error || !result) {
+              reject(unknownToError(error));
+            } else {
+              resolve(result);
+            }
+          };
+          _this.analyzeData(size, readChunk, resultCb);
+        });
+      }
+      if (this.isAnalyzing) {
+        callback('', new Error('cannot start a new analysis while another is in progress'));
+        return;
+      }
+      this.reset();
+      this.isAnalyzing = true;
+      var finalize = function finalize() {
+        try {
+          _this.openBufferFinalize();
+          var result = _this.inform();
+          if (_this.options.format === 'object') {
+            callback(_this.parseResultJson(result));
+          } else {
+            callback(result);
+          }
+        } finally {
+          _this.isAnalyzing = false;
+        }
+      };
+      var offset = 0;
+      var runReadDataLoop = function runReadDataLoop(fileSize) {
+        var readNextChunk = function readNextChunk(data) {
+          if (continueBuffer(data)) {
+            getChunk();
+          } else {
+            finalize();
+          }
+        };
+        var getChunk = function getChunk() {
+          var dataValue;
+          try {
+            var safeSize = Math.min(_this.options.chunkSize, fileSize - offset);
+            dataValue = readChunk(safeSize, offset);
+          } catch (error) {
+            _this.isAnalyzing = false;
+            callback('', unknownToError(error));
+            return;
+          }
+          if (dataValue instanceof Promise) {
+            dataValue.then(readNextChunk)["catch"](function (error) {
+              _this.isAnalyzing = false;
+              callback('', unknownToError(error));
+            });
+          } else {
+            readNextChunk(dataValue);
+          }
+        };
+        var continueBuffer = function continueBuffer(data) {
+          if (data.length === 0 || _this.openBufferContinue(data, data.length)) {
+            return false;
+          }
+          var seekTo = _this.openBufferContinueGotoGet();
+          if (seekTo === -1) {
+            offset += data.length;
+          } else {
+            offset = seekTo;
+            _this.openBufferInit(fileSize, seekTo);
+          }
+          return true;
+        };
+        _this.openBufferInit(fileSize, offset);
+        getChunk();
+      };
+      var fileSizeValue = typeof size === 'function' ? size() : size;
+      if (fileSizeValue instanceof Promise) {
+        fileSizeValue.then(runReadDataLoop)["catch"](function (error) {
+          callback(null, unknownToError(error));
+        });
+      } else {
+        runReadDataLoop(fileSizeValue);
+      }
+    }
+
+    /**
+     * Close the MediaInfoLib WASM instance.
+     *
+     * @group General Use
+     */;
+    _proto.close = function close() {
+      if (typeof this.mediainfoModuleInstance.close === 'function') {
+        this.mediainfoModuleInstance.close();
+      }
+    }
+
+    /**
+     * Reset the MediaInfoLib WASM instance to its initial state.
+     *
+     * This method ensures that the instance is ready for a new parse.
+     * @group General Use
+     */;
+    _proto.reset = function reset() {
+      this.mediainfoModuleInstance["delete"]();
+      this.mediainfoModuleInstance = this.instantiateModuleInstance();
+    }
+
+    /**
+     * Receive result data from the WASM instance.
+     *
+     * (This is a low-level MediaInfoLib function.)
+     *
+     * @returns Result data (format can be configured in options)
+     * @group Low-level
+     */;
+    _proto.inform = function inform() {
+      return this.mediainfoModuleInstance.inform();
+    }
+
+    /**
+     * Send more data to the WASM instance.
+     *
+     * (This is a low-level MediaInfoLib function.)
+     *
+     * @param data Data buffer
+     * @param size Buffer size
+     * @returns Processing state: `0` (no bits set) = not finished, Bit `0` set = enough data read for providing information
+     * @group Low-level
+     */;
+    _proto.openBufferContinue = function openBufferContinue(data, size) {
+      // bit 3 set -> done
+      return !!(this.mediainfoModuleInstance.open_buffer_continue(data, size) & 0x08);
+    }
+
+    /**
+     * Retrieve seek position from WASM instance.
+     * The MediaInfoLib function `Open_Buffer_GoTo` returns an integer with 64 bit precision.
+     * It would be cut at 32 bit due to the JavaScript bindings. Here we transport the low and high
+     * parts separately and put them together.
+     *
+     * (This is a low-level MediaInfoLib function.)
+     *
+     * @returns Seek position (where MediaInfoLib wants go in the data buffer)
+     * @group Low-level
+     */;
+    _proto.openBufferContinueGotoGet = function openBufferContinueGotoGet() {
+      // JS bindings don't support 64 bit int
+      // https://github.com/buzz/mediainfo.js/issues/11
+      var seekTo = -1;
+      var seekToLow = this.mediainfoModuleInstance.open_buffer_continue_goto_get_lower();
+      var seekToHigh = this.mediainfoModuleInstance.open_buffer_continue_goto_get_upper();
+      if (seekToLow == -1 && seekToHigh == -1) {
+        seekTo = -1;
+      } else if (seekToLow < 0) {
+        seekTo = seekToLow + MAX_UINT32_PLUS_ONE + seekToHigh * MAX_UINT32_PLUS_ONE;
+      } else {
+        seekTo = seekToLow + seekToHigh * MAX_UINT32_PLUS_ONE;
+      }
+      return seekTo;
+    }
+
+    /**
+     * Inform MediaInfoLib that no more data is being read.
+     *
+     * (This is a low-level MediaInfoLib function.)
+     *
+     * @group Low-level
+     */;
+    _proto.openBufferFinalize = function openBufferFinalize() {
+      this.mediainfoModuleInstance.open_buffer_finalize();
+    }
+
+    /**
+     * Prepare MediaInfoLib to process a data buffer.
+     *
+     * (This is a low-level MediaInfoLib function.)
+     *
+     * @param size Expected buffer size
+     * @param offset Buffer offset
+     * @group Low-level
+     */;
+    _proto.openBufferInit = function openBufferInit(size, offset) {
+      this.mediainfoModuleInstance.open_buffer_init(size, offset);
+    }
+
+    /**
+     * Parse result JSON. Convert integer/float fields.
+     *
+     * @param result Serialized JSON from MediaInfo
+     * @returns Parsed JSON object
+     */;
+    _proto.parseResultJson = function parseResultJson(resultString) {
+      var intFields = INT_FIELDS;
+      var floatFields = FLOAT_FIELDS;
+
+      // Parse JSON
+      var result = JSON.parse(resultString);
+      if (result.media) {
+        var newMedia = _extends({}, result.media, {
+          track: []
+        });
+        if (Array.isArray(result.media.track)) {
+          for (var _iterator = _createForOfIteratorHelperLoose(result.media.track), _step; !(_step = _iterator()).done;) {
+            var track = _step.value;
+            var newTrack = {
+              '@type': track['@type']
+            };
+            for (var _i = 0, _Object$entries = Object.entries(track); _i < _Object$entries.length; _i++) {
+              var _Object$entries$_i = _Object$entries[_i],
+                key = _Object$entries$_i[0],
+                val = _Object$entries$_i[1];
+              if (key === '@type') {
+                continue;
+              }
+              if (typeof val === 'string' && intFields.includes(key)) {
+                var _extends2;
+                newTrack = _extends({}, newTrack, (_extends2 = {}, _extends2[key] = Number.parseInt(val, 10), _extends2));
+              } else if (typeof val === 'string' && floatFields.includes(key)) {
+                var _extends3;
+                newTrack = _extends({}, newTrack, (_extends3 = {}, _extends3[key] = Number.parseFloat(val), _extends3));
+              } else {
+                var _extends4;
+                newTrack = _extends({}, newTrack, (_extends4 = {}, _extends4[key] = val, _extends4));
+              }
+            }
+            newMedia.track.push(newTrack);
+          }
+        }
+        return _extends({}, result, {
+          media: newMedia
+        });
+      }
+      return result;
+    }
+
+    /**
+     * Instantiate a new WASM module instance.
+     *
+     * @returns MediaInfo module instance
+     */;
+    _proto.instantiateModuleInstance = function instantiateModuleInstance() {
+      return new this.mediainfoModule.MediaInfo(this.options.format === 'object' ? 'JSON' : this.options.format, this.options.coverData, this.options.full);
+    };
+    return MediaInfo;
+  }(); // This code implements the `-sMODULARIZE` settings by taking the generated
+  // JS program code (INNER_JS_CODE) and wrapping it in a factory function.
+  // When targetting node and ES6 we use `await import ..` in the generated code
+  // so the outer function needs to be marked as async.
+  function Module(_x) {
+    return _Module.apply(this, arguments);
+  }
+  function _Module() {
+    _Module = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(moduleArg) {
+      var moduleRtn, Module, thisProgram, _scriptName, scriptDirectory, locateFile, readAsync, out, err, wasmBinary, ABORT, readyPromiseResolve, readyPromiseReject, wasmMemory, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64, HEAP64, HEAPU64, runtimeInitialized, updateMemoryViews, initRuntime, runDependencies, dependenciesFulfilled, addRunDependency, removeRunDependency, abort, wasmBinaryFile, findWasmBinary, getBinarySync, getWasmBinary, _getWasmBinary, instantiateArrayBuffer, _instantiateArrayBuffer, instantiateAsync, _instantiateAsync, getWasmImports, createWasm, _createWasm, __abort_js, AsciiToString, awaitingDependencies, registeredTypes, typeDependencies, BindingError, throwBindingError, sharedRegisterType, registerType, integerReadValueFromPointer, __embind_register_bigint, __embind_register_bool, shallowCopyInternalPointer, throwInstanceAlreadyDeleted, finalizationRegistry, detachFinalizer, runDestructor, releaseClassHandle, _attachFinalizer, init_ClassHandle, ClassHandle, createNamedFunction, registeredPointers, ensureOverloadTable, exposePublicSymbol, char_0, char_9, makeLegalFunctionName, RegisteredClass, upcastPointer, embindRepr, constNoSmartPtrRawPointerToWireType, genericPointerToWireType, nonConstNoSmartPtrRawPointerToWireType, readPointer, _downcastPointer, registeredInstances, getBasestPointer, getInheritedInstance, InternalError, throwInternalError, makeClassHandle, RegisteredPointer_fromWireType, init_RegisteredPointer, RegisteredPointer, replacePublicSymbol, wasmTableMirror, wasmTable, getWasmTableEntry, embind__requireFunction, UnboundTypeError, getTypeName, throwUnboundTypeError, whenDependentTypesAreResolved, __embind_register_class, heap32VectorToArray, runDestructors, usesDestructorStack, createJsInvoker, craftInvokerFunction, __embind_register_class_constructor, getFunctionName, __embind_register_class_function, emval_freelist, emval_handles, __emval_decref, Emval, EmValType, __embind_register_emval, floatReadValueFromPointer, __embind_register_float, __embind_register_integer, __embind_register_memory_view, __embind_register_smart_ptr, stringToUTF8Array, stringToUTF8, lengthBytesUTF8, UTF8Decoder, findStringEnd, UTF8ArrayToString, UTF8ToString, __embind_register_std_string, UTF16Decoder, UTF16ToString, stringToUTF16, lengthBytesUTF16, UTF32ToString, stringToUTF32, lengthBytesUTF32, __embind_register_std_wstring, __embind_register_void, emval_methodCallers, emval_addMethodCaller, requireRegisteredType, emval_lookupTypes, emval_returnValue, emval_symbols, getStringOrSymbol, __emval_create_invoker, __emval_incref, __emval_invoke, __emval_run_destructors, INT53_MAX, INT53_MIN, bigintToI53Checked, __gmtime_js, __tzset_js, _emscripten_date_now, getHeapMax, alignMemory, growMemory, _emscripten_resize_heap, ENV, getExecutableName, _getEnvStrings, _environ_get, _environ_sizes_get, _fd_close, _fd_seek, printCharBuffers, printChar, _fd_write, ___getTypeName, _malloc, _free, assignWasmExports, wasmImports, wasmExports, run;
+      return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            run = function _run() {
+              if (runDependencies > 0) {
+                dependenciesFulfilled = run;
+                return;
+              }
+
+              // a preRun added a dependency, run will be called later
+              if (runDependencies > 0) {
+                dependenciesFulfilled = run;
+                return;
+              }
+              function doRun() {
+                // run may have just been called through dependencies being fulfilled just in this very frame,
+                // or while the async setStatus time below was happening
+                Module['calledRun'] = true;
+                if (ABORT) return;
+                initRuntime();
+                readyPromiseResolve == null || readyPromiseResolve(Module);
+              }
+              {
+                doRun();
+              }
+            };
+            assignWasmExports = function _assignWasmExports(wasmExports) {
+              ___getTypeName = wasmExports['__getTypeName'];
+              _malloc = wasmExports['malloc'];
+              _free = wasmExports['free'];
+              wasmExports['_emscripten_stack_restore'];
+              wasmExports['_emscripten_stack_alloc'];
+              wasmExports['emscripten_stack_get_current'];
+            };
+            _fd_seek = function _fd_seek2(fd, offset, whence, newOffset) {
+              return 70;
+            };
+            __gmtime_js = function _gmtime_js(time, tmPtr) {
+              time = bigintToI53Checked(time);
+              var date = new Date(time * 1000);
+              HEAP32[tmPtr >> 2] = date.getUTCSeconds();
+              HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes();
+              HEAP32[tmPtr + 8 >> 2] = date.getUTCHours();
+              HEAP32[tmPtr + 12 >> 2] = date.getUTCDate();
+              HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth();
+              HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900;
+              HEAP32[tmPtr + 24 >> 2] = date.getUTCDay();
+              var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
+              var yday = (date.getTime() - start) / (1000 * 60 * 60 * 24) | 0;
+              HEAP32[tmPtr + 28 >> 2] = yday;
+            };
+            craftInvokerFunction = function _craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */isAsync) {
+              // humanName: a human-readable string name for the function to be generated.
+              // argTypes: An array that contains the embind type objects for all types in the function signature.
+              //    argTypes[0] is the type object for the function return value.
+              //    argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method.
+              //    argTypes[2...] are the actual function parameters.
+              // classType: The embind type object for the class to be bound, or null if this is not a method of a class.
+              // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code.
+              // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling.
+              // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI.
+              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;
+
+              // Free functions with signature "void function()" do not need an invoker that marshalls between wire types.
+              // TODO: This omits argument count check - enable only at -O3 or similar.
+              //    if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) {
+              //       return FUNCTION_TABLE[fn];
+              //    }
+
+              // Determine if we need to use a dynamic stack to store the destructors for the function parameters.
+              // TODO: Remove this completely once all function invokers are being dynamically generated.
+              var needsDestructorStack = usesDestructorStack(argTypes);
+              var returns = !argTypes[0].isVoid;
+              // Builld the arguments that will be passed into the closure around the invoker
+              // function.
+              var retType = argTypes[0];
+              var instType = argTypes[1];
+              var closureArgs = [humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, retType.fromWireType.bind(retType), instType == null ? void 0 : instType.toWireType.bind(instType)];
+              for (var i = 2; i < argCount; ++i) {
+                var argType = argTypes[i];
+                closureArgs.push(argType.toWireType.bind(argType));
+              }
+              if (!needsDestructorStack) {
+                // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method.
+                for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+                  if (argTypes[i].destructorFunction !== null) {
+                    closureArgs.push(argTypes[i].destructorFunction);
+                  }
+                }
+              }
+              var invokerFactory = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync);
+              var invokerFn = invokerFactory.apply(void 0, closureArgs);
+              return createNamedFunction(humanName, invokerFn);
+            };
+            createJsInvoker = function _createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) {
+              var needsDestructorStack = usesDestructorStack(argTypes);
+              var argCount = argTypes.length - 2;
+              var argsList = [];
+              var argsListWired = ['fn'];
+              if (isClassMethodFunc) {
+                argsListWired.push('thisWired');
+              }
+              for (var i = 0; i < argCount; ++i) {
+                argsList.push("arg" + i);
+                argsListWired.push("arg" + i + "Wired");
+              }
+              argsList = argsList.join(',');
+              argsListWired = argsListWired.join(',');
+              var invokerFnBody = "return function (" + argsList + ") {\n";
+              if (needsDestructorStack) {
+                invokerFnBody += 'var destructors = [];\n';
+              }
+              var dtorStack = needsDestructorStack ? 'destructors' : 'null';
+              var args1 = ['humanName', 'throwBindingError', 'invoker', 'fn', 'runDestructors', 'fromRetWire', 'toClassParamWire'];
+              if (isClassMethodFunc) {
+                invokerFnBody += "var thisWired = toClassParamWire(" + dtorStack + ", this);\n";
+              }
+              for (var i = 0; i < argCount; ++i) {
+                var argName = "toArg" + i + "Wire";
+                invokerFnBody += "var arg" + i + "Wired = " + argName + "(" + dtorStack + ", arg" + i + ");\n";
+                args1.push(argName);
+              }
+              invokerFnBody += (returns || isAsync ? 'var rv = ' : '') + ("invoker(" + argsListWired + ");\n");
+              if (needsDestructorStack) {
+                invokerFnBody += 'runDestructors(destructors);\n';
+              } else {
+                for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
+                  // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method.
+                  var paramName = i === 1 ? 'thisWired' : 'arg' + (i - 2) + 'Wired';
+                  if (argTypes[i].destructorFunction !== null) {
+                    invokerFnBody += paramName + "_dtor(" + paramName + ");\n";
+                    args1.push(paramName + "_dtor");
+                  }
+                }
+              }
+              if (returns) {
+                invokerFnBody += 'var ret = fromRetWire(rv);\n' + 'return ret;\n';
+              }
+              invokerFnBody += '}\n';
+              return new Function(args1, invokerFnBody);
+            };
+            usesDestructorStack = function _usesDestructorStack(argTypes) {
+              // Skip return value at index 0 - it's not deleted here.
+              for (var i = 1; i < argTypes.length; ++i) {
+                // The type does not define a destructor function - must use dynamic stack
+                if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) {
+                  return true;
+                }
+              }
+              return false;
+            };
+            RegisteredPointer = function _RegisteredPointer(name, registeredClass, isReference, isConst,
+            // smart pointer properties
+            isSmartPointer, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor) {
+              this.name = name;
+              this.registeredClass = registeredClass;
+              this.isReference = isReference;
+              this.isConst = isConst;
+
+              // smart pointer properties
+              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;
+                // Here we must leave this.destructorFunction undefined, since whether genericPointerToWireType returns
+                // a pointer that needs to be freed up is runtime-dependent, and cannot be evaluated at registration time.
+                // TODO: Create an alternative mechanism that allows removing the use of var destructors = []; array in
+                //       craftInvokerFunction altogether.
+              }
+            };
+            RegisteredPointer_fromWireType = function _RegisteredPointer_fr(ptr) {
+              // ptr is a raw pointer (or a raw smartpointer)
+
+              // rawPointer is a maybe-null raw pointer
+              var rawPointer = this.getPointee(ptr);
+              if (!rawPointer) {
+                this.destructor(ptr);
+                return null;
+              }
+              var registeredInstance = getInheritedInstance(this.registeredClass, rawPointer);
+              if (undefined !== registeredInstance) {
+                // JS object has been neutered, time to repopulate it
+                if (0 === registeredInstance.$$.count.value) {
+                  registeredInstance.$$.ptr = rawPointer;
+                  registeredInstance.$$.smartPtr = ptr;
+                  return registeredInstance['clone']();
+                } else {
+                  // else, just increment reference count on existing object
+                  // it already has a reference to the smart pointer
+                  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
+                  });
+                } else {
+                  return makeClassHandle(this.registeredClass.instancePrototype, {
+                    ptrType: this,
+                    ptr: 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
+                });
+              } else {
+                return makeClassHandle(toType.registeredClass.instancePrototype, {
+                  ptrType: toType,
+                  ptr: dp
+                });
+              }
+            };
+            readPointer = function _readPointer(pointer) {
+              return this.fromWireType(HEAPU32[pointer >> 2]);
+            };
+            nonConstNoSmartPtrRawPointerToWireType = function _nonConstNoSmartPtrRa(destructors, handle) {
+              if (handle === null) {
+                if (this.isReference) {
+                  throwBindingError("null is not a valid " + this.name);
+                }
+                return 0;
+              }
+              if (!handle.$$) {
+                throwBindingError("Cannot pass \"" + embindRepr(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;
+            };
+            genericPointerToWireType = function _genericPointerToWire(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;
+                } else {
+                  return 0;
+                }
+              }
+              if (!handle || !handle.$$) {
+                throwBindingError("Cannot pass \"" + embindRepr(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) {
+                // TODO: this is not strictly true
+                // We could support BY_EMVAL conversions from raw pointers to smart pointers
+                // because the smart pointer can hold a reference to the handle
+                if (undefined === handle.$$.smartPtr) {
+                  throwBindingError('Passing raw pointer to smart pointer is illegal');
+                }
+                switch (this.sharingPolicy) {
+                  case 0:
+                    // NONE
+                    // no upcasting
+                    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:
+                    // INTRUSIVE
+                    ptr = handle.$$.smartPtr;
+                    break;
+                  case 2:
+                    // BY_EMVAL
+                    if (handle.$$.smartPtrType === this) {
+                      ptr = handle.$$.smartPtr;
+                    } else {
+                      var clonedHandle = handle['clone']();
+                      ptr = this.rawShare(ptr, Emval.toHandle(function () {
+                        return clonedHandle['delete']();
+                      }));
+                      if (destructors !== null) {
+                        destructors.push(this.rawDestructor, ptr);
+                      }
+                    }
+                    break;
+                  default:
+                    throwBindingError('Unsupporting sharing policy');
+                }
+              }
+              return ptr;
+            };
+            constNoSmartPtrRawPointerToWireType = function _constNoSmartPtrRawPo(destructors, handle) {
+              if (handle === null) {
+                if (this.isReference) {
+                  throwBindingError("null is not a valid " + this.name);
+                }
+                return 0;
+              }
+              if (!handle.$$) {
+                throwBindingError("Cannot pass \"" + embindRepr(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;
+            };
+            RegisteredClass = 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 = [];
+            };
+            ClassHandle = function _ClassHandle() {};
+            registerType = function _registerType(rawType, registeredInstance, options) {
+              if (options === void 0) {
+                options = {};
+              }
+              return sharedRegisterType(rawType, registeredInstance, options);
+            };
+            sharedRegisterType = function _sharedRegisterType(rawType, registeredInstance, options) {
+              if (options === void 0) {
+                options = {};
+              }
+              var name = registeredInstance.name;
+              if (!rawType) {
+                throwBindingError("type \"" + name + "\" must have a positive integer typeid pointer");
+              }
+              if (registeredTypes.hasOwnProperty(rawType)) {
+                if (options.ignoreDuplicateRegistrations) {
+                  return;
+                } else {
+                  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(function (cb) {
+                  return cb();
+                });
+              }
+            };
+            _createWasm = function _createWasm3() {
+              _createWasm = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+                var _wasmBinaryFile;
+                var receiveInstance, receiveInstantiationResult, info, result, exports;
+                return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+                  while (1) switch (_context5.prev = _context5.next) {
+                    case 0:
+                      receiveInstantiationResult = function _receiveInstantiation(result) {
+                        // 'result' is a ResultObject object which has both the module and instance.
+                        // receiveInstance() will swap in the exports (to Module.asm) so they can be called
+                        // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
+                        // When the regression is fixed, can restore the above PTHREADS-enabled path.
+                        return receiveInstance(result['instance']);
+                      };
+                      receiveInstance = function _receiveInstance(instance, module) {
+                        wasmExports = instance.exports;
+                        wasmMemory = wasmExports['memory'];
+                        updateMemoryViews();
+                        wasmTable = wasmExports['__indirect_function_table'];
+                        assignWasmExports(wasmExports);
+                        removeRunDependency();
+                        return wasmExports;
+                      }; // Load the wasm module and create an instance of using native support in the JS engine.
+                      // handle a generated wasm instance, receiving its exports and
+                      // performing other necessary setup
+                      /** @param {WebAssembly.Module=} module*/
+                      // wait for the pthread pool (if any)
+                      addRunDependency();
+
+                      // Prefer streaming instantiation if available.
+                      info = getWasmImports();
+                      (_wasmBinaryFile = wasmBinaryFile) != null ? _wasmBinaryFile : wasmBinaryFile = findWasmBinary();
+                      _context5.next = 7;
+                      return instantiateAsync(wasmBinary, wasmBinaryFile, info);
+                    case 7:
+                      result = _context5.sent;
+                      exports = receiveInstantiationResult(result);
+                      return _context5.abrupt("return", exports);
+                    case 10:
+                    case "end":
+                      return _context5.stop();
+                  }
+                }, _callee5);
+              }));
+              return _createWasm.apply(this, arguments);
+            };
+            createWasm = function _createWasm2() {
+              return _createWasm.apply(this, arguments);
+            };
+            getWasmImports = function _getWasmImports() {
+              // prepare imports
+              return {
+                env: wasmImports,
+                wasi_snapshot_preview1: wasmImports
+              };
+            };
+            _instantiateAsync = function _instantiateAsync3() {
+              _instantiateAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(binary, binaryFile, imports) {
+                var response, instantiationResult;
+                return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+                  while (1) switch (_context4.prev = _context4.next) {
+                    case 0:
+                      _context4.prev = 0;
+                      response = fetch(binaryFile, {
+                        credentials: 'same-origin'
+                      });
+                      _context4.next = 4;
+                      return WebAssembly.instantiateStreaming(response, imports);
+                    case 4:
+                      instantiationResult = _context4.sent;
+                      return _context4.abrupt("return", instantiationResult);
+                    case 8:
+                      _context4.prev = 8;
+                      _context4.t0 = _context4["catch"](0);
+                      // We expect the most common failure cause to be a bad MIME type for the binary,
+                      // in which case falling back to ArrayBuffer instantiation should work.
+                      err("wasm streaming compile failed: " + _context4.t0);
+                      err('falling back to ArrayBuffer instantiation');
+                      // fall back of instantiateArrayBuffer below
+                    case 12:
+                      return _context4.abrupt("return", instantiateArrayBuffer(binaryFile, imports));
+                    case 13:
+                    case "end":
+                      return _context4.stop();
+                  }
+                }, _callee4, null, [[0, 8]]);
+              }));
+              return _instantiateAsync.apply(this, arguments);
+            };
+            instantiateAsync = function _instantiateAsync2(_x6, _x7, _x8) {
+              return _instantiateAsync.apply(this, arguments);
+            };
+            _instantiateArrayBuffer = function _instantiateArrayBuff2() {
+              _instantiateArrayBuffer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(binaryFile, imports) {
+                var binary, instance;
+                return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+                  while (1) switch (_context3.prev = _context3.next) {
+                    case 0:
+                      _context3.prev = 0;
+                      _context3.next = 3;
+                      return getWasmBinary(binaryFile);
+                    case 3:
+                      binary = _context3.sent;
+                      _context3.next = 6;
+                      return WebAssembly.instantiate(binary, imports);
+                    case 6:
+                      instance = _context3.sent;
+                      return _context3.abrupt("return", instance);
+                    case 10:
+                      _context3.prev = 10;
+                      _context3.t0 = _context3["catch"](0);
+                      err("failed to asynchronously prepare wasm: " + _context3.t0);
+                      abort(_context3.t0);
+                    case 14:
+                    case "end":
+                      return _context3.stop();
+                  }
+                }, _callee3, null, [[0, 10]]);
+              }));
+              return _instantiateArrayBuffer.apply(this, arguments);
+            };
+            instantiateArrayBuffer = function _instantiateArrayBuff(_x4, _x5) {
+              return _instantiateArrayBuffer.apply(this, arguments);
+            };
+            _getWasmBinary = function _getWasmBinary3() {
+              _getWasmBinary = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(binaryFile) {
+                var response;
+                return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+                  while (1) switch (_context2.prev = _context2.next) {
+                    case 0:
+                      _context2.prev = 0;
+                      _context2.next = 3;
+                      return readAsync(binaryFile);
+                    case 3:
+                      response = _context2.sent;
+                      return _context2.abrupt("return", new Uint8Array(response));
+                    case 7:
+                      _context2.prev = 7;
+                      _context2.t0 = _context2["catch"](0);
+                    case 9:
+                      return _context2.abrupt("return", getBinarySync());
+                    case 10:
+                    case "end":
+                      return _context2.stop();
+                  }
+                }, _callee2, null, [[0, 7]]);
+              }));
+              return _getWasmBinary.apply(this, arguments);
+            };
+            getWasmBinary = function _getWasmBinary2(_x3) {
+              return _getWasmBinary.apply(this, arguments);
+            };
+            getBinarySync = function _getBinarySync(file) {
+              throw 'both async and sync fetching of the wasm failed';
+            };
+            findWasmBinary = function _findWasmBinary() {
+              if (Module['locateFile']) {
+                return locateFile('MediaInfoModule.wasm');
+              }
+              // Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too.
+              return new URL('MediaInfoModule.wasm', (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('sdk2.umd.development.js', document.baseURI).href))).href;
+            };
+            abort = function _abort(what) {
+              what = 'Aborted(' + what + ')';
+              // TODO(sbc): Should we remove printing and leave it up to whoever
+              // catches the exception?
+              err(what);
+              ABORT = true;
+              what += '. Build with -sASSERTIONS for more info.';
+
+              // Use a wasm runtime error, because a JS error might be seen as a foreign
+              // exception, which means we'd run destructors on it. We need the error to
+              // simply make the program stop.
+              // FIXME This approach does not work in Wasm EH because it currently does not assume
+              // all RuntimeErrors are from traps; it decides whether a RuntimeError is from
+              // a trap or not based on a hidden field within the object. So at the moment
+              // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
+              // allows this in the wasm spec.
+
+              // Suppress closure compiler warning here. Closure compiler's builtin extern
+              // definition for WebAssembly.RuntimeError claims it takes no arguments even
+              // though it can.
+              // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
+              /** @suppress {checkTypes} */
+              var e = new WebAssembly.RuntimeError(what);
+              readyPromiseReject == null || readyPromiseReject(e);
+              // Throw the error whether or not MODULARIZE is set because abort is used
+              // in code paths apart from instantiation where an exception is expected
+              // to be thrown when abort is called.
+              throw e;
+            };
+            removeRunDependency = function _removeRunDependency(id) {
+              runDependencies--;
+              if (runDependencies == 0) {
+                if (dependenciesFulfilled) {
+                  var callback = dependenciesFulfilled;
+                  dependenciesFulfilled = null;
+                  callback(); // can add another dependenciesFulfilled
+                }
+              }
+            };
+            addRunDependency = function _addRunDependency(id) {
+              runDependencies++;
+            };
+            initRuntime = function _initRuntime() {
+              runtimeInitialized = true;
+
+              // No ATINITS hooks
+
+              wasmExports['__wasm_call_ctors']();
+
+              // No ATPOSTCTORS hooks
+            };
+            updateMemoryViews = function _updateMemoryViews() {
+              var b = wasmMemory.buffer;
+              HEAP8 = new Int8Array(b);
+              HEAP16 = new Int16Array(b);
+              HEAPU8 = new Uint8Array(b);
+              HEAPU16 = new Uint16Array(b);
+              HEAP32 = new Int32Array(b);
+              HEAPU32 = new Uint32Array(b);
+              HEAPF32 = new Float32Array(b);
+              HEAPF64 = new Float64Array(b);
+              HEAP64 = new BigInt64Array(b);
+              HEAPU64 = new BigUint64Array(b);
+            };
+            locateFile = function _locateFile(path) {
+              if (Module['locateFile']) {
+                return Module['locateFile'](path, scriptDirectory);
+              }
+              return scriptDirectory + path;
+            };
+            if (moduleArg === void 0) {
+              moduleArg = {};
+            }
+            // include: shell.js
+            // The Module object: Our interface to the outside world. We import
+            // and export values on it. There are various ways Module can be used:
+            // 1. Not defined. We create it here
+            // 2. A function parameter, function(moduleArg) => Promise<Module>
+            // 3. pre-run appended it, var Module = {}; ..generated code..
+            // 4. External script tag defines var Module.
+            // We need to check if Module already exists (e.g. case 3 above).
+            // Substitution will be replaced with actual code on later stage of the build,
+            // this way Closure Compiler will not mangle it (e.g. case 4. above).
+            // Note that if you want to run closure, and also to use Module
+            // after the generated code, you will need to define   var Module = {};
+            // before the code. Then that object will be used in the code, and you
+            // can continue to use Module afterwards as well.
+            Module = moduleArg;
+            thisProgram = './this.program';
+            _scriptName = (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('sdk2.umd.development.js', document.baseURI).href)); // `/` should be present at the end if `scriptDirectory` is not empty
+            scriptDirectory = ''; // Hooks that are implemented differently in different runtime environments.
+            try {
+              scriptDirectory = new URL('.', _scriptName).href; // includes trailing slash
+            } catch (_unused2) {
+              // Must be a `blob:` or `data:` URL (e.g. `blob:http://site.com/etc/etc`), we cannot
+              // infer anything from them.
+            }
+            // include: web_or_worker_shell_read.js
+            readAsync = /*#__PURE__*/function () {
+              var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(url) {
+                var response;
+                return _regeneratorRuntime.wrap(function _callee$(_context) {
+                  while (1) switch (_context.prev = _context.next) {
+                    case 0:
+                      _context.next = 2;
+                      return fetch(url, {
+                        credentials: 'same-origin'
+                      });
+                    case 2:
+                      response = _context.sent;
+                      if (!response.ok) {
+                        _context.next = 5;
+                        break;
+                      }
+                      return _context.abrupt("return", response.arrayBuffer());
+                    case 5:
+                      throw new Error(response.status + ' : ' + response.url);
+                    case 6:
+                    case "end":
+                      return _context.stop();
+                  }
+                }, _callee);
+              }));
+              return function readAsync(_x2) {
+                return _ref.apply(this, arguments);
+              };
+            }();
+            // end include: web_or_worker_shell_read.js
+            out = console.log.bind(console);
+            err = console.error.bind(console); // end include: shell.js
+            // include: preamble.js
+            // === Preamble library stuff ===
+            // Documentation for the public APIs defined in this file must be updated in:
+            //    site/source/docs/api_reference/preamble.js.rst
+            // A prebuilt local version of the documentation is available at:
+            //    site/build/text/docs/api_reference/preamble.js.txt
+            // You can also build docs locally as HTML or other formats in site/
+            // An online HTML version (which may be of a different version of Emscripten)
+            //    is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
+            // Wasm globals
+            //========================================
+            // Runtime essentials
+            //========================================
+            // whether we are quitting the application. no code should run after this.
+            // set in exit() and abort()
+            ABORT = false; // include: runtime_common.js
+            // include: runtime_stack_check.js
+            // end include: runtime_stack_check.js
+            // include: runtime_exceptions.js
+            // end include: runtime_exceptions.js
+            // include: runtime_debug.js
+            // end include: runtime_debug.js
+            // Memory management
+            // BigInt64Array type is not correctly defined in closure
+            runtimeInitialized = false;
+            // A counter of dependencies for calling run(). If we need to
+            // do asynchronous work before running, increment this and
+            // decrement it. Incrementing must happen in a place like
+            // Module.preRun (used by emcc to add file preloading).
+            // Note that you can add dependencies in preRun, even though
+            // it happens right before run - run will be postponed until
+            // the dependencies are met.
+            runDependencies = 0;
+            dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+            /** @param {string|number=} what */
+            // Create the wasm instance.
+            // Receives the wasm imports, returns the exports.
+            __abort_js = function __abort_js() {
+              return abort('');
+            };
+            AsciiToString = function AsciiToString(ptr) {
+              var str = '';
+              while (1) {
+                var ch = HEAPU8[ptr++];
+                if (!ch) return str;
+                str += String.fromCharCode(ch);
+              }
+            };
+            awaitingDependencies = {};
+            registeredTypes = {};
+            typeDependencies = {};
+            BindingError = /*#__PURE__*/function (_Error) {
+              function BindingError(message) {
+                var _this2;
+                _this2 = _Error.call(this, message) || this;
+                _this2.name = 'BindingError';
+                return _this2;
+              }
+              _inheritsLoose(BindingError, _Error);
+              return BindingError;
+            }( /*#__PURE__*/_wrapNativeSuper(Error));
+            throwBindingError = function throwBindingError(message) {
+              throw new BindingError(message);
+            };
+            /** @param {Object=} options */
+            /** @param {Object=} options */
+            integerReadValueFromPointer = function integerReadValueFromPointer(name, width, signed) {
+              // integers are quite common, so generate very specialized functions
+              switch (width) {
+                case 1:
+                  return signed ? function (pointer) {
+                    return HEAP8[pointer];
+                  } : function (pointer) {
+                    return HEAPU8[pointer];
+                  };
+                case 2:
+                  return signed ? function (pointer) {
+                    return HEAP16[pointer >> 1];
+                  } : function (pointer) {
+                    return HEAPU16[pointer >> 1];
+                  };
+                case 4:
+                  return signed ? function (pointer) {
+                    return HEAP32[pointer >> 2];
+                  } : function (pointer) {
+                    return HEAPU32[pointer >> 2];
+                  };
+                case 8:
+                  return signed ? function (pointer) {
+                    return HEAP64[pointer >> 3];
+                  } : function (pointer) {
+                    return HEAPU64[pointer >> 3];
+                  };
+                default:
+                  throw new TypeError("invalid integer width (" + width + "): " + name);
+              }
+            };
+            /** @suppress {globalThis} */
+            __embind_register_bigint = function __embind_register_bigint(primitiveType, name, size, minRange, maxRange) {
+              name = AsciiToString(name);
+              var isUnsignedType = minRange === 0n;
+              var fromWireType = function fromWireType(value) {
+                return value;
+              };
+              if (isUnsignedType) {
+                // uint64 get converted to int64 in ABI, fix them up like we do for 32-bit integers.
+                var bitSize = size * 8;
+                fromWireType = function fromWireType(value) {
+                  return BigInt.asUintN(bitSize, value);
+                };
+                maxRange = fromWireType(maxRange);
+              }
+              registerType(primitiveType, {
+                name: name,
+                fromWireType: fromWireType,
+                toWireType: function toWireType(destructors, value) {
+                  if (typeof value == 'number') {
+                    value = BigInt(value);
+                  }
+                  return value;
+                },
+                readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType),
+                destructorFunction: null // This type does not need a destructor
+              });
+            };
+            /** @suppress {globalThis} */
+            __embind_register_bool = function __embind_register_bool(rawType, name, trueValue, falseValue) {
+              name = AsciiToString(name);
+              registerType(rawType, {
+                name: name,
+                fromWireType: function fromWireType(wt) {
+                  // ambiguous emscripten ABI: sometimes return values are
+                  // true or false, and sometimes integers (0 or 1)
+                  return !!wt;
+                },
+                toWireType: function toWireType(destructors, o) {
+                  return o ? trueValue : falseValue;
+                },
+                readValueFromPointer: function readValueFromPointer(pointer) {
+                  return this.fromWireType(HEAPU8[pointer]);
+                },
+                destructorFunction: null // This type does not need a destructor
+              });
+            };
+            shallowCopyInternalPointer = 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
+              };
+            };
+            throwInstanceAlreadyDeleted = function throwInstanceAlreadyDeleted(obj) {
+              function getInstanceTypeName(handle) {
+                return handle.$$.ptrType.registeredClass.name;
+              }
+              throwBindingError(getInstanceTypeName(obj) + ' instance already deleted');
+            };
+            finalizationRegistry = false;
+            detachFinalizer = function detachFinalizer(handle) {};
+            runDestructor = function runDestructor($$) {
+              if ($$.smartPtr) {
+                $$.smartPtrType.rawDestructor($$.smartPtr);
+              } else {
+                $$.ptrType.registeredClass.rawDestructor($$.ptr);
+              }
+            };
+            releaseClassHandle = function releaseClassHandle($$) {
+              $$.count.value -= 1;
+              var toDelete = 0 === $$.count.value;
+              if (toDelete) {
+                runDestructor($$);
+              }
+            };
+            _attachFinalizer = function attachFinalizer(handle) {
+              if ('undefined' === typeof FinalizationRegistry) {
+                _attachFinalizer = function attachFinalizer(handle) {
+                  return handle;
+                };
+                return handle;
+              }
+              // If the running environment has a FinalizationRegistry (see
+              // https://github.com/tc39/proposal-weakrefs), then attach finalizers
+              // for class handles.  We check for the presence of FinalizationRegistry
+              // at run-time, not build-time.
+              finalizationRegistry = new FinalizationRegistry(function (info) {
+                releaseClassHandle(info.$$);
+              });
+              _attachFinalizer = function attachFinalizer(handle) {
+                var $$ = handle.$$;
+                var hasSmartPtr = !!$$.smartPtr;
+                if (hasSmartPtr) {
+                  // We should not call the destructor on raw pointers in case other code expects the pointee to live
+                  var info = {
+                    $$: $$
+                  };
+                  finalizationRegistry.register(handle, info, handle);
+                }
+                return handle;
+              };
+              detachFinalizer = function detachFinalizer(handle) {
+                return finalizationRegistry.unregister(handle);
+              };
+              return _attachFinalizer(handle);
+            };
+            init_ClassHandle = function init_ClassHandle() {
+              var proto = ClassHandle.prototype;
+              Object.assign(proto, {
+                isAliasOf: function isAliasOf(other) {
+                  if (!(this instanceof ClassHandle)) {
+                    return false;
+                  }
+                  if (!(other instanceof ClassHandle)) {
+                    return false;
+                  }
+                  var leftClass = this.$$.ptrType.registeredClass;
+                  var left = this.$$.ptr;
+                  other.$$ = /** @type {Object} */other.$$;
+                  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;
+                },
+                clone: function clone() {
+                  if (!this.$$.ptr) {
+                    throwInstanceAlreadyDeleted(this);
+                  }
+                  if (this.$$.preservePointerOnDelete) {
+                    this.$$.count.value += 1;
+                    return this;
+                  } else {
+                    var clone = _attachFinalizer(Object.create(Object.getPrototypeOf(this), {
+                      $$: {
+                        value: shallowCopyInternalPointer(this.$$)
+                      }
+                    }));
+                    clone.$$.count.value += 1;
+                    clone.$$.deleteScheduled = false;
+                    return clone;
+                  }
+                },
+                "delete": function _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;
+                  }
+                },
+                isDeleted: function isDeleted() {
+                  return !this.$$.ptr;
+                },
+                deleteLater: function deleteLater() {
+                  if (!this.$$.ptr) {
+                    throwInstanceAlreadyDeleted(this);
+                  }
+                  if (this.$$.deleteScheduled && !this.$$.preservePointerOnDelete) {
+                    throwBindingError('Object already scheduled for deletion');
+                  }
+                  this.$$.deleteScheduled = true;
+                  return this;
+                }
+              });
+
+              // Support `using ...` from https://github.com/tc39/proposal-explicit-resource-management.
+              var symbolDispose = Symbol.dispose;
+              if (symbolDispose) {
+                proto[symbolDispose] = proto['delete'];
+              }
+            };
+            /** @constructor */
+            createNamedFunction = function createNamedFunction(name, func) {
+              return Object.defineProperty(func, 'name', {
+                value: name
+              });
+            };
+            registeredPointers = {};
+            ensureOverloadTable = function ensureOverloadTable(proto, methodName, humanName) {
+              if (undefined === proto[methodName].overloadTable) {
+                var prevFunc = proto[methodName];
+                // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments.
+                proto[methodName] = function () {
+                  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                    args[_key] = arguments[_key];
+                  }
+                  // TODO This check can be removed in -O3 level "unsafe" optimizations.
+                  if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) {
+                    throwBindingError("Function '" + humanName + "' called with an invalid number of arguments (" + args.length + ") - expects one of (" + proto[methodName].overloadTable + ")!");
+                  }
+                  return proto[methodName].overloadTable[args.length].apply(this, args);
+                };
+                // Move the previous function into the overload table.
+                proto[methodName].overloadTable = [];
+                proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
+              }
+            };
+            /** @param {number=} numArguments */
+            exposePublicSymbol = function exposePublicSymbol(name, value, numArguments) {
+              if (Module.hasOwnProperty(name)) {
+                {
+                  throwBindingError("Cannot register public name '" + name + "' twice");
+                }
+
+                // We are exposing a function with the same name as an existing function. Create an overload table and a function selector
+                // that routes between the two.
+                ensureOverloadTable(Module, name, name);
+                if (Module[name].overloadTable.hasOwnProperty(numArguments)) {
+                  throwBindingError("Cannot register multiple overloads of a function with the same number of arguments (" + numArguments + ")!");
+                }
+                // Add the new function into the overload table.
+                Module[name].overloadTable[numArguments] = value;
+              } else {
+                Module[name] = value;
+                Module[name].argCount = numArguments;
+              }
+            };
+            char_0 = 48;
+            char_9 = 57;
+            makeLegalFunctionName = function makeLegalFunctionName(name) {
+              name = name.replace(/[^a-zA-Z0-9_]/g, '$');
+              var f = name.charCodeAt(0);
+              if (f >= char_0 && f <= char_9) {
+                return "_" + name;
+              }
+              return name;
+            };
+            /** @constructor */
+            upcastPointer = 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;
+            };
+            embindRepr = function embindRepr(v) {
+              if (v === null) {
+                return 'null';
+              }
+              var t = typeof v;
+              if (t === 'object' || t === 'array' || t === 'function') {
+                return v.toString();
+              } else {
+                return '' + v;
+              }
+            };
+            /** @suppress {globalThis} */
+            /** @suppress {globalThis} */
+            /** @suppress {globalThis} */
+            /** @suppress {globalThis} */
+            _downcastPointer = function downcastPointer(ptr, ptrClass, desiredClass) {
+              if (ptrClass === desiredClass) {
+                return ptr;
+              }
+              if (undefined === desiredClass.baseClass) {
+                return null; // no conversion
+              }
+              var rv = _downcastPointer(ptr, ptrClass, desiredClass.baseClass);
+              if (rv === null) {
+                return null;
+              }
+              return desiredClass.downcast(rv);
+            };
+            registeredInstances = {};
+            getBasestPointer = 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;
+            };
+            getInheritedInstance = function getInheritedInstance(class_, ptr) {
+              ptr = getBasestPointer(class_, ptr);
+              return registeredInstances[ptr];
+            };
+            InternalError = /*#__PURE__*/function (_Error2) {
+              function InternalError(message) {
+                var _this3;
+                _this3 = _Error2.call(this, message) || this;
+                _this3.name = 'InternalError';
+                return _this3;
+              }
+              _inheritsLoose(InternalError, _Error2);
+              return InternalError;
+            }( /*#__PURE__*/_wrapNativeSuper(Error));
+            throwInternalError = function throwInternalError(message) {
+              throw new InternalError(message);
+            };
+            makeClassHandle = 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,
+                  writable: true
+                }
+              }));
+            };
+            /** @suppress {globalThis} */
+            init_RegisteredPointer = function init_RegisteredPointer() {
+              Object.assign(RegisteredPointer.prototype, {
+                getPointee: function getPointee(ptr) {
+                  if (this.rawGetPointee) {
+                    ptr = this.rawGetPointee(ptr);
+                  }
+                  return ptr;
+                },
+                destructor: function destructor(ptr) {
+                  var _this$rawDestructor;
+                  (_this$rawDestructor = this.rawDestructor) == null || _this$rawDestructor.call(this, ptr);
+                },
+                readValueFromPointer: readPointer,
+                fromWireType: RegisteredPointer_fromWireType
+              });
+            };
+            /** @constructor
+                @param {*=} pointeeType,
+                @param {*=} sharingPolicy,
+                @param {*=} rawGetPointee,
+                @param {*=} rawConstructor,
+                @param {*=} rawShare,
+                @param {*=} rawDestructor,
+                 */
+            /** @param {number=} numArguments */
+            replacePublicSymbol = function replacePublicSymbol(name, value, numArguments) {
+              if (!Module.hasOwnProperty(name)) {
+                throwInternalError('Replacing nonexistent public symbol');
+              }
+              // If there's an overload table for this symbol, replace the symbol in the overload table instead.
+              if (undefined !== Module[name].overloadTable && undefined !== numArguments) ;else {
+                Module[name] = value;
+                Module[name].argCount = numArguments;
+              }
+            };
+            wasmTableMirror = [];
+            /** @type {WebAssembly.Table} */
+            getWasmTableEntry = function getWasmTableEntry(funcPtr) {
+              var func = wasmTableMirror[funcPtr];
+              if (!func) {
+                /** @suppress {checkTypes} */
+                wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+              }
+              return func;
+            };
+            embind__requireFunction = function embind__requireFunction(signature, rawFunction, isAsync) {
+              signature = AsciiToString(signature);
+              function makeDynCaller() {
+                var rtn = getWasmTableEntry(rawFunction);
+                return rtn;
+              }
+              var fp = makeDynCaller();
+              if (typeof fp != 'function') {
+                throwBindingError("unknown function pointer with signature " + signature + ": " + rawFunction);
+              }
+              return fp;
+            };
+            UnboundTypeError = /*#__PURE__*/function (_Error3) {
+              function UnboundTypeError() {
+                return _Error3.apply(this, arguments) || this;
+              }
+              _inheritsLoose(UnboundTypeError, _Error3);
+              return UnboundTypeError;
+            }( /*#__PURE__*/_wrapNativeSuper(Error));
+            getTypeName = function getTypeName(type) {
+              var ptr = ___getTypeName(type);
+              var rv = AsciiToString(ptr);
+              _free(ptr);
+              return rv;
+            };
+            throwUnboundTypeError = 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([', ']));
+            };
+            whenDependentTypesAreResolved = function whenDependentTypesAreResolved(myTypes, dependentTypes, getTypeConverters) {
+              myTypes.forEach(function (type) {
+                return 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(function (dt, i) {
+                if (registeredTypes.hasOwnProperty(dt)) {
+                  typeConverters[i] = registeredTypes[dt];
+                } else {
+                  unregisteredTypes.push(dt);
+                  if (!awaitingDependencies.hasOwnProperty(dt)) {
+                    awaitingDependencies[dt] = [];
+                  }
+                  awaitingDependencies[dt].push(function () {
+                    typeConverters[i] = registeredTypes[dt];
+                    ++registered;
+                    if (registered === unregisteredTypes.length) {
+                      onComplete(typeConverters);
+                    }
+                  });
+                }
+              });
+              if (0 === unregisteredTypes.length) {
+                onComplete(typeConverters);
+              }
+            };
+            __embind_register_class = function __embind_register_class(rawType, rawPointerType, rawConstPointerType, baseClassRawType, getActualTypeSignature, getActualType, upcastSignature, upcast, downcastSignature, downcast, name, destructorSignature, rawDestructor) {
+              name = AsciiToString(name);
+              getActualType = embind__requireFunction(getActualTypeSignature, getActualType);
+              upcast && (upcast = embind__requireFunction(upcastSignature, upcast));
+              downcast && (downcast = embind__requireFunction(downcastSignature, downcast));
+              rawDestructor = embind__requireFunction(destructorSignature, rawDestructor);
+              var legalFunctionName = makeLegalFunctionName(name);
+              exposePublicSymbol(legalFunctionName, function () {
+                // this code cannot run if baseClassRawType is zero
+                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(name, 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");
+                  }
+                  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                    args[_key2] = arguments[_key2];
+                  }
+                  var body = registeredClass.constructor_body[args.length];
+                  if (undefined === body) {
+                    throw new BindingError("Tried to invoke ctor of " + name + " with invalid number of parameters (" + args.length + ") - expected (" + Object.keys(registeredClass.constructor_body).toString() + ") parameters instead!");
+                  }
+                  return body.apply(this, args);
+                });
+                var instancePrototype = Object.create(basePrototype, {
+                  constructor: {
+                    value: constructor
+                  }
+                });
+                constructor.prototype = instancePrototype;
+                var registeredClass = new RegisteredClass(name, constructor, instancePrototype, rawDestructor, baseClass, getActualType, upcast, downcast);
+                if (registeredClass.baseClass) {
+                  var _registeredClass$base, _registeredClass$base2;
+                  // Keep track of class hierarchy. Used to allow sub-classes to inherit class functions.
+                  (_registeredClass$base2 = (_registeredClass$base = registeredClass.baseClass).__derivedClasses) != null ? _registeredClass$base2 : _registeredClass$base.__derivedClasses = [];
+                  registeredClass.baseClass.__derivedClasses.push(registeredClass);
+                }
+                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];
+              });
+            };
+            heap32VectorToArray = function heap32VectorToArray(count, firstElement) {
+              var array = [];
+              for (var i = 0; i < count; i++) {
+                // TODO(https://github.com/emscripten-core/emscripten/issues/17310):
+                // Find a way to hoist the `>> 2` or `>> 3` out of this loop.
+                array.push(HEAPU32[firstElement + i * 4 >> 2]);
+              }
+              return array;
+            };
+            runDestructors = function runDestructors(destructors) {
+              while (destructors.length) {
+                var ptr = destructors.pop();
+                var del = destructors.pop();
+                del(ptr);
+              }
+            };
+            __embind_register_class_constructor = function __embind_register_class_constructor(rawClassType, argCount, rawArgTypesAddr, invokerSignature, invoker, rawConstructor) {
+              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] = function () {
+                  throwUnboundTypeError("Cannot construct " + classType.name + " due to unbound types", rawArgTypes);
+                };
+                whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+                  // Insert empty slot for context type (argTypes[1]).
+                  argTypes.splice(1, 0, null);
+                  classType.registeredClass.constructor_body[argCount - 1] = craftInvokerFunction(humanName, argTypes, null, invoker, rawConstructor);
+                  return [];
+                });
+                return [];
+              });
+            };
+            getFunctionName = function getFunctionName(signature) {
+              signature = signature.trim();
+              var argsIndex = signature.indexOf('(');
+              if (argsIndex === -1) return signature;
+              return signature.slice(0, argsIndex);
+            };
+            __embind_register_class_function = function __embind_register_class_function(rawClassType, methodName, argCount, rawArgTypesAddr,
+            // [ReturnType, ThisType, Args...]
+            invokerSignature, rawInvoker, context, isPureVirtual, isAsync, isNonnullReturn) {
+              var rawArgTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
+              methodName = AsciiToString(methodName);
+              methodName = getFunctionName(methodName);
+              rawInvoker = embind__requireFunction(invokerSignature, rawInvoker, isAsync);
+              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) {
+                  // This is the first overload to be registered, OR we are replacing a
+                  // function in the base class with a function in the derived class.
+                  unboundTypesHandler.argCount = argCount - 2;
+                  unboundTypesHandler.className = classType.name;
+                  proto[methodName] = unboundTypesHandler;
+                } else {
+                  // There was an existing function with the same name registered. Set up
+                  // a function overload routing table.
+                  ensureOverloadTable(proto, methodName, humanName);
+                  proto[methodName].overloadTable[argCount - 2] = unboundTypesHandler;
+                }
+                whenDependentTypesAreResolved([], rawArgTypes, function (argTypes) {
+                  var memberFunction = craftInvokerFunction(humanName, argTypes, classType, rawInvoker, context, isAsync);
+
+                  // Replace the initial unbound-handler-stub function with the
+                  // appropriate member function, now that all types are resolved. If
+                  // multiple overloads are registered for this function, the function
+                  // goes into an overload table.
+                  if (undefined === proto[methodName].overloadTable) {
+                    // Set argCount in case an overload is registered later
+                    memberFunction.argCount = argCount - 2;
+                    proto[methodName] = memberFunction;
+                  } else {
+                    proto[methodName].overloadTable[argCount - 2] = memberFunction;
+                  }
+                  return [];
+                });
+                return [];
+              });
+            };
+            emval_freelist = [];
+            emval_handles = [0, 1,, 1, null, 1, true, 1, false, 1];
+            __emval_decref = function __emval_decref(handle) {
+              if (handle > 9 && 0 === --emval_handles[handle + 1]) {
+                emval_handles[handle] = undefined;
+                emval_freelist.push(handle);
+              }
+            };
+            Emval = {
+              toValue: function toValue(handle) {
+                if (!handle) {
+                  throwBindingError("Cannot use deleted val. handle = " + handle);
+                }
+                return emval_handles[handle];
+              },
+              toHandle: function toHandle(value) {
+                switch (value) {
+                  case undefined:
+                    return 2;
+                  case null:
+                    return 4;
+                  case true:
+                    return 6;
+                  case false:
+                    return 8;
+                  default:
+                    {
+                      var handle = emval_freelist.pop() || emval_handles.length;
+                      emval_handles[handle] = value;
+                      emval_handles[handle + 1] = 1;
+                      return handle;
+                    }
+                }
+              }
+            };
+            EmValType = {
+              name: 'emscripten::val',
+              fromWireType: function fromWireType(handle) {
+                var rv = Emval.toValue(handle);
+                __emval_decref(handle);
+                return rv;
+              },
+              toWireType: function toWireType(destructors, value) {
+                return Emval.toHandle(value);
+              },
+              readValueFromPointer: readPointer,
+              destructorFunction: null // This type does not need a destructor
+
+              // TODO: do we need a deleteObject here?  write a test where
+              // emval is passed into JS via an interface
+            };
+            __embind_register_emval = function __embind_register_emval(rawType) {
+              return registerType(rawType, EmValType);
+            };
+            floatReadValueFromPointer = function floatReadValueFromPointer(name, width) {
+              switch (width) {
+                case 4:
+                  return function (pointer) {
+                    return this.fromWireType(HEAPF32[pointer >> 2]);
+                  };
+                case 8:
+                  return function (pointer) {
+                    return this.fromWireType(HEAPF64[pointer >> 3]);
+                  };
+                default:
+                  throw new TypeError("invalid float width (" + width + "): " + name);
+              }
+            };
+            __embind_register_float = function __embind_register_float(rawType, name, size) {
+              name = AsciiToString(name);
+              registerType(rawType, {
+                name: name,
+                fromWireType: function fromWireType(value) {
+                  return value;
+                },
+                toWireType: function toWireType(destructors, value) {
+                  // The VM will perform JS to Wasm value conversion, according to the spec:
+                  // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue
+                  return value;
+                },
+                readValueFromPointer: floatReadValueFromPointer(name, size),
+                destructorFunction: null // This type does not need a destructor
+              });
+            };
+            /** @suppress {globalThis} */
+            __embind_register_integer = function __embind_register_integer(primitiveType, name, size, minRange, maxRange) {
+              name = AsciiToString(name);
+              var isUnsignedType = minRange === 0;
+              var fromWireType = function fromWireType(value) {
+                return value;
+              };
+              if (isUnsignedType) {
+                var bitshift = 32 - 8 * size;
+                fromWireType = function fromWireType(value) {
+                  return value << bitshift >>> bitshift;
+                };
+                maxRange = fromWireType(maxRange);
+              }
+              registerType(primitiveType, {
+                name: name,
+                fromWireType: fromWireType,
+                toWireType: function toWireType(destructors, value) {
+                  // The VM will perform JS to Wasm value conversion, according to the spec:
+                  // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue
+                  return value;
+                },
+                readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0),
+                destructorFunction: null // This type does not need a destructor
+              });
+            };
+            __embind_register_memory_view = function __embind_register_memory_view(rawType, dataTypeIndex, name) {
+              var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
+              var TA = typeMapping[dataTypeIndex];
+              function decodeMemoryView(handle) {
+                var size = HEAPU32[handle >> 2];
+                var data = HEAPU32[handle + 4 >> 2];
+                return new TA(HEAP8.buffer, data, size);
+              }
+              name = AsciiToString(name);
+              registerType(rawType, {
+                name: name,
+                fromWireType: decodeMemoryView,
+                readValueFromPointer: decodeMemoryView
+              }, {
+                ignoreDuplicateRegistrations: true
+              });
+            };
+            __embind_register_smart_ptr = function __embind_register_smart_ptr(rawType, rawPointeeType, name, sharingPolicy, getPointeeSignature, rawGetPointee, constructorSignature, rawConstructor, shareSignature, rawShare, destructorSignature, rawDestructor) {
+              name = AsciiToString(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,
+                // smart pointer properties
+                true, pointeeType, sharingPolicy, rawGetPointee, rawConstructor, rawShare, rawDestructor);
+                return [registeredPointer];
+              });
+            };
+            stringToUTF8Array = function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
+              // Parameter maxBytesToWrite is not optional. Negative values, 0, null,
+              // undefined and false each don't write out any bytes.
+              if (!(maxBytesToWrite > 0)) return 0;
+              var startIdx = outIdx;
+              var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
+              for (var i = 0; i < str.length; ++i) {
+                // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
+                // and https://www.ietf.org/rfc/rfc2279.txt
+                // and https://tools.ietf.org/html/rfc3629
+                var u = str.codePointAt(i);
+                if (u <= 0x7f) {
+                  if (outIdx >= endIdx) break;
+                  heap[outIdx++] = u;
+                } else if (u <= 0x7ff) {
+                  if (outIdx + 1 >= endIdx) break;
+                  heap[outIdx++] = 0xc0 | u >> 6;
+                  heap[outIdx++] = 0x80 | u & 63;
+                } else if (u <= 0xffff) {
+                  if (outIdx + 2 >= endIdx) break;
+                  heap[outIdx++] = 0xe0 | u >> 12;
+                  heap[outIdx++] = 0x80 | u >> 6 & 63;
+                  heap[outIdx++] = 0x80 | u & 63;
+                } else {
+                  if (outIdx + 3 >= endIdx) break;
+                  heap[outIdx++] = 0xf0 | u >> 18;
+                  heap[outIdx++] = 0x80 | u >> 12 & 63;
+                  heap[outIdx++] = 0x80 | u >> 6 & 63;
+                  heap[outIdx++] = 0x80 | u & 63;
+                  // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16.
+                  // We need to manually skip over the second code unit for correct iteration.
+                  i++;
+                }
+              }
+              // Null-terminate the pointer to the buffer.
+              heap[outIdx] = 0;
+              return outIdx - startIdx;
+            };
+            stringToUTF8 = function stringToUTF8(str, outPtr, maxBytesToWrite) {
+              return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+            };
+            lengthBytesUTF8 = function lengthBytesUTF8(str) {
+              var len = 0;
+              for (var i = 0; i < str.length; ++i) {
+                // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+                // unit, not a Unicode code point of the character! So decode
+                // UTF16->UTF32->UTF8.
+                // See http://unicode.org/faq/utf_bom.html#utf16-3
+                var c = str.charCodeAt(i); // possibly a lead surrogate
+                if (c <= 0x7f) {
+                  len++;
+                } else if (c <= 0x7ff) {
+                  len += 2;
+                } else if (c >= 0xd800 && c <= 0xdfff) {
+                  len += 4;
+                  ++i;
+                } else {
+                  len += 3;
+                }
+              }
+              return len;
+            };
+            UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder() : undefined;
+            findStringEnd = function findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul) {
+              var maxIdx = idx + maxBytesToRead;
+              if (ignoreNul) return maxIdx;
+              // TextDecoder needs to know the byte length in advance, it doesn't stop on
+              // null terminator by itself.
+              // As a tiny code save trick, compare idx against maxIdx using a negation,
+              // so that maxBytesToRead=undefined/NaN means Infinity.
+              while (heapOrArray[idx] && !(idx >= maxIdx)) ++idx;
+              return idx;
+            };
+            /**
+             * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
+             * array that contains uint8 values, returns a copy of that string as a
+             * Javascript String object.
+             * heapOrArray is either a regular array, or a JavaScript typed array view.
+             * @param {number=} idx
+             * @param {number=} maxBytesToRead
+             * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character.
+             * @return {string}
+             */
+            UTF8ArrayToString = function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead, ignoreNul) {
+              if (idx === void 0) {
+                idx = 0;
+              }
+              var endPtr = findStringEnd(heapOrArray, idx, maxBytesToRead, ignoreNul);
+
+              // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it.
+              if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+                return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+              }
+              var str = '';
+              while (idx < endPtr) {
+                // For UTF8 byte structure, see:
+                // http://en.wikipedia.org/wiki/UTF-8#Description
+                // https://www.ietf.org/rfc/rfc2279.txt
+                // https://tools.ietf.org/html/rfc3629
+                var u0 = heapOrArray[idx++];
+                if (!(u0 & 0x80)) {
+                  str += String.fromCharCode(u0);
+                  continue;
+                }
+                var u1 = heapOrArray[idx++] & 63;
+                if ((u0 & 0xe0) == 0xc0) {
+                  str += String.fromCharCode((u0 & 31) << 6 | u1);
+                  continue;
+                }
+                var u2 = heapOrArray[idx++] & 63;
+                if ((u0 & 0xf0) == 0xe0) {
+                  u0 = (u0 & 15) << 12 | u1 << 6 | u2;
+                } else {
+                  u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
+                }
+                if (u0 < 0x10000) {
+                  str += String.fromCharCode(u0);
+                } else {
+                  var ch = u0 - 0x10000;
+                  str += String.fromCharCode(0xd800 | ch >> 10, 0xdc00 | ch & 0x3ff);
+                }
+              }
+              return str;
+            };
+            /**
+             * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
+             * emscripten HEAP, returns a copy of that string as a Javascript String object.
+             *
+             * @param {number} ptr
+             * @param {number=} maxBytesToRead - An optional length that specifies the
+             *   maximum number of bytes to read. You can omit this parameter to scan the
+             *   string until the first 0 byte. If maxBytesToRead is passed, and the string
+             *   at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
+             *   string will cut short at that byte index.
+             * @param {boolean=} ignoreNul - If true, the function will not stop on a NUL character.
+             * @return {string}
+             */
+            UTF8ToString = function UTF8ToString(ptr, maxBytesToRead, ignoreNul) {
+              return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead, ignoreNul) : '';
+            };
+            __embind_register_std_string = function __embind_register_std_string(rawType, name) {
+              name = AsciiToString(name);
+              registerType(rawType, {
+                name: name,
+                // For some method names we use string keys here since they are part of
+                // the public/external API and/or used by the runtime-generated code.
+                fromWireType: function fromWireType(value) {
+                  var length = HEAPU32[value >> 2];
+                  var payload = value + 4;
+                  var str;
+                  {
+                    str = UTF8ToString(payload, length, true);
+                  }
+                  _free(value);
+                  return str;
+                },
+                toWireType: function toWireType(destructors, value) {
+                  if (value instanceof ArrayBuffer) {
+                    value = new Uint8Array(value);
+                  }
+                  var length;
+                  var valueIsOfTypeString = typeof value == 'string';
+
+                  // We accept `string` or array views with single byte elements
+                  if (!(valueIsOfTypeString || ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1)) {
+                    throwBindingError('Cannot pass non-string to std::string');
+                  }
+                  if (valueIsOfTypeString) {
+                    length = lengthBytesUTF8(value);
+                  } else {
+                    length = value.length;
+                  }
+
+                  // assumes POINTER_SIZE alignment
+                  var base = _malloc(4 + length + 1);
+                  var ptr = base + 4;
+                  HEAPU32[base >> 2] = length;
+                  if (valueIsOfTypeString) {
+                    {
+                      stringToUTF8(value, ptr, length + 1);
+                    }
+                  } else {
+                    HEAPU8.set(value, ptr);
+                  }
+                  if (destructors !== null) {
+                    destructors.push(_free, base);
+                  }
+                  return base;
+                },
+                readValueFromPointer: readPointer,
+                destructorFunction: function destructorFunction(ptr) {
+                  _free(ptr);
+                }
+              });
+            };
+            UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;
+            UTF16ToString = function UTF16ToString(ptr, maxBytesToRead, ignoreNul) {
+              var idx = ptr >> 1;
+              var endIdx = findStringEnd(HEAPU16, idx, maxBytesToRead / 2, ignoreNul);
+
+              // When using conditional TextDecoder, skip it for short strings as the overhead of the native call is not worth it.
+              if (endIdx - idx > 16 && UTF16Decoder) return UTF16Decoder.decode(HEAPU16.subarray(idx, endIdx));
+
+              // Fallback: decode without UTF16Decoder
+              var str = '';
+
+              // If maxBytesToRead is not passed explicitly, it will be undefined, and the
+              // for-loop's condition will always evaluate to true. The loop is then
+              // terminated on the first null char.
+              for (var i = idx; i < endIdx; ++i) {
+                var codeUnit = HEAPU16[i];
+                // fromCharCode constructs a character from a UTF-16 code unit, so we can
+                // pass the UTF16 string right through.
+                str += String.fromCharCode(codeUnit);
+              }
+              return str;
+            };
+            stringToUTF16 = function stringToUTF16(str, outPtr, maxBytesToWrite) {
+              var _maxBytesToWrite;
+              // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
+              (_maxBytesToWrite = maxBytesToWrite) != null ? _maxBytesToWrite : maxBytesToWrite = 0x7fffffff;
+              if (maxBytesToWrite < 2) return 0;
+              maxBytesToWrite -= 2; // Null terminator.
+              var startPtr = outPtr;
+              var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
+              for (var i = 0; i < numCharsToWrite; ++i) {
+                // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP.
+                var codeUnit = str.charCodeAt(i); // possibly a lead surrogate
+                HEAP16[outPtr >> 1] = codeUnit;
+                outPtr += 2;
+              }
+              // Null-terminate the pointer to the HEAP.
+              HEAP16[outPtr >> 1] = 0;
+              return outPtr - startPtr;
+            };
+            lengthBytesUTF16 = function lengthBytesUTF16(str) {
+              return str.length * 2;
+            };
+            UTF32ToString = function UTF32ToString(ptr, maxBytesToRead, ignoreNul) {
+              var str = '';
+              var startIdx = ptr >> 2;
+              // If maxBytesToRead is not passed explicitly, it will be undefined, and this
+              // will always evaluate to true. This saves on code size.
+              for (var i = 0; !(i >= maxBytesToRead / 4); i++) {
+                var utf32 = HEAPU32[startIdx + i];
+                if (!utf32 && !ignoreNul) break;
+                str += String.fromCodePoint(utf32);
+              }
+              return str;
+            };
+            stringToUTF32 = function stringToUTF32(str, outPtr, maxBytesToWrite) {
+              var _maxBytesToWrite2;
+              // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed.
+              (_maxBytesToWrite2 = maxBytesToWrite) != null ? _maxBytesToWrite2 : maxBytesToWrite = 0x7fffffff;
+              if (maxBytesToWrite < 4) return 0;
+              var startPtr = outPtr;
+              var endPtr = startPtr + maxBytesToWrite - 4;
+              for (var i = 0; i < str.length; ++i) {
+                var codePoint = str.codePointAt(i);
+                // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16.
+                // We need to manually skip over the second code unit for correct iteration.
+                if (codePoint > 0xffff) {
+                  i++;
+                }
+                HEAP32[outPtr >> 2] = codePoint;
+                outPtr += 4;
+                if (outPtr + 4 > endPtr) break;
+              }
+              // Null-terminate the pointer to the HEAP.
+              HEAP32[outPtr >> 2] = 0;
+              return outPtr - startPtr;
+            };
+            lengthBytesUTF32 = function lengthBytesUTF32(str) {
+              var len = 0;
+              for (var i = 0; i < str.length; ++i) {
+                var codePoint = str.codePointAt(i);
+                // Gotcha: if codePoint is over 0xFFFF, it is represented as a surrogate pair in UTF-16.
+                // We need to manually skip over the second code unit for correct iteration.
+                if (codePoint > 0xffff) {
+                  i++;
+                }
+                len += 4;
+              }
+              return len;
+            };
+            __embind_register_std_wstring = function __embind_register_std_wstring(rawType, charSize, name) {
+              name = AsciiToString(name);
+              var decodeString, encodeString, lengthBytesUTF;
+              if (charSize === 2) {
+                decodeString = UTF16ToString;
+                encodeString = stringToUTF16;
+                lengthBytesUTF = lengthBytesUTF16;
+              } else {
+                decodeString = UTF32ToString;
+                encodeString = stringToUTF32;
+                lengthBytesUTF = lengthBytesUTF32;
+              }
+              registerType(rawType, {
+                name: name,
+                fromWireType: function fromWireType(value) {
+                  // Code mostly taken from _embind_register_std_string fromWireType
+                  var length = HEAPU32[value >> 2];
+                  var str = decodeString(value + 4, length * charSize, true);
+                  _free(value);
+                  return str;
+                },
+                toWireType: function toWireType(destructors, value) {
+                  if (!(typeof value == 'string')) {
+                    throwBindingError("Cannot pass non-string to C++ string type " + name);
+                  }
+
+                  // assumes POINTER_SIZE alignment
+                  var length = lengthBytesUTF(value);
+                  var ptr = _malloc(4 + length + charSize);
+                  HEAPU32[ptr >> 2] = length / charSize;
+                  encodeString(value, ptr + 4, length + charSize);
+                  if (destructors !== null) {
+                    destructors.push(_free, ptr);
+                  }
+                  return ptr;
+                },
+                readValueFromPointer: readPointer,
+                destructorFunction: function destructorFunction(ptr) {
+                  _free(ptr);
+                }
+              });
+            };
+            __embind_register_void = function __embind_register_void(rawType, name) {
+              name = AsciiToString(name);
+              registerType(rawType, {
+                isVoid: true,
+                // void return values can be optimized out sometimes
+                name: name,
+                fromWireType: function fromWireType() {
+                  return undefined;
+                },
+                // TODO: assert if anything else is given?
+                toWireType: function toWireType(destructors, o) {
+                  return undefined;
+                }
+              });
+            };
+            emval_methodCallers = [];
+            emval_addMethodCaller = function emval_addMethodCaller(caller) {
+              var id = emval_methodCallers.length;
+              emval_methodCallers.push(caller);
+              return id;
+            };
+            requireRegisteredType = function requireRegisteredType(rawType, humanName) {
+              var impl = registeredTypes[rawType];
+              if (undefined === impl) {
+                throwBindingError(humanName + " has unknown type " + getTypeName(rawType));
+              }
+              return impl;
+            };
+            emval_lookupTypes = function emval_lookupTypes(argCount, argTypes) {
+              var a = new Array(argCount);
+              for (var i = 0; i < argCount; ++i) {
+                a[i] = requireRegisteredType(HEAPU32[argTypes + i * 4 >> 2], "parameter " + i);
+              }
+              return a;
+            };
+            emval_returnValue = function emval_returnValue(toReturnWire, destructorsRef, handle) {
+              var destructors = [];
+              var result = toReturnWire(destructors, handle);
+              if (destructors.length) {
+                // void, primitives and any other types w/o destructors don't need to allocate a handle
+                HEAPU32[destructorsRef >> 2] = Emval.toHandle(destructors);
+              }
+              return result;
+            };
+            emval_symbols = {};
+            getStringOrSymbol = function getStringOrSymbol(address) {
+              var symbol = emval_symbols[address];
+              if (symbol === undefined) {
+                return AsciiToString(address);
+              }
+              return symbol;
+            };
+            __emval_create_invoker = function __emval_create_invoker(argCount, argTypesPtr, kind) {
+              var GenericWireTypeSize = 8;
+              var _emval_lookupTypes = emval_lookupTypes(argCount, argTypesPtr),
+                retType = _emval_lookupTypes[0],
+                argTypes = _emval_lookupTypes.slice(1);
+              var toReturnWire = retType.toWireType.bind(retType);
+              var argFromPtr = argTypes.map(function (type) {
+                return type.readValueFromPointer.bind(type);
+              });
+              argCount--; // remove the extracted return type
+
+              var captures = {
+                toValue: Emval.toValue
+              };
+              var args = argFromPtr.map(function (argFromPtr, i) {
+                var captureName = "argFromPtr" + i;
+                captures[captureName] = argFromPtr;
+                return captureName + "(args" + (i ? '+' + i * GenericWireTypeSize : '') + ")";
+              });
+              var functionBody;
+              switch (kind) {
+                case 0:
+                  functionBody = 'toValue(handle)';
+                  break;
+                case 2:
+                  functionBody = 'new (toValue(handle))';
+                  break;
+                case 3:
+                  functionBody = '';
+                  break;
+                case 1:
+                  captures['getStringOrSymbol'] = getStringOrSymbol;
+                  functionBody = 'toValue(handle)[getStringOrSymbol(methodName)]';
+                  break;
+              }
+              functionBody += "(" + args + ")";
+              if (!retType.isVoid) {
+                captures['toReturnWire'] = toReturnWire;
+                captures['emval_returnValue'] = emval_returnValue;
+                functionBody = "return emval_returnValue(toReturnWire, destructorsRef, " + functionBody + ")";
+              }
+              functionBody = "return function (handle, methodName, destructorsRef, args) {\n  " + functionBody + "\n  }";
+              var invokerFunction = new Function(Object.keys(captures), functionBody).apply(void 0, Object.values(captures));
+              var functionName = "methodCaller<(" + argTypes.map(function (t) {
+                return t.name;
+              }) + ") => " + retType.name + ">";
+              return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));
+            };
+            __emval_incref = function __emval_incref(handle) {
+              if (handle > 9) {
+                emval_handles[handle + 1] += 1;
+              }
+            };
+            __emval_invoke = function __emval_invoke(caller, handle, methodName, destructorsRef, args) {
+              return emval_methodCallers[caller](handle, methodName, destructorsRef, args);
+            };
+            __emval_run_destructors = function __emval_run_destructors(handle) {
+              var destructors = Emval.toValue(handle);
+              runDestructors(destructors);
+              __emval_decref(handle);
+            };
+            INT53_MAX = 9007199254740992;
+            INT53_MIN = -9007199254740992;
+            bigintToI53Checked = function bigintToI53Checked(num) {
+              return num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
+            };
+            __tzset_js = function __tzset_js(timezone, daylight, std_name, dst_name) {
+              // TODO: Use (malleable) environment variables instead of system settings.
+              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();
+
+              // Local standard timezone offset. Local standard time is not adjusted for
+              // daylight savings.  This code uses the fact that getTimezoneOffset returns
+              // a greater value during Standard Time versus Daylight Saving Time (DST).
+              // Thus it determines the expected output during Standard Time, and it
+              // compares whether the output of the given date the same (Standard) or less
+              // (DST).
+              var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
+
+              // timezone is specified as seconds west of UTC ("The external variable
+              // `timezone` shall be set to the difference, in seconds, between
+              // Coordinated Universal Time (UTC) and local standard time."), the same
+              // as returned by stdTimezoneOffset.
+              // See http://pubs.opengroup.org/onlinepubs/009695399/functions/tzset.html
+              HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
+              HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
+              var extractZone = function extractZone(timezoneOffset) {
+                // Why inverse sign?
+                // Read here https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
+                var sign = timezoneOffset >= 0 ? '-' : '+';
+                var absOffset = Math.abs(timezoneOffset);
+                var hours = String(Math.floor(absOffset / 60)).padStart(2, '0');
+                var minutes = String(absOffset % 60).padStart(2, '0');
+                return "UTC" + sign + hours + minutes;
+              };
+              var winterName = extractZone(winterOffset);
+              var summerName = extractZone(summerOffset);
+              if (summerOffset < winterOffset) {
+                // Northern hemisphere
+                stringToUTF8(winterName, std_name, 17);
+                stringToUTF8(summerName, dst_name, 17);
+              } else {
+                stringToUTF8(winterName, dst_name, 17);
+                stringToUTF8(summerName, std_name, 17);
+              }
+            };
+            _emscripten_date_now = function _emscripten_date_now() {
+              return Date.now();
+            };
+            getHeapMax = function getHeapMax() {
+              return (
+                // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+                // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+                // for any code that deals with heap sizes, which would require special
+                // casing all heap size related code to treat 0 specially.
+                2147483648
+              );
+            };
+            alignMemory = function alignMemory(size, alignment) {
+              return Math.ceil(size / alignment) * alignment;
+            };
+            growMemory = function growMemory(size) {
+              var oldHeapSize = wasmMemory.buffer.byteLength;
+              var pages = (size - oldHeapSize + 65535) / 65536 | 0;
+              try {
+                // round size grow request up to wasm page size (fixed 64KB per spec)
+                wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size
+                updateMemoryViews();
+                return 1; /*success*/
+              } catch (e) {}
+              // implicit 0 return to save code size (caller will cast "undefined" into 0
+              // anyhow)
+            };
+            _emscripten_resize_heap = function _emscripten_resize_heap(requestedSize) {
+              var oldSize = HEAPU8.length;
+              // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
+              requestedSize >>>= 0;
+              // With multithreaded builds, races can happen (another thread might increase the size
+              // in between), so return a failure, and let the caller retry.
+
+              // Memory resize rules:
+              // 1.  Always increase heap size to at least the requested size, rounded up
+              //     to next page multiple.
+              // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
+              //     geometrically: increase the heap size according to
+              //     MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
+              //     overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
+              // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
+              //     linearly: increase the heap size by at least
+              //     MEMORY_GROWTH_LINEAR_STEP bytes.
+              // 3.  Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
+              //     MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
+              // 4.  If we were unable to allocate as much memory, it may be due to
+              //     over-eager decision to excessively reserve due to (3) above.
+              //     Hence if an allocation fails, cut down on the amount of excess
+              //     growth, in an attempt to succeed to perform a smaller allocation.
+
+              // A limit is set for how much we can grow. We should not exceed that
+              // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
+              var maxHeapSize = getHeapMax();
+              if (requestedSize > maxHeapSize) {
+                return false;
+              }
+
+              // Loop through potential heap size increases. If we attempt a too eager
+              // reservation that fails, cut down on the attempted size and reserve a
+              // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
+              for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+                var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth
+                // but limit overreserving (default to capping at +96MB overgrowth at most)
+                overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+                var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+                var replacement = growMemory(newSize);
+                if (replacement) {
+                  return true;
+                }
+              }
+              return false;
+            };
+            ENV = {};
+            getExecutableName = function getExecutableName() {
+              return thisProgram;
+            };
+            _getEnvStrings = function getEnvStrings() {
+              if (!_getEnvStrings.strings) {
+                // Default values.
+                // Browser language detection #8751
+                var lang = (typeof navigator == 'object' && navigator.language || 'C').replace('-', '_') + '.UTF-8';
+                var env = {
+                  USER: 'web_user',
+                  LOGNAME: 'web_user',
+                  PATH: '/',
+                  PWD: '/',
+                  HOME: '/home/web_user',
+                  LANG: lang,
+                  _: getExecutableName()
+                };
+                // Apply the user-provided values, if any.
+                for (var x in ENV) {
+                  // x is a key in ENV; if ENV[x] is undefined, that means it was
+                  // explicitly set to be so. We allow user code to do that to
+                  // force variables with default values to remain unset.
+                  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;
+            };
+            _environ_get = function _environ_get(__environ, environ_buf) {
+              var bufSize = 0;
+              var envp = 0;
+              for (var _iterator2 = _createForOfIteratorHelperLoose(_getEnvStrings()), _step2; !(_step2 = _iterator2()).done;) {
+                var string = _step2.value;
+                var ptr = environ_buf + bufSize;
+                HEAPU32[__environ + envp >> 2] = ptr;
+                bufSize += stringToUTF8(string, ptr, Infinity) + 1;
+                envp += 4;
+              }
+              return 0;
+            };
+            _environ_sizes_get = function _environ_sizes_get(penviron_count, penviron_buf_size) {
+              var strings = _getEnvStrings();
+              HEAPU32[penviron_count >> 2] = strings.length;
+              var bufSize = 0;
+              for (var _iterator3 = _createForOfIteratorHelperLoose(strings), _step3; !(_step3 = _iterator3()).done;) {
+                var string = _step3.value;
+                bufSize += lengthBytesUTF8(string) + 1;
+              }
+              HEAPU32[penviron_buf_size >> 2] = bufSize;
+              return 0;
+            };
+            _fd_close = function _fd_close(fd) {
+              return 52;
+            };
+            printCharBuffers = [null, [], []];
+            printChar = function printChar(stream, curr) {
+              var buffer = printCharBuffers[stream];
+              if (curr === 0 || curr === 10) {
+                (stream === 1 ? out : err)(UTF8ArrayToString(buffer));
+                buffer.length = 0;
+              } else {
+                buffer.push(curr);
+              }
+            };
+            _fd_write = function _fd_write(fd, iov, iovcnt, pnum) {
+              // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0
+              var num = 0;
+              for (var i = 0; i < iovcnt; i++) {
+                var ptr = HEAPU32[iov >> 2];
+                var len = HEAPU32[iov + 4 >> 2];
+                iov += 8;
+                for (var j = 0; j < len; j++) {
+                  printChar(fd, HEAPU8[ptr + j]);
+                }
+                num += len;
+              }
+              HEAPU32[pnum >> 2] = num;
+              return 0;
+            };
+            init_ClassHandle();
+            init_RegisteredPointer();
+
+            // Begin runtime exports
+            // End runtime exports
+            // Begin JS library exports
+            // End JS library exports
+
+            // end include: postlibrary.js
+
+            // Imports from the Wasm binary.
+            wasmImports = {
+              /** @export */
+              _abort_js: __abort_js,
+              /** @export */
+              _embind_register_bigint: __embind_register_bigint,
+              /** @export */
+              _embind_register_bool: __embind_register_bool,
+              /** @export */
+              _embind_register_class: __embind_register_class,
+              /** @export */
+              _embind_register_class_constructor: __embind_register_class_constructor,
+              /** @export */
+              _embind_register_class_function: __embind_register_class_function,
+              /** @export */
+              _embind_register_emval: __embind_register_emval,
+              /** @export */
+              _embind_register_float: __embind_register_float,
+              /** @export */
+              _embind_register_integer: __embind_register_integer,
+              /** @export */
+              _embind_register_memory_view: __embind_register_memory_view,
+              /** @export */
+              _embind_register_smart_ptr: __embind_register_smart_ptr,
+              /** @export */
+              _embind_register_std_string: __embind_register_std_string,
+              /** @export */
+              _embind_register_std_wstring: __embind_register_std_wstring,
+              /** @export */
+              _embind_register_void: __embind_register_void,
+              /** @export */
+              _emval_create_invoker: __emval_create_invoker,
+              /** @export */
+              _emval_decref: __emval_decref,
+              /** @export */
+              _emval_incref: __emval_incref,
+              /** @export */
+              _emval_invoke: __emval_invoke,
+              /** @export */
+              _emval_run_destructors: __emval_run_destructors,
+              /** @export */
+              _gmtime_js: __gmtime_js,
+              /** @export */
+              _tzset_js: __tzset_js,
+              /** @export */
+              emscripten_date_now: _emscripten_date_now,
+              /** @export */
+              emscripten_resize_heap: _emscripten_resize_heap,
+              /** @export */
+              environ_get: _environ_get,
+              /** @export */
+              environ_sizes_get: _environ_sizes_get,
+              /** @export */
+              fd_close: _fd_close,
+              /** @export */
+              fd_seek: _fd_seek,
+              /** @export */
+              fd_write: _fd_write
+            };
+            _context6.next = 158;
+            return createWasm();
+          case 158:
+            wasmExports = _context6.sent;
+            run();
+
+            // end include: postamble.js
+
+            // include: postamble_modularize.js
+            // In MODULARIZE mode we wrap the generated code in a factory function
+            // and return either the Module itself, or a promise of the module.
+            //
+            // We assign to the `moduleRtn` global here and configure closure to see
+            // this as and extern so it won't get minified.
+
+            if (runtimeInitialized) {
+              moduleRtn = Module;
+            } else {
+              // Set up the promise that indicates the Module is initialized
+              moduleRtn = new Promise(function (resolve, reject) {
+                readyPromiseResolve = resolve;
+                readyPromiseReject = reject;
+              });
+            }
+
+            // end include: postamble_modularize.js
+            return _context6.abrupt("return", moduleRtn);
+          case 162:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    }));
+    return _Module.apply(this, arguments);
+  }
+  var noopPrint = function noopPrint() {
+    // No-op
+  };
+  function defaultLocateFile(path, prefix) {
+    try {
+      var url = new URL(prefix);
+      if (url.pathname === '/') {
+        return prefix + "mediainfo.js/dist/" + path;
+      }
+    } catch (_unused) {
+      // empty
+    }
+    return prefix + "../" + path;
+  }
+
+  // TODO pass through more emscripten module options?
+
+  /**
+   * Creates a {@link MediaInfo} instance with the specified options.
+   *
+   * @typeParam TFormat - The format type, defaults to `object`.
+   * @param options - Configuration options for creating the {@link MediaInfo} instance.
+   * @returns A promise that resolves to a {@link MediaInfo} instance when no callback is provided.
+   */
+
+  /**
+   * Creates a {@link MediaInfo} instance with the specified options and executes the callback.
+   *
+   * @typeParam TFormat - The format type, defaults to `object`.
+   * @param options - Configuration options for creating the {@link MediaInfo} instance.
+   * @param callback - Function to call with the {@link MediaInfo} instance.
+   * @param errCallback - Optional function to call on error.
+   */
+
+  function mediaInfoFactory() {
+    var _options$format;
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var callback = arguments.length > 1 ? arguments[1] : undefined;
+    var errCallback = arguments.length > 2 ? arguments[2] : undefined;
+    if (callback === undefined) {
+      return new Promise(function (resolve, reject) {
+        mediaInfoFactory(options, resolve, reject);
+      });
+    }
+    var _DEFAULT_OPTIONS$opti = _extends({}, DEFAULT_OPTIONS, options, {
+        format: (_options$format = options.format) != null ? _options$format : DEFAULT_OPTIONS.format
+      }),
+      locateFile = _DEFAULT_OPTIONS$opti.locateFile,
+      mergedOptions = _objectWithoutPropertiesLoose(_DEFAULT_OPTIONS$opti, _excluded);
+    var mediaInfoModuleFactoryOpts = {
+      // Silence all print in module
+      print: noopPrint,
+      printErr: noopPrint,
+      locateFile: locateFile != null ? locateFile : defaultLocateFile,
+      onAbort: function onAbort(err) {
+        if (errCallback) {
+          errCallback(err);
+        }
+      }
+    };
+
+    // Fetch and load WASM module
+    Module(mediaInfoModuleFactoryOpts).then(function (wasmModule) {
+      callback(new MediaInfo(wasmModule, mergedOptions));
+    })["catch"](function (error) {
+      if (errCallback) {
+        errCallback(error);
+      }
+    });
+  }
+
+  /**
+   * Checks if a given object is of a specified track type.
+   *
+   * @template T - The type of track to check for.
+   * @param thing - The object to check.
+   * @param type - The track type to check against.
+   * @returns A boolean indicating whether the object is of the specified track type.
+   */
+  function isTrackType(thing, type) {
+    return thing !== null && typeof thing === 'object' && thing['@type'] === type;
+  }
+
+  var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: mediaInfoFactory,
+    isTrackType: isTrackType,
+    mediaInfoFactory: mediaInfoFactory
+  });
+
   exports.CapturedDocumentImg = CapturedDocumentImg;
   exports.CustomerBiometricsEnrollment = CustomerBiometricsEnrollment;
   exports.CustomerIdAndBiometricsEnrollment = CustomerIdAndBiometricsEnrollment;