idmission-web-sdk 2.3.54 → 2.3.55

package/dist/sdk2.umd.development.js

@@ -211,7 +211,7 @@
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
   };
 
-  var webSdkVersion = '2.3.54';
+  var webSdkVersion = '2.3.55';
 
   function getPlatform() {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
@@ -9477,11 +9477,18 @@
         return listeners["delete"](listener);
       };
     };
+    var destroy = function destroy() {
+      if ((undefined ? undefined.MODE : void 0) !== "production") {
+        console.warn("[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected.");
+      }
+      listeners.clear();
+    };
     var api = {
       setState: setState,
       getState: getState,
       getInitialState: getInitialState,
-      subscribe: subscribe
+      subscribe: subscribe,
+      destroy: destroy
     };
     var initialState = state = createState(setState, getState, api);
     return api;
@@ -9490,25 +9497,213 @@
     return createState ? createStoreImpl(createState) : createStoreImpl;
   };
 
+  var withSelector = {exports: {}};
+
+  var shim = {exports: {}};
+
+  var useSyncExternalStoreShim_development = {};
+
+  /**
+   * @license React
+   * use-sync-external-store-shim.development.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  var hasRequiredUseSyncExternalStoreShim_development;
+  function requireUseSyncExternalStoreShim_development() {
+    if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+    hasRequiredUseSyncExternalStoreShim_development = 1;
+    (function () {
+      function is(x, y) {
+        return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      function useSyncExternalStore$2(subscribe, getSnapshot) {
+        didWarnOld18Alpha || void 0 === React$1.startTransition || (didWarnOld18Alpha = !0, console.error("You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."));
+        var value = getSnapshot();
+        if (!didWarnUncachedGetSnapshot) {
+          var cachedValue = getSnapshot();
+          objectIs(value, cachedValue) || (console.error("The result of getSnapshot should be cached to avoid an infinite loop"), didWarnUncachedGetSnapshot = !0);
+        }
+        cachedValue = useState({
+          inst: {
+            value: value,
+            getSnapshot: getSnapshot
+          }
+        });
+        var inst = cachedValue[0].inst,
+          forceUpdate = cachedValue[1];
+        useLayoutEffect(function () {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          checkIfSnapshotChanged(inst) && forceUpdate({
+            inst: inst
+          });
+        }, [subscribe, value, getSnapshot]);
+        useEffect(function () {
+          checkIfSnapshotChanged(inst) && forceUpdate({
+            inst: inst
+          });
+          return subscribe(function () {
+            checkIfSnapshotChanged(inst) && forceUpdate({
+              inst: inst
+            });
+          });
+        }, [subscribe]);
+        useDebugValue(value);
+        return value;
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        inst = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(inst, nextValue);
+        } catch (error) {
+          return !0;
+        }
+      }
+      function useSyncExternalStore$1(subscribe, getSnapshot) {
+        return getSnapshot();
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var React$1 = React,
+        objectIs = "function" === typeof Object.is ? Object.is : is,
+        useState = React$1.useState,
+        useEffect = React$1.useEffect,
+        useLayoutEffect = React$1.useLayoutEffect,
+        useDebugValue = React$1.useDebugValue,
+        didWarnOld18Alpha = !1,
+        didWarnUncachedGetSnapshot = !1,
+        shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+      useSyncExternalStoreShim_development.useSyncExternalStore = void 0 !== React$1.useSyncExternalStore ? React$1.useSyncExternalStore : shim;
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+    return useSyncExternalStoreShim_development;
+  }
+
+  var hasRequiredShim;
+  function requireShim() {
+    if (hasRequiredShim) return shim.exports;
+    hasRequiredShim = 1;
+    {
+      shim.exports = requireUseSyncExternalStoreShim_development();
+    }
+    return shim.exports;
+  }
+
+  var withSelector_development = {};
+
+  /**
+   * @license React
+   * use-sync-external-store-shim/with-selector.development.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  var hasRequiredWithSelector_development;
+  function requireWithSelector_development() {
+    if (hasRequiredWithSelector_development) return withSelector_development;
+    hasRequiredWithSelector_development = 1;
+    (function () {
+      function is(x, y) {
+        return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var React$1 = React,
+        shim = requireShim(),
+        objectIs = "function" === typeof Object.is ? Object.is : is,
+        useSyncExternalStore = shim.useSyncExternalStore,
+        useRef = React$1.useRef,
+        useEffect = React$1.useEffect,
+        useMemo = React$1.useMemo,
+        useDebugValue = React$1.useDebugValue;
+      withSelector_development.useSyncExternalStoreWithSelector = function (subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+        var instRef = useRef(null);
+        if (null === instRef.current) {
+          var inst = {
+            hasValue: !1,
+            value: null
+          };
+          instRef.current = inst;
+        } else inst = instRef.current;
+        instRef = useMemo(function () {
+          function memoizedSelector(nextSnapshot) {
+            if (!hasMemo) {
+              hasMemo = !0;
+              memoizedSnapshot = nextSnapshot;
+              nextSnapshot = selector(nextSnapshot);
+              if (void 0 !== isEqual && inst.hasValue) {
+                var currentSelection = inst.value;
+                if (isEqual(currentSelection, nextSnapshot)) return memoizedSelection = currentSelection;
+              }
+              return memoizedSelection = nextSnapshot;
+            }
+            currentSelection = memoizedSelection;
+            if (objectIs(memoizedSnapshot, nextSnapshot)) return currentSelection;
+            var nextSelection = selector(nextSnapshot);
+            if (void 0 !== isEqual && isEqual(currentSelection, nextSelection)) return memoizedSnapshot = nextSnapshot, currentSelection;
+            memoizedSnapshot = nextSnapshot;
+            return memoizedSelection = nextSelection;
+          }
+          var hasMemo = !1,
+            memoizedSnapshot,
+            memoizedSelection,
+            maybeGetServerSnapshot = void 0 === getServerSnapshot ? null : getServerSnapshot;
+          return [function () {
+            return memoizedSelector(getSnapshot());
+          }, null === maybeGetServerSnapshot ? void 0 : function () {
+            return memoizedSelector(maybeGetServerSnapshot());
+          }];
+        }, [getSnapshot, getServerSnapshot, selector, isEqual]);
+        var value = useSyncExternalStore(subscribe, instRef[0], instRef[1]);
+        useEffect(function () {
+          inst.hasValue = !0;
+          inst.value = value;
+        }, [value]);
+        useDebugValue(value);
+        return value;
+      };
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+    return withSelector_development;
+  }
+
+  {
+    withSelector.exports = requireWithSelector_development();
+  }
+  var withSelectorExports = withSelector.exports;
+  var useSyncExternalStoreExports = /*@__PURE__*/getDefaultExportFromCjs(withSelectorExports);
+
+  var useDebugValue = React.useDebugValue;
+  var useSyncExternalStoreWithSelector = useSyncExternalStoreExports.useSyncExternalStoreWithSelector;
+  var didWarnAboutEqualityFn = false;
   var identity = function identity(arg) {
     return arg;
   };
-  function useStore(api, selector) {
+  function useStore(api, selector, equalityFn) {
     if (selector === void 0) {
       selector = identity;
     }
-    var slice = React.useSyncExternalStore(api.subscribe, function () {
-      return selector(api.getState());
-    }, function () {
-      return selector(api.getInitialState());
-    });
-    React.useDebugValue(slice);
+    if ((undefined ? undefined.MODE : void 0) !== "production" && equalityFn && !didWarnAboutEqualityFn) {
+      console.warn("[DEPRECATED] Use `createWithEqualityFn` instead of `create` or use `useStoreWithEqualityFn` instead of `useStore`. They can be imported from 'zustand/traditional'. https://github.com/pmndrs/zustand/discussions/1937");
+      didWarnAboutEqualityFn = true;
+    }
+    var slice = useSyncExternalStoreWithSelector(api.subscribe, api.getState, api.getServerState || api.getInitialState, selector, equalityFn);
+    useDebugValue(slice);
     return slice;
   }
   var createImpl = function createImpl(createState) {
-    var api = createStore(createState);
-    var useBoundStore = function useBoundStore(selector) {
-      return useStore(api, selector);
+    if ((undefined ? undefined.MODE : void 0) !== "production" && typeof createState !== "function") {
+      console.warn("[DEPRECATED] Passing a vanilla store will be unsupported in a future version. Instead use `import { useStore } from 'zustand'`.");
+    }
+    var api = typeof createState === "function" ? createStore(createState) : createState;
+    var useBoundStore = function useBoundStore(selector, equalityFn) {
+      return useStore(api, selector, equalityFn);
     };
     Object.assign(useBoundStore, api);
     return useBoundStore;
@@ -14061,8 +14256,8 @@
       documentDetectionModelPath = _e === void 0 ? defaultDocumentDetectorModelPath : _e,
       _f = _a.documentDetectionModelScoreThreshold,
       documentDetectionModelScoreThreshold = _f === void 0 ? defaultDocumentDetectionScoreThreshold : _f,
-      _g = _a.documentDetectionModelLoadTimeoutMs,
-      documentDetectionModelLoadTimeoutMs = _g === void 0 ? defaultDocumentDetectionModelLoadTimeoutMs : _g,
+      _g = _a.modelLoadTimeoutMs,
+      modelLoadTimeoutMs = _g === void 0 ? defaultDocumentDetectionModelLoadTimeoutMs : _g,
       onDocumentDetectionModelError = _a.onDocumentDetectionModelError,
       _h = _a.shouldLoadModels,
       shouldLoadModelsProp = _h === void 0 ? true : _h;
@@ -14093,7 +14288,7 @@
     }, []);
     var _q = useLoadDocumentDetector({
         modelPath: documentDetectionModelPath,
-        modelLoadTimeoutMs: documentDetectionModelLoadTimeoutMs,
+        modelLoadTimeoutMs: modelLoadTimeoutMs,
         scoreThreshold: documentDetectionModelScoreThreshold,
         onModelError: onDocumentDetectionModelError,
         videoRef: videoRef,
@@ -14708,8 +14903,11 @@
       var extensionConnector;
       try {
         extensionConnector = (enabled != null ? enabled : (undefined ? undefined.MODE : void 0) !== "production") && window.__REDUX_DEVTOOLS_EXTENSION__;
-      } catch (e) {}
+      } catch (_e) {}
       if (!extensionConnector) {
+        if ((undefined ? undefined.MODE : void 0) !== "production" && enabled) {
+          console.warn("[zustand devtools middleware] Please install/enable Redux devtools extension");
+        }
         return fn(set, get, api);
       }
       var _extractConnectionInf = extractConnectionInformation(store, extensionConnector, options),
@@ -14780,7 +14978,7 @@
                   return;
                 }
                 if (Object.keys(action.state).length !== 1) {
-                  console.error("\n                    [zustand devtools middleware] Unsupported __setState action format.\n                    When using 'store' option in devtools(), the 'state' should have only one key, which is a value of 'store' that was passed in devtools(),\n                    and value of this only key should be a state object. Example: { \"type\": \"__setState\", \"state\": { \"abc123Store\": { \"foo\": \"bar\" } } }\n                    ");
+                  console.error("\n                    [zustand devtools middleware] Unsupported __setState action format. \n                    When using 'store' option in devtools(), the 'state' should have only one key, which is a value of 'store' that was passed in devtools(),\n                    and value of this only key should be a state object. Example: { \"type\": \"__setState\", \"state\": { \"abc123Store\": { \"foo\": \"bar\" } } }\n                    ");
                 }
                 var stateFromDevtools = action.state[store];
                 if (stateFromDevtools === void 0 || stateFromDevtools === null) {
@@ -14868,71 +15066,50 @@
   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; }
-  var isIterable = function isIterable(obj) {
-    return Symbol.iterator in obj;
-  };
-  var hasIterableEntries = function hasIterableEntries(value) {
-    return (
-      // HACK: avoid checking entries type
-      "entries" in value
-    );
-  };
-  var compareEntries = function compareEntries(valueA, valueB) {
-    var mapA = valueA instanceof Map ? valueA : new Map(valueA.entries());
-    var mapB = valueB instanceof Map ? valueB : new Map(valueB.entries());
-    if (mapA.size !== mapB.size) {
+  function shallow(objA, objB) {
+    if (Object.is(objA, objB)) {
+      return true;
+    }
+    if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
       return false;
     }
-    for (var _iterator = _createForOfIteratorHelperLoose(mapA), _step; !(_step = _iterator()).done;) {
-      var _step$value = _step.value,
-        key = _step$value[0],
-        value = _step$value[1];
-      if (!Object.is(value, mapB.get(key))) {
-        return false;
+    if (objA instanceof Map && objB instanceof Map) {
+      if (objA.size !== objB.size) return false;
+      for (var _iterator = _createForOfIteratorHelperLoose(objA), _step; !(_step = _iterator()).done;) {
+        var _step$value = _step.value,
+          key = _step$value[0],
+          value = _step$value[1];
+        if (!Object.is(value, objB.get(key))) {
+          return false;
+        }
       }
+      return true;
     }
-    return true;
-  };
-  var compareIterables = function compareIterables(valueA, valueB) {
-    var iteratorA = valueA[Symbol.iterator]();
-    var iteratorB = valueB[Symbol.iterator]();
-    var nextA = iteratorA.next();
-    var nextB = iteratorB.next();
-    while (!nextA.done && !nextB.done) {
-      if (!Object.is(nextA.value, nextB.value)) {
-        return false;
+    if (objA instanceof Set && objB instanceof Set) {
+      if (objA.size !== objB.size) return false;
+      for (var _iterator2 = _createForOfIteratorHelperLoose(objA), _step2; !(_step2 = _iterator2()).done;) {
+        var _value = _step2.value;
+        if (!objB.has(_value)) {
+          return false;
+        }
       }
-      nextA = iteratorA.next();
-      nextB = iteratorB.next();
-    }
-    return !!nextA.done && !!nextB.done;
-  };
-  function shallow(valueA, valueB) {
-    if (Object.is(valueA, valueB)) {
       return true;
     }
-    if (typeof valueA !== "object" || valueA === null || typeof valueB !== "object" || valueB === null) {
+    var keysA = Object.keys(objA);
+    if (keysA.length !== Object.keys(objB).length) {
       return false;
     }
-    if (!isIterable(valueA) || !isIterable(valueB)) {
-      return compareEntries({
-        entries: function entries() {
-          return Object.entries(valueA);
-        }
-      }, {
-        entries: function entries() {
-          return Object.entries(valueB);
-        }
-      });
-    }
-    if (hasIterableEntries(valueA) && hasIterableEntries(valueB)) {
-      return compareEntries(valueA, valueB);
+    for (var _i = 0, _keysA = keysA; _i < _keysA.length; _i++) {
+      var keyA = _keysA[_i];
+      if (!Object.prototype.hasOwnProperty.call(objB, keyA) || !Object.is(objA[keyA], objB[keyA])) {
+        return false;
+      }
     }
-    return compareIterables(valueA, valueB);
+    return true;
   }
-
+  var useRef = React.useRef;
   function useShallow(selector) {
-    var prev = React.useRef();
+    var prev = useRef();
     return function (state) {
       var next = selector(state);
       return shallow(prev.current, next) ? prev.current : prev.current = next;