@idscan/onboarding 2.7.5 → 2.9.0

package/dist/wrapper.es.js

@@ -0,0 +1,4376 @@
+import './Wrapper.css';var global = void 0;
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var runtime = { exports: {} };
+var hasRequiredRuntime;
+function requireRuntime() {
+  if (hasRequiredRuntime) return runtime.exports;
+  hasRequiredRuntime = 1;
+  (function(module) {
+    var runtime2 = (function(exports$1) {
+      var Op = Object.prototype;
+      var hasOwn = Op.hasOwnProperty;
+      var defineProperty = Object.defineProperty || function(obj, key, desc) {
+        obj[key] = desc.value;
+      };
+      var undefined$1;
+      var $Symbol = typeof Symbol === "function" ? Symbol : {};
+      var iteratorSymbol = $Symbol.iterator || "@@iterator";
+      var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+      var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+      function define(obj, key, value) {
+        Object.defineProperty(obj, key, {
+          value,
+          enumerable: true,
+          configurable: true,
+          writable: true
+        });
+        return obj[key];
+      }
+      try {
+        define({}, "");
+      } catch (err) {
+        define = function(obj, key, value) {
+          return obj[key] = value;
+        };
+      }
+      function wrap(innerFn, outerFn, self, tryLocsList) {
+        var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+        var generator = Object.create(protoGenerator.prototype);
+        var context = new Context(tryLocsList || []);
+        defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) });
+        return generator;
+      }
+      exports$1.wrap = wrap;
+      function tryCatch(fn, obj, arg) {
+        try {
+          return { type: "normal", arg: fn.call(obj, arg) };
+        } catch (err) {
+          return { type: "throw", arg: err };
+        }
+      }
+      var GenStateSuspendedStart = "suspendedStart";
+      var GenStateSuspendedYield = "suspendedYield";
+      var GenStateExecuting = "executing";
+      var GenStateCompleted = "completed";
+      var ContinueSentinel = {};
+      function Generator() {
+      }
+      function GeneratorFunction() {
+      }
+      function GeneratorFunctionPrototype() {
+      }
+      var IteratorPrototype = {};
+      define(IteratorPrototype, iteratorSymbol, function() {
+        return this;
+      });
+      var getProto = Object.getPrototypeOf;
+      var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+      if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+        IteratorPrototype = NativeIteratorPrototype;
+      }
+      var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+      GeneratorFunction.prototype = GeneratorFunctionPrototype;
+      defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: true });
+      defineProperty(
+        GeneratorFunctionPrototype,
+        "constructor",
+        { value: GeneratorFunction, configurable: true }
+      );
+      GeneratorFunction.displayName = define(
+        GeneratorFunctionPrototype,
+        toStringTagSymbol,
+        "GeneratorFunction"
+      );
+      function defineIteratorMethods(prototype) {
+        ["next", "throw", "return"].forEach(function(method) {
+          define(prototype, method, function(arg) {
+            return this._invoke(method, arg);
+          });
+        });
+      }
+      exports$1.isGeneratorFunction = function(genFun) {
+        var ctor = typeof genFun === "function" && genFun.constructor;
+        return ctor ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can
+        // do is to check its .name property.
+        (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+      };
+      exports$1.mark = function(genFun) {
+        if (Object.setPrototypeOf) {
+          Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+        } else {
+          genFun.__proto__ = GeneratorFunctionPrototype;
+          define(genFun, toStringTagSymbol, "GeneratorFunction");
+        }
+        genFun.prototype = Object.create(Gp);
+        return genFun;
+      };
+      exports$1.awrap = function(arg) {
+        return { __await: arg };
+      };
+      function AsyncIterator(generator, PromiseImpl) {
+        function invoke(method, arg, resolve, reject) {
+          var record = tryCatch(generator[method], generator, arg);
+          if (record.type === "throw") {
+            reject(record.arg);
+          } else {
+            var result = record.arg;
+            var value = result.value;
+            if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
+              return PromiseImpl.resolve(value.__await).then(function(value2) {
+                invoke("next", value2, resolve, reject);
+              }, function(err) {
+                invoke("throw", err, resolve, reject);
+              });
+            }
+            return PromiseImpl.resolve(value).then(function(unwrapped) {
+              result.value = unwrapped;
+              resolve(result);
+            }, function(error) {
+              return invoke("throw", error, resolve, reject);
+            });
+          }
+        }
+        var previousPromise;
+        function enqueue(method, arg) {
+          function callInvokeWithMethodAndArg() {
+            return new PromiseImpl(function(resolve, reject) {
+              invoke(method, arg, resolve, reject);
+            });
+          }
+          return previousPromise = // If enqueue has been called before, then we want to wait until
+          // all previous Promises have been resolved before calling invoke,
+          // so that results are always delivered in the correct order. If
+          // enqueue has not been called before, then it is important to
+          // call invoke immediately, without waiting on a callback to fire,
+          // so that the async generator function has the opportunity to do
+          // any necessary setup in a predictable way. This predictability
+          // is why the Promise constructor synchronously invokes its
+          // executor callback, and why async functions synchronously
+          // execute code before the first await. Since we implement simple
+          // async functions in terms of async generators, it is especially
+          // important to get this right, even though it requires care.
+          previousPromise ? previousPromise.then(
+            callInvokeWithMethodAndArg,
+            // Avoid propagating failures to Promises returned by later
+            // invocations of the iterator.
+            callInvokeWithMethodAndArg
+          ) : callInvokeWithMethodAndArg();
+        }
+        defineProperty(this, "_invoke", { value: enqueue });
+      }
+      defineIteratorMethods(AsyncIterator.prototype);
+      define(AsyncIterator.prototype, asyncIteratorSymbol, function() {
+        return this;
+      });
+      exports$1.AsyncIterator = AsyncIterator;
+      exports$1.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+        if (PromiseImpl === void 0) PromiseImpl = Promise;
+        var iter = new AsyncIterator(
+          wrap(innerFn, outerFn, self, tryLocsList),
+          PromiseImpl
+        );
+        return exports$1.isGeneratorFunction(outerFn) ? iter : iter.next().then(function(result) {
+          return result.done ? result.value : iter.next();
+        });
+      };
+      function makeInvokeMethod(innerFn, self, context) {
+        var state = GenStateSuspendedStart;
+        return function invoke(method, arg) {
+          if (state === GenStateExecuting) {
+            throw new Error("Generator is already running");
+          }
+          if (state === GenStateCompleted) {
+            if (method === "throw") {
+              throw arg;
+            }
+            return doneResult();
+          }
+          context.method = method;
+          context.arg = arg;
+          while (true) {
+            var delegate = context.delegate;
+            if (delegate) {
+              var delegateResult = maybeInvokeDelegate(delegate, context);
+              if (delegateResult) {
+                if (delegateResult === ContinueSentinel) continue;
+                return delegateResult;
+              }
+            }
+            if (context.method === "next") {
+              context.sent = context._sent = context.arg;
+            } else if (context.method === "throw") {
+              if (state === GenStateSuspendedStart) {
+                state = GenStateCompleted;
+                throw context.arg;
+              }
+              context.dispatchException(context.arg);
+            } else if (context.method === "return") {
+              context.abrupt("return", context.arg);
+            }
+            state = GenStateExecuting;
+            var record = tryCatch(innerFn, self, context);
+            if (record.type === "normal") {
+              state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+              if (record.arg === ContinueSentinel) {
+                continue;
+              }
+              return {
+                value: record.arg,
+                done: context.done
+              };
+            } else if (record.type === "throw") {
+              state = GenStateCompleted;
+              context.method = "throw";
+              context.arg = record.arg;
+            }
+          }
+        };
+      }
+      function maybeInvokeDelegate(delegate, context) {
+        var methodName = context.method;
+        var method = delegate.iterator[methodName];
+        if (method === undefined$1) {
+          context.delegate = null;
+          if (methodName === "throw" && delegate.iterator["return"]) {
+            context.method = "return";
+            context.arg = undefined$1;
+            maybeInvokeDelegate(delegate, context);
+            if (context.method === "throw") {
+              return ContinueSentinel;
+            }
+          }
+          if (methodName !== "return") {
+            context.method = "throw";
+            context.arg = new TypeError(
+              "The iterator does not provide a '" + methodName + "' method"
+            );
+          }
+          return ContinueSentinel;
+        }
+        var record = tryCatch(method, delegate.iterator, context.arg);
+        if (record.type === "throw") {
+          context.method = "throw";
+          context.arg = record.arg;
+          context.delegate = null;
+          return ContinueSentinel;
+        }
+        var info = record.arg;
+        if (!info) {
+          context.method = "throw";
+          context.arg = new TypeError("iterator result is not an object");
+          context.delegate = null;
+          return ContinueSentinel;
+        }
+        if (info.done) {
+          context[delegate.resultName] = info.value;
+          context.next = delegate.nextLoc;
+          if (context.method !== "return") {
+            context.method = "next";
+            context.arg = undefined$1;
+          }
+        } else {
+          return info;
+        }
+        context.delegate = null;
+        return ContinueSentinel;
+      }
+      defineIteratorMethods(Gp);
+      define(Gp, toStringTagSymbol, "Generator");
+      define(Gp, iteratorSymbol, function() {
+        return this;
+      });
+      define(Gp, "toString", function() {
+        return "[object Generator]";
+      });
+      function pushTryEntry(locs) {
+        var entry = { tryLoc: locs[0] };
+        if (1 in locs) {
+          entry.catchLoc = locs[1];
+        }
+        if (2 in locs) {
+          entry.finallyLoc = locs[2];
+          entry.afterLoc = locs[3];
+        }
+        this.tryEntries.push(entry);
+      }
+      function resetTryEntry(entry) {
+        var record = entry.completion || {};
+        record.type = "normal";
+        delete record.arg;
+        entry.completion = record;
+      }
+      function Context(tryLocsList) {
+        this.tryEntries = [{ tryLoc: "root" }];
+        tryLocsList.forEach(pushTryEntry, this);
+        this.reset(true);
+      }
+      exports$1.keys = function(val) {
+        var object = Object(val);
+        var keys = [];
+        for (var key in object) {
+          keys.push(key);
+        }
+        keys.reverse();
+        return function next() {
+          while (keys.length) {
+            var key2 = keys.pop();
+            if (key2 in object) {
+              next.value = key2;
+              next.done = false;
+              return next;
+            }
+          }
+          next.done = true;
+          return next;
+        };
+      };
+      function values(iterable) {
+        if (iterable) {
+          var iteratorMethod = iterable[iteratorSymbol];
+          if (iteratorMethod) {
+            return iteratorMethod.call(iterable);
+          }
+          if (typeof iterable.next === "function") {
+            return iterable;
+          }
+          if (!isNaN(iterable.length)) {
+            var i = -1, next = function next2() {
+              while (++i < iterable.length) {
+                if (hasOwn.call(iterable, i)) {
+                  next2.value = iterable[i];
+                  next2.done = false;
+                  return next2;
+                }
+              }
+              next2.value = undefined$1;
+              next2.done = true;
+              return next2;
+            };
+            return next.next = next;
+          }
+        }
+        return { next: doneResult };
+      }
+      exports$1.values = values;
+      function doneResult() {
+        return { value: undefined$1, done: true };
+      }
+      Context.prototype = {
+        constructor: Context,
+        reset: function(skipTempReset) {
+          this.prev = 0;
+          this.next = 0;
+          this.sent = this._sent = undefined$1;
+          this.done = false;
+          this.delegate = null;
+          this.method = "next";
+          this.arg = undefined$1;
+          this.tryEntries.forEach(resetTryEntry);
+          if (!skipTempReset) {
+            for (var name in this) {
+              if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+                this[name] = undefined$1;
+              }
+            }
+          }
+        },
+        stop: function() {
+          this.done = true;
+          var rootEntry = this.tryEntries[0];
+          var rootRecord = rootEntry.completion;
+          if (rootRecord.type === "throw") {
+            throw rootRecord.arg;
+          }
+          return this.rval;
+        },
+        dispatchException: function(exception) {
+          if (this.done) {
+            throw exception;
+          }
+          var context = this;
+          function handle(loc, caught) {
+            record.type = "throw";
+            record.arg = exception;
+            context.next = loc;
+            if (caught) {
+              context.method = "next";
+              context.arg = undefined$1;
+            }
+            return !!caught;
+          }
+          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+            var entry = this.tryEntries[i];
+            var record = entry.completion;
+            if (entry.tryLoc === "root") {
+              return handle("end");
+            }
+            if (entry.tryLoc <= this.prev) {
+              var hasCatch = hasOwn.call(entry, "catchLoc");
+              var hasFinally = hasOwn.call(entry, "finallyLoc");
+              if (hasCatch && hasFinally) {
+                if (this.prev < entry.catchLoc) {
+                  return handle(entry.catchLoc, true);
+                } else if (this.prev < entry.finallyLoc) {
+                  return handle(entry.finallyLoc);
+                }
+              } else if (hasCatch) {
+                if (this.prev < entry.catchLoc) {
+                  return handle(entry.catchLoc, true);
+                }
+              } else if (hasFinally) {
+                if (this.prev < entry.finallyLoc) {
+                  return handle(entry.finallyLoc);
+                }
+              } else {
+                throw new Error("try statement without catch or finally");
+              }
+            }
+          }
+        },
+        abrupt: function(type, arg) {
+          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+            var entry = this.tryEntries[i];
+            if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+              var finallyEntry = entry;
+              break;
+            }
+          }
+          if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+            finallyEntry = null;
+          }
+          var record = finallyEntry ? finallyEntry.completion : {};
+          record.type = type;
+          record.arg = arg;
+          if (finallyEntry) {
+            this.method = "next";
+            this.next = finallyEntry.finallyLoc;
+            return ContinueSentinel;
+          }
+          return this.complete(record);
+        },
+        complete: function(record, afterLoc) {
+          if (record.type === "throw") {
+            throw record.arg;
+          }
+          if (record.type === "break" || record.type === "continue") {
+            this.next = record.arg;
+          } else if (record.type === "return") {
+            this.rval = this.arg = record.arg;
+            this.method = "return";
+            this.next = "end";
+          } else if (record.type === "normal" && afterLoc) {
+            this.next = afterLoc;
+          }
+          return ContinueSentinel;
+        },
+        finish: function(finallyLoc) {
+          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+            var entry = this.tryEntries[i];
+            if (entry.finallyLoc === finallyLoc) {
+              this.complete(entry.completion, entry.afterLoc);
+              resetTryEntry(entry);
+              return ContinueSentinel;
+            }
+          }
+        },
+        "catch": function(tryLoc) {
+          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+            var entry = this.tryEntries[i];
+            if (entry.tryLoc === tryLoc) {
+              var record = entry.completion;
+              if (record.type === "throw") {
+                var thrown = record.arg;
+                resetTryEntry(entry);
+              }
+              return thrown;
+            }
+          }
+          throw new Error("illegal catch attempt");
+        },
+        delegateYield: function(iterable, resultName, nextLoc) {
+          this.delegate = {
+            iterator: values(iterable),
+            resultName,
+            nextLoc
+          };
+          if (this.method === "next") {
+            this.arg = undefined$1;
+          }
+          return ContinueSentinel;
+        }
+      };
+      return exports$1;
+    })(
+      // If this script is executing as a CommonJS module, use module.exports
+      // as the regeneratorRuntime namespace. Otherwise create a new empty
+      // object. Either way, the resulting object will be used to initialize
+      // the regeneratorRuntime variable at the top of this file.
+      module.exports
+    );
+    try {
+      regeneratorRuntime = runtime2;
+    } catch (accidentalStrictMode) {
+      if (typeof globalThis === "object") {
+        globalThis.regeneratorRuntime = runtime2;
+      } else {
+        Function("r", "regeneratorRuntime = r")(runtime2);
+      }
+    }
+  })(runtime);
+  return runtime.exports;
+}
+requireRuntime();
+const notEmptyString = (val) => !!val;
+const isUUID = (str) => !!str.match(/\w{8}-\w{4}-\w{4}-\w{4}-\w{12}/);
+const isPublicKey = (str) => str.toLowerCase().startsWith("pk_") && isUUID(str);
+const isElExist = (str) => !!document.getElementById(str);
+const isPackageVersionNumber = (input) => {
+  const regex2 = /^([1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+  return regex2.test(input);
+};
+class WrapperError extends Error {
+}
+class ConfigError extends WrapperError {
+  constructor(name) {
+    super(name);
+    this.message = `Configuration parameter error: ${name}`;
+    this.name = "ConfigError";
+    this.header = "Configuration Error!";
+    this.content = name || "";
+  }
+}
+const defaultDocumentTypes = [
+  {
+    type: "DL",
+    steps: [
+      {
+        type: "front",
+        name: "Document Front",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      },
+      {
+        type: "pdf",
+        name: "Document Back",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false,
+        enableFourCornerCapture: false
+      },
+      {
+        type: "face",
+        name: "Face",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      }
+    ]
+  },
+  {
+    type: "IC",
+    steps: [
+      {
+        type: "front",
+        name: "Document Front",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      },
+      {
+        type: "pdf",
+        name: "Document Back",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false,
+        enableFourCornerCapture: true
+      },
+      {
+        type: "face",
+        name: "Face",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      }
+    ]
+  },
+  {
+    type: "Passport",
+    steps: [
+      // { type: 'front', name: 'Document Front', mode: { uploader: true, video: true } },
+      {
+        type: "mrz",
+        name: "Document Front",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      },
+      {
+        type: "face",
+        name: "Face",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      }
+    ]
+  },
+  {
+    type: "PassportCard",
+    steps: [
+      {
+        type: "front",
+        name: "Document Front",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      },
+      {
+        type: "mrz",
+        name: "Document Back",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      },
+      {
+        type: "face",
+        name: "Face",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      }
+    ]
+  },
+  {
+    type: "GreenCard",
+    steps: [
+      {
+        type: "front",
+        name: "Document Front",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      },
+      {
+        type: "mrz",
+        name: "Document Back",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      },
+      {
+        type: "face",
+        name: "Face",
+        mode: { uploader: true, video: true },
+        autocaptureDelay: 0,
+        enableDesktopNotification: false
+      }
+    ]
+  },
+  {
+    type: "EmploymentAuthorization",
+    steps: [
+      { type: "front", name: "Document Front", mode: { uploader: true, video: true } },
+      { type: "mrz", name: "Document Back", mode: { uploader: true, video: true } },
+      { type: "face", name: "Face", mode: { uploader: true, video: true } }
+    ]
+  }
+];
+const createGuid = () => {
+  const s4 = () => Math.floor((1 + Math.random()) * 65536).toString(16).substring(1);
+  return `${s4() + s4()}-${s4()}-${s4()}-${s4()}-${s4()}${s4()}${s4()}`;
+};
+const getFilteredDocumentTypes = (documentTypes) => {
+  if (!documentTypes) {
+    return [];
+  }
+  return documentTypes.map((document2) => ({
+    ...document2,
+    steps: document2.steps.filter((step) => step.mode ? Object.values(step.mode).some(Boolean) : true)
+  })).filter((document2) => document2.steps.length).map((document2) => ({
+    type: document2.type,
+    steps: document2.steps
+  }));
+};
+const prepareDocumentTypes = (config) => {
+  let result;
+  const filteredDocuments = getFilteredDocumentTypes(config.documentTypes);
+  const passportDocument = filteredDocuments.find((document2) => document2.type === "Passport");
+  if (passportDocument) {
+    const mrzPassport = { type: "mrz", name: "Passport MRZ", mode: { uploader: true, video: true } };
+    const frontStepIndex = passportDocument.steps.findIndex((step) => step.type === "front");
+    if (frontStepIndex !== -1) {
+      passportDocument.steps.splice(frontStepIndex, 1, mrzPassport);
+    }
+  }
+  if (filteredDocuments.length === 0) {
+    result = defaultDocumentTypes;
+  } else {
+    result = filteredDocuments;
+  }
+  return result;
+};
+const getQueryParam = (param) => {
+  const urlParams = new URLSearchParams(window.location.search);
+  return urlParams.get(param);
+};
+const validateHOF = ({ name, value, validationFunctions }) => {
+  const res = validationFunctions.reduce((acc, validationFn) => acc && validationFn(value), true);
+  if (!res) {
+    throw new ConfigError(name);
+  }
+};
+const validateApplicantId = (applicantId) => {
+  const uuidValidationFunctions = [notEmptyString, isUUID];
+  const validateConfig = {
+    name: "applicantId",
+    value: applicantId,
+    validationFunctions: uuidValidationFunctions
+  };
+  validateHOF(validateConfig);
+};
+const validateWrapperConfig = ({
+  demoMode,
+  applicantId,
+  domainId,
+  domainApi,
+  publicKey,
+  el = "videoCapturingEl"
+}) => {
+  const uuidValidationFunctions = [notEmptyString, isUUID];
+  const pkValidationFunctions = [notEmptyString, isPublicKey];
+  const elValidationFunctions = [notEmptyString, isElExist];
+  [
+    demoMode ? null : {
+      name: "applicantId",
+      value: applicantId,
+      validationFunctions: uuidValidationFunctions
+    },
+    {
+      name: "domainId",
+      value: domainId,
+      validationFunctions: uuidValidationFunctions
+    },
+    {
+      name: "publicKey",
+      value: publicKey,
+      validationFunctions: pkValidationFunctions
+    },
+    {
+      name: "el",
+      value: el,
+      validationFunctions: elValidationFunctions
+    },
+    {
+      name: "domainApi should not be empty",
+      value: domainApi,
+      validationFunctions: [notEmptyString]
+    }
+  ].filter(Boolean).forEach((e) => validateHOF(e));
+};
+class Configs {
+  constructor(config) {
+    this.validate = () => {
+      validateWrapperConfig(this.wrapper);
+    };
+    this.wrapper = { ...config };
+    if (config.getApplicantIdFromURL) {
+      this.wrapper.applicantId = getQueryParam("requestId") || config.applicantId;
+    }
+  }
+  parseFromWeb(options) {
+    const parsedIDVCConfig = JSON.parse(options == null ? void 0 : options.jsonSettings);
+    if (this.isAuth || this.faceOnly) {
+      this.libConfig = this.faceAuthorizationConfig(parsedIDVCConfig);
+    } else {
+      parsedIDVCConfig.documentTypes = prepareDocumentTypes(parsedIDVCConfig);
+      this.libConfig = parsedIDVCConfig;
+    }
+    this.cssStyles = options == null ? void 0 : options.cssStyles;
+    this.cssVariables = options == null ? void 0 : options.cssVariables;
+  }
+  faceAuthorizationConfig(jsonSettings) {
+    jsonSettings.isShowDocumentTypeSelect = false;
+    jsonSettings.documentTypes = [
+      {
+        type: "DL",
+        steps: [
+          { type: "face", name: "Face", mode: { uploader: true, video: true } }
+        ]
+      }
+    ];
+    return jsonSettings;
+  }
+  getFirstStepModeState() {
+    const firstStepMode = structuredClone(this.firstStepMode);
+    return () => firstStepMode;
+  }
+  get firstStepMode() {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = this.libConfig) == null ? void 0 : _a.documentTypes[0]) == null ? void 0 : _b.steps[0]) == null ? void 0 : _c.mode;
+  }
+  set applicantId(applicantId) {
+    validateApplicantId(applicantId);
+    this.wrapper.applicantId = applicantId;
+  }
+  get applicantId() {
+    return this.wrapper.applicantId;
+  }
+  get domainId() {
+    return this.wrapper.domainId;
+  }
+  get publicKey() {
+    return this.wrapper.publicKey;
+  }
+  get domainApi() {
+    return this.wrapper.domainApi;
+  }
+  get onValidate() {
+    var _a, _b;
+    if ((_b = (_a = this.wrapper) == null ? void 0 : _a.callbacks) == null ? void 0 : _b.onValidate) {
+      return this.wrapper.callbacks.onValidate;
+    }
+    return () => {
+    };
+  }
+  get onError() {
+    var _a, _b;
+    if ((_b = (_a = this.wrapper) == null ? void 0 : _a.callbacks) == null ? void 0 : _b.onError) {
+      return this.wrapper.callbacks.onError;
+    }
+    return () => {
+    };
+  }
+  get onGetOptionsStart() {
+    var _a, _b;
+    if ((_b = (_a = this.wrapper) == null ? void 0 : _a.callbacks) == null ? void 0 : _b.onGetOptionsStart) {
+      return this.wrapper.callbacks.onGetOptionsStart;
+    }
+    return () => {
+    };
+  }
+  get onGetOptionsComplete() {
+    var _a, _b;
+    if ((_b = (_a = this.wrapper) == null ? void 0 : _a.callbacks) == null ? void 0 : _b.onGetOptionsComplete) {
+      return this.wrapper.callbacks.onGetOptionsComplete;
+    }
+    return () => {
+    };
+  }
+  set libConfig(config) {
+    var _a;
+    const prevLC = (_a = this.IDVCConfig) == null ? void 0 : _a.licenseKey;
+    if (this.wrapper.preferApiConfig) {
+      this.IDVCConfig = {
+        ...this.IDVCConfig,
+        ...config,
+        ...this.wrapper.callbacks
+      };
+    } else {
+      this.IDVCConfig = {
+        ...this.IDVCConfig,
+        ...config,
+        ...this.wrapper,
+        ...this.wrapper.callbacks
+      };
+    }
+    if (prevLC) {
+      this.IDVCConfig.licenseKey = prevLC;
+    }
+  }
+  get libConfig() {
+    return this.IDVCConfig || {};
+  }
+  get cssStylesConfig() {
+    return this.cssStyles;
+  }
+  get cssVariablesConfig() {
+    return this.cssVariables;
+  }
+  get mountElement() {
+    return this.wrapper.el || "videoCapturingEl";
+  }
+  get demoMode() {
+    return this.wrapper.demoMode || false;
+  }
+  get isAuth() {
+    return this.wrapper.isAuth || false;
+  }
+  get faceOnly() {
+    return this.wrapper.faceOnly || false;
+  }
+  get qrCodeLinkOrigin() {
+    return this.wrapper.qrCodeLinkOrigin || "https://diveonline.idscan.net";
+  }
+  get IDVCDownloadVersion() {
+    if (isPackageVersionNumber(this.wrapper.IDVCDownloadVersion || "")) {
+      return this.wrapper.IDVCDownloadVersion;
+    }
+    return "latest";
+  }
+}
+class NotValidApplicant extends WrapperError {
+  constructor(name) {
+    super(name);
+    this.message = "This application is closed";
+    this.name = "NotValidApplicant";
+    this.header = "Request Closed";
+    this.content = "This application is closed";
+  }
+}
+class ValidationError extends WrapperError {
+  constructor(error) {
+    super("ValidationError");
+    this.message = error.message || "Try again later";
+    this.name = "ValidationError";
+    this.setHeader(error);
+    this.content = error.message || "Try again later";
+    if (error == null ? void 0 : error.propertyErrors) {
+      const errorList = Object.values(error.propertyErrors).reduce((acc, errorText) => `${acc}<li class="idvc-modal__body__list__item">${errorText}</li>`, "");
+      this.content = `<ol class="idvc-modal__body__list">${errorList}</ol>`;
+    }
+  }
+  setHeader({ code = "" }) {
+    if (code && ["ApiError", "ValidationError", "MultipleErrors", "BadRequest"].includes(code)) {
+      this.header = "Something Went Wrong!";
+    } else {
+      this.header = "Data invalid";
+    }
+  }
+}
+class HttpError extends WrapperError {
+  constructor(response) {
+    super(response.status.toString());
+    const { status } = response;
+    let message;
+    switch (status) {
+      case 400:
+        message = "Bad Request";
+        break;
+      case 401:
+        message = "Unauthorized";
+        break;
+      case 403:
+        message = "Forbidden";
+        break;
+      case 404:
+        message = "Not Found";
+        break;
+      case 500:
+        message = "Server Error";
+        break;
+      default:
+        message = "Something Went Wrong!";
+    }
+    this.message = `Status code: ${status}. ${message}`;
+    this.name = "HttpError";
+    this.statusCode = status;
+    this.header = "Server Side Problems";
+    this.content = "Please try again later";
+  }
+}
+class RequestTimeoutError extends WrapperError {
+  constructor(name) {
+    super(name);
+    this.message = "This application is closed";
+    this.name = "RequestTimeoutError";
+    this.header = "Request Timeout";
+    this.content = "This application is closed";
+  }
+}
+const success = { "validationResponseId": 6223, "validationRequestId": "8151f48d-bab1-4491-037d-08d9b3c5cfec", "documentType": 1, "document": { "abbr3Country": "USA", "abbrCountry": "US", "address": "25805 VAN LEUVEN ST 136", "city": "LOMA LINDA", "class": "C", "country": "United States of America", "dob": "1961-01-07", "expires": "2024-01-07", "eyes": "Brown", "familyName": "GILMER", "firstName": "DARIENNE", "fullName": "DARIENNE ELIZABETH GILMER", "gender": "Female", "hair": "Black", "height": "064 IN", "id": "C3568758", "idType": "DL", "issued": "2019-01-07", "middleName": "ELIZABETH", "postalBox": null, "privateName": "ELIZABETH", "state": "CA", "template": "09", "weight": "77", "zip": "92354-0000" }, "attemptsLeft": 0, "status": 0, "validationStatus": { "expired": false, "documentIsValid": true, "faceIsValid": true }, "invalidDataErrors": null, "faceSuccess": null, "documentSuccess": null, "documentHasNotExpired": null, "documentValidationTests": [{ "displayName": "DMV", "name": "DMVValidation", "status": 0, "statusString": "Failed", "reason": "Internal Server Error" }, { "displayName": "IdentiFraud", "name": "IdentiFraudValidation", "status": -1, "statusString": "Disabled", "reason": "Integration was turned off" }] };
+const json = {
+  success
+};
+class FaceAuthorizationError extends WrapperError {
+  constructor(error) {
+    super("FaceAuthorizationError");
+    this.message = error.message || "Try again later";
+    this.name = "FaceAuthorizationError";
+    this.setHeader(error);
+    this.content = error.message || "Try again later";
+    if (error == null ? void 0 : error.propertyErrors) {
+      const errorList = Object.values(error.propertyErrors).reduce((acc, errorText) => `${acc}<li class="idvc-modal__body__list__item">${errorText}</li>`, "");
+      this.content = `<ol class="idvc-modal__body__list">${errorList}</ol>`;
+    }
+  }
+  setHeader({ code = "" }) {
+    if (code && ["ApiError", "ValidationError", "MultipleErrors", "BadRequest"].includes(code)) {
+      this.header = "Something Went Wrong!";
+    } else {
+      this.header = "Data invalid";
+    }
+  }
+}
+var ValidationStatus = /* @__PURE__ */ ((ValidationStatus2) => {
+  ValidationStatus2["DANGER"] = "danger";
+  ValidationStatus2["SUCCESS"] = "success";
+  ValidationStatus2["PRIMARY"] = "primary";
+  return ValidationStatus2;
+})(ValidationStatus || {});
+var ResponseStatus = /* @__PURE__ */ ((ResponseStatus2) => {
+  ResponseStatus2[ResponseStatus2["SUCCESS"] = 0] = "SUCCESS";
+  ResponseStatus2[ResponseStatus2["FAIL"] = 1] = "FAIL";
+  ResponseStatus2[ResponseStatus2["INVALID_DATA"] = 2] = "INVALID_DATA";
+  ResponseStatus2[ResponseStatus2["ERROR"] = 3] = "ERROR";
+  ResponseStatus2[ResponseStatus2["COMPLETE"] = 4] = "COMPLETE";
+  return ResponseStatus2;
+})(ResponseStatus || {});
+var QRCodeModalState = /* @__PURE__ */ ((QRCodeModalState2) => {
+  QRCodeModalState2["READY"] = "ready";
+  QRCodeModalState2["VALIDATING"] = "validating";
+  QRCodeModalState2["DONE_WITH_SUCCESS"] = "doneWithSuccess";
+  QRCodeModalState2["DONE_WITH_ERROR"] = "doneWithError";
+  return QRCodeModalState2;
+})(QRCodeModalState || {});
+var EmbeddedStatus = /* @__PURE__ */ ((EmbeddedStatus2) => {
+  EmbeddedStatus2[EmbeddedStatus2["NEVER_OPEN"] = 0] = "NEVER_OPEN";
+  EmbeddedStatus2[EmbeddedStatus2["OPEN"] = 1] = "OPEN";
+  EmbeddedStatus2[EmbeddedStatus2["CLOSED"] = 2] = "CLOSED";
+  EmbeddedStatus2[EmbeddedStatus2["CLOSED_FOREVER"] = 3] = "CLOSED_FOREVER";
+  return EmbeddedStatus2;
+})(EmbeddedStatus || {});
+var ClientType = /* @__PURE__ */ ((ClientType2) => {
+  ClientType2[ClientType2["WebLibStandalone"] = 0] = "WebLibStandalone";
+  ClientType2[ClientType2["WebLibDashboard"] = 1] = "WebLibDashboard";
+  ClientType2[ClientType2["Android"] = 2] = "Android";
+  ClientType2[ClientType2["Ios"] = 3] = "Ios";
+  return ClientType2;
+})(ClientType || {});
+var NotificationText = /* @__PURE__ */ ((NotificationText2) => {
+  NotificationText2[NotificationText2[""] = 0] = "";
+  NotificationText2[NotificationText2["sent via SMS"] = 1] = "sent via SMS";
+  NotificationText2[NotificationText2["sent via email"] = 2] = "sent via email";
+  NotificationText2[NotificationText2["sent via SMS or email"] = 3] = "sent via SMS or email";
+  return NotificationText2;
+})(NotificationText || {});
+var DocumentTypeIDs = /* @__PURE__ */ ((DocumentTypeIDs2) => {
+  DocumentTypeIDs2[DocumentTypeIDs2["DL"] = 1] = "DL";
+  DocumentTypeIDs2[DocumentTypeIDs2["Passport"] = 2] = "Passport";
+  DocumentTypeIDs2[DocumentTypeIDs2["PassportCard"] = 3] = "PassportCard";
+  DocumentTypeIDs2[DocumentTypeIDs2["CommonAccessCardOld"] = 4] = "CommonAccessCardOld";
+  DocumentTypeIDs2[DocumentTypeIDs2["CommonAccessCard"] = 5] = "CommonAccessCard";
+  DocumentTypeIDs2[DocumentTypeIDs2["GreenCard"] = 6] = "GreenCard";
+  DocumentTypeIDs2[DocumentTypeIDs2["InternationalId"] = 7] = "InternationalId";
+  DocumentTypeIDs2[DocumentTypeIDs2["VIN"] = 8] = "VIN";
+  DocumentTypeIDs2[DocumentTypeIDs2["Barcode"] = 11] = "Barcode";
+  DocumentTypeIDs2[DocumentTypeIDs2["FaceAuthorization"] = 10] = "FaceAuthorization";
+  DocumentTypeIDs2[DocumentTypeIDs2["EmploymentAuthorization"] = 9] = "EmploymentAuthorization";
+  return DocumentTypeIDs2;
+})(DocumentTypeIDs || {});
+var HttpStatus = /* @__PURE__ */ ((HttpStatus2) => {
+  HttpStatus2[HttpStatus2["OK"] = 200] = "OK";
+  HttpStatus2[HttpStatus2["Created"] = 201] = "Created";
+  HttpStatus2[HttpStatus2["Accepted"] = 202] = "Accepted";
+  HttpStatus2[HttpStatus2["NoContent"] = 204] = "NoContent";
+  HttpStatus2[HttpStatus2["BadRequest"] = 400] = "BadRequest";
+  HttpStatus2[HttpStatus2["Unauthorized"] = 401] = "Unauthorized";
+  HttpStatus2[HttpStatus2["PaymentRequired"] = 402] = "PaymentRequired";
+  HttpStatus2[HttpStatus2["Forbidden"] = 403] = "Forbidden";
+  HttpStatus2[HttpStatus2["NotFound"] = 404] = "NotFound";
+  HttpStatus2[HttpStatus2["MethodNotAllowed"] = 405] = "MethodNotAllowed";
+  HttpStatus2[HttpStatus2["Gone"] = 410] = "Gone";
+  HttpStatus2[HttpStatus2["RequestTimeout"] = 408] = "RequestTimeout";
+  HttpStatus2[HttpStatus2["Conflict"] = 409] = "Conflict";
+  HttpStatus2[HttpStatus2["PreconditionFailed"] = 412] = "PreconditionFailed";
+  HttpStatus2[HttpStatus2["LengthRequired"] = 411] = "LengthRequired";
+  HttpStatus2[HttpStatus2["PayloadTooLarge"] = 413] = "PayloadTooLarge";
+  HttpStatus2[HttpStatus2["RequestEntityTooLarge"] = 413] = "RequestEntityTooLarge";
+  HttpStatus2[HttpStatus2["RequestURITooLong"] = 414] = "RequestURITooLong";
+  HttpStatus2[HttpStatus2["UnsupportedMediaType"] = 415] = "UnsupportedMediaType";
+  HttpStatus2[HttpStatus2["RangeNotSatisfiable"] = 416] = "RangeNotSatisfiable";
+  HttpStatus2[HttpStatus2["ExpectationFailed"] = 417] = "ExpectationFailed";
+  HttpStatus2[HttpStatus2["ImATextDocument"] = 423] = "ImATextDocument";
+  HttpStatus2[HttpStatus2["Locked"] = 423] = "Locked";
+  HttpStatus2[HttpStatus2["MisdirectedRequest"] = 421] = "MisdirectedRequest";
+  HttpStatus2[HttpStatus2["NetworkAuthenticationRequired"] = 511] = "NetworkAuthenticationRequired";
+  HttpStatus2[HttpStatus2["InternalServerError"] = 500] = "InternalServerError";
+  HttpStatus2[HttpStatus2["NotImplemented"] = 501] = "NotImplemented";
+  HttpStatus2[HttpStatus2["BadGateway"] = 502] = "BadGateway";
+  HttpStatus2[HttpStatus2["ServiceUnavailable"] = 503] = "ServiceUnavailable";
+  HttpStatus2[HttpStatus2["GatewayTimeout"] = 504] = "GatewayTimeout";
+  HttpStatus2[HttpStatus2["HTTPVersionNotSupported"] = 505] = "HTTPVersionNotSupported";
+  HttpStatus2[HttpStatus2["VariantAlsoNegotiates"] = 506] = "VariantAlsoNegotiates";
+  HttpStatus2[HttpStatus2["InsufficientStorage"] = 507] = "InsufficientStorage";
+  HttpStatus2[HttpStatus2["NetworkConnectTimeoutError"] = 524] = "NetworkConnectTimeoutError";
+  return HttpStatus2;
+})(HttpStatus || {});
+class Api {
+  constructor(publicKey, domainApi = "https://api-dvsonline.idscan.net") {
+    this.idvcManifestUrl = "https://neurons.cdn.idscan.net/manifest.json";
+    this.HEADERS = {
+      "Content-Type": "application/json"
+    };
+    const baseUrl = `${domainApi}/api/v2/`;
+    this.baseUrl = `${baseUrl}public/`;
+    this.baseEmbeddedUrl = `${baseUrl}EmbeddedApp/`;
+    this.HEADERS.Authorization = `Bearer ${publicKey}`;
+  }
+  async checkApplicantIdIsNotClosed({
+    applicantId = "",
+    demoMode = false,
+    faceAuth = false,
+    faceOnly = false
+  }) {
+    if (demoMode) {
+      return true;
+    }
+    const url = `${this.baseUrl}Applicants/${applicantId}/Completed`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: this.HEADERS
+    });
+    if (response.ok && !faceAuth) {
+      throw new NotValidApplicant("request closed");
+    } else if (response.ok && faceAuth) {
+      return true;
+    } else if (HttpStatus.NotFound === response.status && faceAuth) {
+      throw new NotValidApplicant("validation not completed");
+    } else if (HttpStatus.NotFound === response.status && (!faceAuth || faceOnly)) {
+      return true;
+    }
+    if (HttpStatus.BadRequest === response.status) {
+      const responseData = await response.json();
+      throw new ValidationError(responseData);
+    } else {
+      throw new HttpError(response);
+    }
+  }
+  async getCurrentIdvcVersion() {
+    try {
+      const response = await fetch(this.idvcManifestUrl);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const jsonData = await response.json();
+      return jsonData.latestVersion;
+    } catch (error) {
+      console.error("Error fetching data:", error);
+      throw error;
+    }
+  }
+  async getOptions(integrationId) {
+    const url = `${this.baseUrl}Integrations/${integrationId}/Configuration`;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: this.HEADERS
+      });
+      if (response.ok) {
+        return await response.json();
+      }
+      throw new HttpError(response);
+    } catch (e) {
+      if (e instanceof HttpError) {
+        throw e;
+      } else {
+        throw new HttpError(e);
+      }
+    }
+  }
+  async validateApplicant(data, demoMode = false, isFaceAuth = false) {
+    if (demoMode) {
+      return json.success;
+    }
+    const url = `${this.baseUrl}Validation`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.HEADERS,
+      body: JSON.stringify(data)
+    });
+    if (response.ok) {
+      return response.json();
+    }
+    if (HttpStatus.BadRequest === response.status) {
+      const responseData = await response.json();
+      if (isFaceAuth) {
+        throw new FaceAuthorizationError(responseData);
+      }
+      throw new ValidationError(responseData);
+    } else if (HttpStatus.NotFound === response.status) {
+      const responseData = await response.json();
+      throw new FaceAuthorizationError(responseData);
+    } else {
+      throw new HttpError(response);
+    }
+  }
+  async forceClose(applicantId) {
+    const url = `${this.baseUrl}Applicants/${applicantId}/Complete`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.HEADERS
+    });
+    if (response.ok) {
+      return response.json();
+    }
+    if (HttpStatus.BadRequest === response.status) {
+      const responseData = await response.json();
+      throw new ValidationError(responseData);
+    } else {
+      throw new HttpError(response);
+    }
+  }
+  async closeEmbeddedApplication(applicantId, callback) {
+    let response;
+    try {
+      const embeddedUrl = `${this.baseEmbeddedUrl}Close/${applicantId}`;
+      response = await fetch(embeddedUrl, {
+        method: "POST",
+        headers: this.HEADERS
+      });
+      if (!response.ok) {
+        throw new Error(`Request Error: ${response.status}`);
+      } else {
+        callback();
+      }
+    } catch (e) {
+      if (e instanceof HttpError) {
+        throw e;
+      } else {
+        throw new HttpError(response);
+      }
+    }
+  }
+  async longPollingRequest(url, init, callback) {
+    try {
+      const embeddedUrl = `${this.baseEmbeddedUrl}${url}`;
+      const response = await fetch(embeddedUrl, init);
+      if (HttpStatus.RequestTimeout === response.status || HttpStatus.NetworkConnectTimeoutError === response.status) {
+        throw new RequestTimeoutError("Request Timeout");
+      }
+      if (!response.ok) {
+        throw new Error(`Request Error: ${response.status}`);
+      }
+      const data = await response.json();
+      callback(data);
+    } catch (error) {
+      if (error instanceof RequestTimeoutError) {
+        await this.longPollingRequest(url, init, callback);
+      }
+    }
+  }
+}
+const isString = (val) => typeof val === "string";
+const processingCheckMap = {
+  back: [DocumentTypeIDs.DL, DocumentTypeIDs.InternationalId],
+  mrz: [
+    DocumentTypeIDs.PassportCard,
+    DocumentTypeIDs.GreenCard,
+    DocumentTypeIDs.Passport,
+    DocumentTypeIDs.EmploymentAuthorization
+  ],
+  pdf: [DocumentTypeIDs.DL, DocumentTypeIDs.InternationalId]
+};
+const checkBackOrSecondImageProcessing = (documentType, steps) => {
+  var _a;
+  const backStep = steps.find((step) => Object.keys(processingCheckMap).includes(step.type));
+  if (!backStep) {
+    return false;
+  }
+  const allowedDocumentTypeIDs = (_a = processingCheckMap[backStep.type]) == null ? void 0 : _a.includes(documentType);
+  return allowedDocumentTypeIDs ?? false;
+};
+const checkOcrEnabled = (documentType, steps) => {
+  const isPassportFront = !!steps.find((step) => step.type === "mrz");
+  if (documentType === DocumentTypeIDs.Passport && isPassportFront) {
+    return true;
+  }
+  const hasFrontStep = steps.find((step) => step.type === "front");
+  return !!hasFrontStep;
+};
+class Lib {
+  constructor() {
+    this.cleanBase64 = (base64EncodedImage) => {
+      if (!base64EncodedImage || !isString(base64EncodedImage)) return "";
+      const splitPattern = /:image\/\w+;base64,/;
+      const parts = base64EncodedImage.split(splitPattern);
+      if (parts.length) {
+        return parts[parts.length - 1];
+      }
+      return "";
+    };
+    this.validationModel = (data) => {
+      var _a;
+      const isPassportDocument = data.documentType === DocumentTypeIDs.Passport;
+      const getBackData = () => {
+        const step = data.steps.find((item) => item.type === "pdf" || item.type === "mrz" || item.type === "back");
+        const trackString = (step == null ? void 0 : step.mrzText) || (step == null ? void 0 : step.trackString) || "";
+        if (isPassportDocument) {
+          return {
+            img: "",
+            trackString
+          };
+        }
+        return {
+          img: (step == null ? void 0 : step.img) || "",
+          trackString
+        };
+      };
+      const getFrontData = () => {
+        var _a2;
+        if (isPassportDocument) {
+          const frontPassportStep = data.steps.find((el) => el.type === "mrz");
+          if (frontPassportStep) {
+            return frontPassportStep.img;
+          }
+        }
+        return (_a2 = data.steps.find((el) => el.type === "front")) == null ? void 0 : _a2.img;
+      };
+      const back = getBackData();
+      return {
+        frontImageBase64: this.cleanBase64(getFrontData()),
+        backOrSecondImageBase64: this.cleanBase64(back == null ? void 0 : back.img),
+        faceImageBase64: this.cleanBase64((_a = data.steps.find((item) => item.type === "face")) == null ? void 0 : _a.img),
+        trackString: back.trackString,
+        ssn: "",
+        verifyFace: !!data.steps.find((item) => item.type === "face"),
+        documentType: data.documentType,
+        captureMethod: data.steps.reduce((acc, step) => `${acc}${+step.isAuto}`, ""),
+        userAgent: window.navigator.userAgent,
+        frontEndMetadata: data.metaData,
+        isBackOrSecondImageProcessingEnabled: checkBackOrSecondImageProcessing(
+          data.documentType,
+          data.steps
+        ),
+        isOcrEnabled: checkOcrEnabled(data.documentType, data.steps)
+      };
+    };
+  }
+  async initializeLibrary(loadIDVCFromCDN, idvcVersion, IDVCModule) {
+    if (!this.library) {
+      if (loadIDVCFromCDN) {
+        await this.loadFromCDN(idvcVersion);
+      } else {
+        this.loadFromNodeModules(IDVCModule);
+      }
+      this.postInitialize();
+    }
+  }
+  loadFromNodeModules(IDVCModule) {
+    this.library = new IDVCModule(this.IdvcConfig);
+  }
+  async loadFromCDN(idvcVersion) {
+    return new Promise((resolve, reject) => {
+      const script = document.createElement("script");
+      script.src = `https://neurons.cdn.idscan.net/${idvcVersion}-next/idvc.js`;
+      script.async = true;
+      script.onload = () => resolve(window.IDVC);
+      script.onerror = reject;
+      document.body.appendChild(script);
+    }).then((IDVCFromCDN) => {
+      this.library = new IDVCFromCDN(this.IdvcConfig);
+    }).catch((err) => {
+      console.log(err);
+    });
+  }
+  get initialized() {
+    return !!this.library;
+  }
+  get version() {
+    return this.library.version;
+  }
+  set configs({ IdvcConfig, CSSStylesConfig, CSSVariablesConfig }) {
+    this.IdvcConfig = IdvcConfig;
+    this.CSSStylesConfig = CSSStylesConfig;
+    this.CSSVariablesConfig = CSSVariablesConfig;
+  }
+  set loading(val) {
+    if (this.library) {
+      this.library.showSpinner(val);
+    }
+  }
+  postInitialize() {
+    document.head.insertAdjacentHTML("beforeend", `
+        <style id="onboarding-css-variables">${this.CSSVariablesConfig ? this.CSSVariablesConfig : ""}</style>
+        <style id="onboarding-css-config">${this.CSSStylesConfig ? this.CSSStylesConfig : ""}</style>
+      `);
+  }
+  reloadComponent(newConfig) {
+    this.library.reloadComponent(newConfig);
+  }
+  updateDocumentTypes(docTypes) {
+    this.library.updateDocumentTypes(docTypes);
+  }
+  restart() {
+    this.library.resetAllSteps();
+  }
+  showLoader(val, bottomText, topText) {
+    this.library.showLoader(val, bottomText, topText);
+  }
+  mixSubmit(name, fn) {
+    const prevCallback = this.IdvcConfig[name];
+    this.IdvcConfig[name] = (data) => {
+      if (prevCallback) {
+        const result = Promise.resolve(prevCallback(data));
+        result.then(() => {
+          fn(this.validationModel(data));
+        }).catch(() => {
+          fn(this.validationModel(data));
+        });
+      } else {
+        fn(this.validationModel(data));
+      }
+    };
+  }
+}
+const validationModalHTML = '<div class="idvc-modal-background" id="idvc-modal-background">\n  <div class="el-loading-spinner" id="idvc-loading-spinner">\n    <svg viewBox="25 25 50 50" class="circular">\n      <circle cx="50" cy="50" r="20" fill="none" class="path"></circle>\n    </svg>\n  </div>\n</div>\n<div class="idvc-modal idvc-modal_validation d-none" id="idvc-modal">\n  <div class="idvc-modal__header">\n    <svg width="20" height="20" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">\n      <path d="M8 1C9.97933 1.052 11.6278 1.73683 12.9455 3.0545C14.2632 4.37217 14.948 6.02067 15 8C14.948 9.97933 14.2632 11.6278 12.9455 12.9455C11.6278 14.2632 9.97933 14.948 8 15C6.02067 14.948 4.37217 14.2632 3.0545 12.9455C1.73683 11.6278 1.052 9.97933 1 8C1.052 6.02067 1.73683 4.37217 3.0545 3.0545C4.37217 1.73683 6.02067 1.052 8 1ZM8 4C7.729 4 7.505 4.099 7.328 4.297C7.151 4.495 7.07283 4.72933 7.0935 5L7.453 9C7.474 9.146 7.53383 9.26317 7.6325 9.3515C7.73117 9.43983 7.8535 9.48417 7.9995 9.4845C8.1455 9.48483 8.26783 9.4405 8.3665 9.3515C8.46517 9.2625 8.525 9.14533 8.546 9L8.9055 5C8.9265 4.729 8.84833 4.49467 8.671 4.297C8.49367 4.09933 8.27067 4.00033 8 4ZM8 12C8.22933 11.9897 8.4195 11.9115 8.5705 11.7655C8.7215 11.6195 8.797 11.432 8.797 11.203C8.797 10.974 8.7215 10.7838 8.5705 10.6325C8.4195 10.4812 8.22933 10.4057 8 10.406C7.77067 10.4063 7.5805 10.4818 7.4295 10.6325C7.2785 10.7832 7.203 10.9733 7.203 11.203C7.203 11.4327 7.2785 11.6202 7.4295 11.7655C7.5805 11.9108 7.77067 11.989 8 12Z" fill="#1C1C1C"/>\n    </svg>\n    <h2 class="idvc-modal__header__content">\n      Header\n    </h2>\n    <div class="idvc-modal__close-btn" id="idvc-close-modal-btn">\n      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1024 1024"><path fill="currentColor" d="M764.288 214.592 512 466.88 259.712 214.592a31.936 31.936 0 0 0-45.12 45.12L466.752 512 214.528 764.224a31.936 31.936 0 1 0 45.12 45.184L512 557.184l252.288 252.288a31.936 31.936 0 0 0 45.12-45.12L557.12 512.064l252.288-252.352a31.936 31.936 0 1 0-45.12-45.184z"></path></svg>\n    </div>\n  </div>\n  <div class="idvc-modal__body">\n    Please try again\n  </div>\n  <div class="idvc-modal__footer">\n    <button type="button" class="btn btn--primary" id="idvc-modal-try-again-btn"><span>Try again</span></button>\n    <button type="button" class="btn btn--default" id="idvc-modal-complete-btn"><span>Complete </span></button>\n  </div>\n</div>\n';
+const modalHTML = '<div class="idvc-modal d-none" id="idvc-modal">\n    <div class="idvc-modal__close-btn" id="idvc-close-modal-btn"></div>\n    <div class="idvc-modal__header">\n        <h2 class="idvc-modal__header__content"></h2>\n    </div>\n    <div class="idvc-modal__body"></div>\n    <div class="idvc-modal__footer"></div>\n</div>\n<div class="idvc-modal-background" id="idvc-modal-background">\n    <div class="el-loading-spinner" id="idvc-loading-spinner">\n        <svg viewBox="25 25 50 50" class="circular">\n            <circle cx="50" cy="50" r="20" fill="none" class="path"></circle>\n        </svg>\n    </div>\n</div>\n';
+class Modal {
+  constructor(mountEl) {
+    this._closable = true;
+    if (typeof mountEl === "string") {
+      this.mountEl = document.getElementById(mountEl);
+    } else {
+      this.mountEl = mountEl;
+    }
+    this.init();
+  }
+  init(html2 = modalHTML) {
+    this.modalContainer = document.createElement("div");
+    this.mountEl.append(this.modalContainer);
+    this.modalContainer.insertAdjacentHTML("beforeend", html2);
+    this.container = this.modalContainer.querySelector("#idvc-modal");
+    this.headerContainer = this.container.querySelector(".idvc-modal__header");
+    this.headerText = this.headerContainer.querySelector(".idvc-modal__header__content");
+    this.background = this.modalContainer.querySelector("#idvc-modal-background");
+    this.spinner = this.modalContainer.querySelector("#idvc-loading-spinner");
+    this.closeBtn = this.modalContainer.querySelector("#idvc-close-modal-btn");
+    this.mountEl.classList.add("pos-relative");
+    this.body = this.container.querySelector(".idvc-modal__body");
+    this.footer = this.container.querySelector(".idvc-modal__footer");
+    this.closeHandler();
+    this.background.classList.add("idvc-preload-element");
+  }
+  set closable(val) {
+    this._closable = val;
+    this.toggleCloseBtn();
+  }
+  set header(val) {
+    if (val) {
+      this.headerText.textContent = val.toString();
+      this.headerContainer.classList.remove("d-none");
+    } else {
+      this.headerContainer.classList.add("d-none");
+    }
+  }
+  set showBackground(val) {
+    if (val) {
+      this.background.classList.remove("d-none");
+    } else {
+      this.background.classList.add("d-none");
+    }
+  }
+  set content(val) {
+    if (val) {
+      this.body.innerHTML = val.toString();
+      this.body.classList.remove("d-none");
+    } else {
+      this.body.classList.add("d-none");
+    }
+  }
+  toggleCloseBtn() {
+    if (this._closable) {
+      this.closeBtn.classList.remove("d-none");
+    } else {
+      this.closeBtn.classList.add("d-none");
+    }
+  }
+  closeHandler() {
+    this.background.addEventListener("click", (event) => {
+      const target = event.target;
+      if (this._closable && target.classList.contains("idvc-modal-background")) {
+        this.hide();
+      }
+    });
+    this.closeBtn.addEventListener("click", () => {
+      this.hide();
+    });
+  }
+  hideSpinner() {
+    this.hide();
+    this.spinner.classList.add("d-none");
+  }
+  hide() {
+    this.showBackground = false;
+    this.container.classList.add("d-none");
+    this.background.classList.remove("idvc-preload-element");
+  }
+  show() {
+    const circular = this.modalContainer.querySelector(".circular");
+    circular.classList.add("d-none");
+    this.showBackground = true;
+    this.container.classList.remove("d-none");
+  }
+  showSpinner(val) {
+    if (val) {
+      this.spinner.classList.remove("d-none");
+    } else {
+      this.spinner.classList.add("d-none");
+    }
+  }
+  prepareBackgroundStyles() {
+    this.background.classList.add("idvc-after-submit");
+    this.mountEl.classList.add("pos-relative");
+  }
+}
+class ValidationModal extends Modal {
+  init(html2 = validationModalHTML) {
+    super.init(html2);
+    this.headerSign = this.headerContainer.querySelector("path");
+    this.tryAgainBtn = this.container.querySelector("#idvc-modal-try-again-btn");
+    this.completeBtn = this.container.querySelector("#idvc-modal-complete-btn");
+    this.addTryAgainHandler();
+    this.addCompleteHandler();
+  }
+  set type(rawType) {
+    if (rawType === ValidationStatus.SUCCESS) {
+      this.applySuccessValidationStyles();
+    }
+    this.headerSign.setAttribute("class", `color-${rawType}`);
+  }
+  set buttons({ tryAgain = false, complete = false }) {
+    const width = 100 / (+tryAgain + +complete);
+    const btnWidth = Number.isFinite(width) ? width : 0;
+    const widthClassName = `w-${btnWidth === 50 ? 45 : btnWidth}`;
+    this.setBtnVisible("tryAgain", tryAgain);
+    this.setBtnVisible("complete", complete);
+    if (!tryAgain && !complete) {
+      this.footer.classList.add("d-none");
+      this.footer.classList.remove("d-flex");
+    } else {
+      this.footer.classList.remove("d-none");
+      this.footer.classList.add("d-flex");
+    }
+    [this.tryAgainBtn, this.completeBtn].forEach((btn) => {
+      Array.from(btn.classList).forEach((className) => {
+        if (className.startsWith("w-")) {
+          btn.classList.remove(className);
+        }
+      });
+      btn.classList.add(widthClassName);
+    });
+  }
+  applySuccessValidationStyles() {
+    this.container.classList.add("center");
+    this.headerContainer.classList.add("center");
+  }
+  setBtnVisible(btnName, visible) {
+    const btn = btnName === "tryAgain" ? this.tryAgainBtn : this.completeBtn;
+    if (visible) {
+      btn.classList.remove("d-none");
+    } else {
+      btn.classList.add("d-none");
+    }
+  }
+  addTryAgainHandler() {
+    this.tryAgainBtn.onclick = () => this.hide();
+  }
+  addCompleteHandler(handler = () => {
+  }) {
+    this.completeBtn.onclick = () => {
+      this.hide();
+      handler();
+    };
+  }
+}
+const html$1 = '<div class="idvc-consent-form" id="idvc-consent-form">\n    <div class="idvc-consent-form__header">\n        <h2 class="idvc-consent-form__header__content">\n            Consent Agreement\n        </h2>\n    </div>\n    <div class="idvc-consent-form__body" id="idvc-consent-form-body">\n        <p id="idvc-consent-form-text">\n        </p>\n        <div class="input-wrapper">\n            <label for="idvc-full-name-input">\n                <span>\n                    <sup class="color-red">*</sup>\n                    Full Name\n                </span>\n            </label>\n            <input\n                type="text"\n                name="fullName"\n                id="idvc-full-name-input"\n            >\n        </div>\n        <div class="checkbox-wrapper">\n            <label class="checkbox-wrapper__star" for="idvc-consent">\n                <span>\n                    <sup class="color-red">*</sup>\n                </span>\n            </label>\n            <input type="checkbox" id="idvc-consent">\n            <span class="checkbox-wrapper__text" id="checkbox-wrapper__text"></span>\n        </div>\n    </div>\n    <div class="idvc-consent-form__footer">\n        <button type="button" class="btn btn--info" id="idvc-consent-form-cancel-btn">\n            <span>Cancel</span>\n        </button>\n        <button type="button" class="btn btn--primary btn--disabled" id="idvc-consent-form-proceed-btn">\n            <span>Proceed</span>\n        </button>\n    </div>\n</div>\n\n';
+class ConsentForm {
+  constructor({
+    mountElementID,
+    consentBodyText,
+    consentCheckboxText
+  }) {
+    this.target = {
+      inputState: "",
+      checkboxState: false
+    };
+    const target = document.getElementById(mountElementID);
+    target.insertAdjacentHTML("afterbegin", html$1);
+    const bodyTextContainer = document.getElementById("idvc-consent-form-text");
+    bodyTextContainer.innerHTML = consentBodyText;
+    const checkBoxTextContainer = document.getElementById("checkbox-wrapper__text");
+    checkBoxTextContainer.innerHTML = consentCheckboxText;
+    this.init();
+  }
+  init() {
+    this.el = document.getElementById("idvc-consent-form");
+    this.proceedBtn = document.getElementById("idvc-consent-form-proceed-btn");
+    this.cancelBtn = document.getElementById("idvc-consent-form-cancel-btn");
+    this.inputEl = document.getElementById("idvc-full-name-input");
+    this.checkboxEl = document.getElementById("idvc-consent");
+    const self = this;
+    const handler = {
+      set(obj, prop, value, receiver) {
+        Reflect.set(obj, prop, value, receiver);
+        if (self.isValidInput() && self.target.checkboxState) {
+          self.proceedBtn.disabled = false;
+          self.proceedBtn.classList.remove("btn--disabled");
+        } else {
+          self.proceedBtn.disabled = true;
+          self.proceedBtn.classList.add("btn--disabled");
+        }
+        return true;
+      },
+      get(obj, prop) {
+        return obj[prop];
+      }
+    };
+    this.state = new Proxy(this.target, handler);
+    this.proceedBtn.disabled = true;
+    this.proceedBtn.addEventListener("click", () => {
+      const proceedEvent = new Event("proceedEvent", { bubbles: true });
+      this.el.remove();
+      this.proceedBtn.dispatchEvent(proceedEvent);
+    }, { once: true });
+    this.cancelBtn.addEventListener("click", () => {
+      this.inputEl.value = "";
+      this.checkboxEl.checked = false;
+    });
+    this.inputEl.addEventListener("input", (e) => {
+      const target = e.target;
+      this.state.inputState = target.value;
+    });
+    this.checkboxEl.addEventListener("click", (e) => {
+      const target = e.target;
+      this.state.checkboxState = target.checked;
+    });
+  }
+  get form() {
+    return this.el;
+  }
+  isValidInput() {
+    return this.state.inputState.trim().length >= 3 && this.state.inputState.trim().length < 100;
+  }
+}
+class Validation {
+  constructor(response, modal) {
+    this.statuses = {
+      [ResponseStatus.SUCCESS]: "Verification complete!",
+      [ResponseStatus.FAIL]: "Validation failed!",
+      [ResponseStatus.INVALID_DATA]: "Data invalid!",
+      [ResponseStatus.ERROR]: "Something went wrong",
+      4: "Request closed"
+    };
+    this.result = {
+      type: ValidationStatus.PRIMARY,
+      header: "",
+      content: "",
+      buttons: {
+        tryAgain: false,
+        complete: false
+      }
+    };
+    this.modal = modal;
+    this.parseResponse(response);
+  }
+  parseResponse(response) {
+    const {
+      code = "",
+      message = "",
+      status = -1,
+      attemptsLeft = -1,
+      attemptsCount = -1,
+      invalidDataErrors = [],
+      notificationType = 0
+    } = response;
+    this.code = code;
+    this.message = message;
+    this.status = status;
+    this.attemptsLeft = attemptsLeft;
+    this.attemptsCount = attemptsCount;
+    this.invalidDataErrors = invalidDataErrors || [];
+    this.notificationType = notificationType;
+  }
+  calculateType() {
+    let type;
+    if (this.status === ResponseStatus.SUCCESS) {
+      type = ValidationStatus.SUCCESS;
+    } else if (this.status === ResponseStatus.ERROR) {
+      type = ValidationStatus.PRIMARY;
+    } else {
+      type = ValidationStatus.DANGER;
+    }
+    this.result.type = type;
+  }
+  calculateHeader() {
+    this.result.header = this.statuses[this.status] || this.statuses[3];
+  }
+  calculateContent() {
+    const isFakeDocWithAttempts = this.status === ResponseStatus.FAIL && this.attemptsLeft > 0;
+    if (isFakeDocWithAttempts || this.status === ResponseStatus.ERROR) {
+      this.result.content = "Please try again";
+    }
+    if (this.status === ResponseStatus.INVALID_DATA) {
+      const ocrMessage = "Image may be blurry. Please try taking photo again in a different room or with different lighting.";
+      const errorList = this.invalidDataErrors.reduce((acc, { code, message }) => `${acc}<li class="idvc-modal__body__list__item">${code === "OCRError" ? ocrMessage : message}</li>`, "");
+      const noNumbersClass = this.invalidDataErrors.length === 1 ? "idvc-modal__body__list--no-numbers" : "";
+      this.result.content = `<ol class="idvc-modal__body__list ${noNumbersClass}">${errorList}</ol>`;
+    }
+    if (this.status === ResponseStatus.FAIL && this.attemptsLeft === 0 && this.attemptsCount > 0) {
+      this.result.content = `No more attempts can be made.<br>You have made all ${this.attemptsCount}<br>of the allowed submissions.<br>Please have a new request link<br>${NotificationText[this.notificationType]}`;
+    }
+    if (this.code && this.message) {
+      this.result.content = this.message;
+    }
+  }
+  calculateFooter() {
+    const isFakeDocWithAttempts = this.status !== ResponseStatus.SUCCESS && this.attemptsLeft > 0;
+    if (this.status === 4) {
+      this.result.buttons.tryAgain = false;
+      this.result.buttons.complete = false;
+      return;
+    }
+    if (isFakeDocWithAttempts) {
+      this.result.buttons.tryAgain = true;
+      this.result.buttons.complete = true;
+    }
+    if ([ResponseStatus.FAIL, ResponseStatus.INVALID_DATA].includes(this.status)) {
+      this.result.buttons.tryAgain = true;
+    }
+  }
+  prepareModal() {
+    this.calculateType();
+    this.calculateHeader();
+    this.calculateContent();
+    this.calculateFooter();
+  }
+  showModal() {
+    this.modal.type = this.result.type;
+    this.modal.header = this.result.header;
+    this.modal.content = this.result.content;
+    this.modal.buttons = this.result.buttons;
+    this.modal.prepareBackgroundStyles();
+    this.modal.show();
+  }
+  hideModal() {
+    this.modal.hide();
+  }
+}
+const html = '<div class="qr-code-wrap">\n    <button class="qr-code-wrap__button" id="qr-code-wrap__button"><span class="qr-code-wrap__content">Verify Documents by Phone<svg class="qr-code-svg" width="18" height="18" viewBox="0 0 18 18" fill="none" xmlns="http://www.w3.org/2000/svg">\n        <path d="M0 8V0H8V8H0ZM2 6H6V2H2V6ZM0 18V10H8V18H0ZM2 16H6V12H2V16ZM10 8V0H18V8H10ZM12 6H16V2H12V6ZM16 18V16H18V18H16ZM10 12V10H12V12H10ZM12 14V12H14V14H12ZM10 16V14H12V16H10ZM12 18V16H14V18H12ZM14 16V14H16V16H14ZM14 12V10H16V12H14ZM16 14V12H18V14H16Z" fill="white"/>\n    </svg></span></button>\n</div>\n';
+var browser = {};
+var canPromise;
+var hasRequiredCanPromise;
+function requireCanPromise() {
+  if (hasRequiredCanPromise) return canPromise;
+  hasRequiredCanPromise = 1;
+  canPromise = function() {
+    return typeof Promise === "function" && Promise.prototype && Promise.prototype.then;
+  };
+  return canPromise;
+}
+var qrcode = {};
+var utils$1 = {};
+var hasRequiredUtils$1;
+function requireUtils$1() {
+  if (hasRequiredUtils$1) return utils$1;
+  hasRequiredUtils$1 = 1;
+  let toSJISFunction;
+  const CODEWORDS_COUNT = [
+    0,
+    // Not used
+    26,
+    44,
+    70,
+    100,
+    134,
+    172,
+    196,
+    242,
+    292,
+    346,
+    404,
+    466,
+    532,
+    581,
+    655,
+    733,
+    815,
+    901,
+    991,
+    1085,
+    1156,
+    1258,
+    1364,
+    1474,
+    1588,
+    1706,
+    1828,
+    1921,
+    2051,
+    2185,
+    2323,
+    2465,
+    2611,
+    2761,
+    2876,
+    3034,
+    3196,
+    3362,
+    3532,
+    3706
+  ];
+  utils$1.getSymbolSize = function getSymbolSize(version2) {
+    if (!version2) throw new Error('"version" cannot be null or undefined');
+    if (version2 < 1 || version2 > 40) throw new Error('"version" should be in range from 1 to 40');
+    return version2 * 4 + 17;
+  };
+  utils$1.getSymbolTotalCodewords = function getSymbolTotalCodewords(version2) {
+    return CODEWORDS_COUNT[version2];
+  };
+  utils$1.getBCHDigit = function(data) {
+    let digit = 0;
+    while (data !== 0) {
+      digit++;
+      data >>>= 1;
+    }
+    return digit;
+  };
+  utils$1.setToSJISFunction = function setToSJISFunction(f) {
+    if (typeof f !== "function") {
+      throw new Error('"toSJISFunc" is not a valid function.');
+    }
+    toSJISFunction = f;
+  };
+  utils$1.isKanjiModeEnabled = function() {
+    return typeof toSJISFunction !== "undefined";
+  };
+  utils$1.toSJIS = function toSJIS(kanji) {
+    return toSJISFunction(kanji);
+  };
+  return utils$1;
+}
+var errorCorrectionLevel = {};
+var hasRequiredErrorCorrectionLevel;
+function requireErrorCorrectionLevel() {
+  if (hasRequiredErrorCorrectionLevel) return errorCorrectionLevel;
+  hasRequiredErrorCorrectionLevel = 1;
+  (function(exports$1) {
+    exports$1.L = { bit: 1 };
+    exports$1.M = { bit: 0 };
+    exports$1.Q = { bit: 3 };
+    exports$1.H = { bit: 2 };
+    function fromString(string) {
+      if (typeof string !== "string") {
+        throw new Error("Param is not a string");
+      }
+      const lcStr = string.toLowerCase();
+      switch (lcStr) {
+        case "l":
+        case "low":
+          return exports$1.L;
+        case "m":
+        case "medium":
+          return exports$1.M;
+        case "q":
+        case "quartile":
+          return exports$1.Q;
+        case "h":
+        case "high":
+          return exports$1.H;
+        default:
+          throw new Error("Unknown EC Level: " + string);
+      }
+    }
+    exports$1.isValid = function isValid(level) {
+      return level && typeof level.bit !== "undefined" && level.bit >= 0 && level.bit < 4;
+    };
+    exports$1.from = function from(value, defaultValue) {
+      if (exports$1.isValid(value)) {
+        return value;
+      }
+      try {
+        return fromString(value);
+      } catch (e) {
+        return defaultValue;
+      }
+    };
+  })(errorCorrectionLevel);
+  return errorCorrectionLevel;
+}
+var bitBuffer;
+var hasRequiredBitBuffer;
+function requireBitBuffer() {
+  if (hasRequiredBitBuffer) return bitBuffer;
+  hasRequiredBitBuffer = 1;
+  function BitBuffer() {
+    this.buffer = [];
+    this.length = 0;
+  }
+  BitBuffer.prototype = {
+    get: function(index) {
+      const bufIndex = Math.floor(index / 8);
+      return (this.buffer[bufIndex] >>> 7 - index % 8 & 1) === 1;
+    },
+    put: function(num, length) {
+      for (let i = 0; i < length; i++) {
+        this.putBit((num >>> length - i - 1 & 1) === 1);
+      }
+    },
+    getLengthInBits: function() {
+      return this.length;
+    },
+    putBit: function(bit) {
+      const bufIndex = Math.floor(this.length / 8);
+      if (this.buffer.length <= bufIndex) {
+        this.buffer.push(0);
+      }
+      if (bit) {
+        this.buffer[bufIndex] |= 128 >>> this.length % 8;
+      }
+      this.length++;
+    }
+  };
+  bitBuffer = BitBuffer;
+  return bitBuffer;
+}
+var bitMatrix;
+var hasRequiredBitMatrix;
+function requireBitMatrix() {
+  if (hasRequiredBitMatrix) return bitMatrix;
+  hasRequiredBitMatrix = 1;
+  function BitMatrix(size) {
+    if (!size || size < 1) {
+      throw new Error("BitMatrix size must be defined and greater than 0");
+    }
+    this.size = size;
+    this.data = new Uint8Array(size * size);
+    this.reservedBit = new Uint8Array(size * size);
+  }
+  BitMatrix.prototype.set = function(row, col, value, reserved) {
+    const index = row * this.size + col;
+    this.data[index] = value;
+    if (reserved) this.reservedBit[index] = true;
+  };
+  BitMatrix.prototype.get = function(row, col) {
+    return this.data[row * this.size + col];
+  };
+  BitMatrix.prototype.xor = function(row, col, value) {
+    this.data[row * this.size + col] ^= value;
+  };
+  BitMatrix.prototype.isReserved = function(row, col) {
+    return this.reservedBit[row * this.size + col];
+  };
+  bitMatrix = BitMatrix;
+  return bitMatrix;
+}
+var alignmentPattern = {};
+var hasRequiredAlignmentPattern;
+function requireAlignmentPattern() {
+  if (hasRequiredAlignmentPattern) return alignmentPattern;
+  hasRequiredAlignmentPattern = 1;
+  (function(exports$1) {
+    const getSymbolSize = requireUtils$1().getSymbolSize;
+    exports$1.getRowColCoords = function getRowColCoords(version2) {
+      if (version2 === 1) return [];
+      const posCount = Math.floor(version2 / 7) + 2;
+      const size = getSymbolSize(version2);
+      const intervals = size === 145 ? 26 : Math.ceil((size - 13) / (2 * posCount - 2)) * 2;
+      const positions = [size - 7];
+      for (let i = 1; i < posCount - 1; i++) {
+        positions[i] = positions[i - 1] - intervals;
+      }
+      positions.push(6);
+      return positions.reverse();
+    };
+    exports$1.getPositions = function getPositions(version2) {
+      const coords = [];
+      const pos = exports$1.getRowColCoords(version2);
+      const posLength = pos.length;
+      for (let i = 0; i < posLength; i++) {
+        for (let j = 0; j < posLength; j++) {
+          if (i === 0 && j === 0 || // top-left
+          i === 0 && j === posLength - 1 || // bottom-left
+          i === posLength - 1 && j === 0) {
+            continue;
+          }
+          coords.push([pos[i], pos[j]]);
+        }
+      }
+      return coords;
+    };
+  })(alignmentPattern);
+  return alignmentPattern;
+}
+var finderPattern = {};
+var hasRequiredFinderPattern;
+function requireFinderPattern() {
+  if (hasRequiredFinderPattern) return finderPattern;
+  hasRequiredFinderPattern = 1;
+  const getSymbolSize = requireUtils$1().getSymbolSize;
+  const FINDER_PATTERN_SIZE = 7;
+  finderPattern.getPositions = function getPositions(version2) {
+    const size = getSymbolSize(version2);
+    return [
+      // top-left
+      [0, 0],
+      // top-right
+      [size - FINDER_PATTERN_SIZE, 0],
+      // bottom-left
+      [0, size - FINDER_PATTERN_SIZE]
+    ];
+  };
+  return finderPattern;
+}
+var maskPattern = {};
+var hasRequiredMaskPattern;
+function requireMaskPattern() {
+  if (hasRequiredMaskPattern) return maskPattern;
+  hasRequiredMaskPattern = 1;
+  (function(exports$1) {
+    exports$1.Patterns = {
+      PATTERN000: 0,
+      PATTERN001: 1,
+      PATTERN010: 2,
+      PATTERN011: 3,
+      PATTERN100: 4,
+      PATTERN101: 5,
+      PATTERN110: 6,
+      PATTERN111: 7
+    };
+    const PenaltyScores = {
+      N1: 3,
+      N2: 3,
+      N3: 40,
+      N4: 10
+    };
+    exports$1.isValid = function isValid(mask) {
+      return mask != null && mask !== "" && !isNaN(mask) && mask >= 0 && mask <= 7;
+    };
+    exports$1.from = function from(value) {
+      return exports$1.isValid(value) ? parseInt(value, 10) : void 0;
+    };
+    exports$1.getPenaltyN1 = function getPenaltyN1(data) {
+      const size = data.size;
+      let points = 0;
+      let sameCountCol = 0;
+      let sameCountRow = 0;
+      let lastCol = null;
+      let lastRow = null;
+      for (let row = 0; row < size; row++) {
+        sameCountCol = sameCountRow = 0;
+        lastCol = lastRow = null;
+        for (let col = 0; col < size; col++) {
+          let module = data.get(row, col);
+          if (module === lastCol) {
+            sameCountCol++;
+          } else {
+            if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5);
+            lastCol = module;
+            sameCountCol = 1;
+          }
+          module = data.get(col, row);
+          if (module === lastRow) {
+            sameCountRow++;
+          } else {
+            if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5);
+            lastRow = module;
+            sameCountRow = 1;
+          }
+        }
+        if (sameCountCol >= 5) points += PenaltyScores.N1 + (sameCountCol - 5);
+        if (sameCountRow >= 5) points += PenaltyScores.N1 + (sameCountRow - 5);
+      }
+      return points;
+    };
+    exports$1.getPenaltyN2 = function getPenaltyN2(data) {
+      const size = data.size;
+      let points = 0;
+      for (let row = 0; row < size - 1; row++) {
+        for (let col = 0; col < size - 1; col++) {
+          const last = data.get(row, col) + data.get(row, col + 1) + data.get(row + 1, col) + data.get(row + 1, col + 1);
+          if (last === 4 || last === 0) points++;
+        }
+      }
+      return points * PenaltyScores.N2;
+    };
+    exports$1.getPenaltyN3 = function getPenaltyN3(data) {
+      const size = data.size;
+      let points = 0;
+      let bitsCol = 0;
+      let bitsRow = 0;
+      for (let row = 0; row < size; row++) {
+        bitsCol = bitsRow = 0;
+        for (let col = 0; col < size; col++) {
+          bitsCol = bitsCol << 1 & 2047 | data.get(row, col);
+          if (col >= 10 && (bitsCol === 1488 || bitsCol === 93)) points++;
+          bitsRow = bitsRow << 1 & 2047 | data.get(col, row);
+          if (col >= 10 && (bitsRow === 1488 || bitsRow === 93)) points++;
+        }
+      }
+      return points * PenaltyScores.N3;
+    };
+    exports$1.getPenaltyN4 = function getPenaltyN4(data) {
+      let darkCount = 0;
+      const modulesCount = data.data.length;
+      for (let i = 0; i < modulesCount; i++) darkCount += data.data[i];
+      const k = Math.abs(Math.ceil(darkCount * 100 / modulesCount / 5) - 10);
+      return k * PenaltyScores.N4;
+    };
+    function getMaskAt(maskPattern2, i, j) {
+      switch (maskPattern2) {
+        case exports$1.Patterns.PATTERN000:
+          return (i + j) % 2 === 0;
+        case exports$1.Patterns.PATTERN001:
+          return i % 2 === 0;
+        case exports$1.Patterns.PATTERN010:
+          return j % 3 === 0;
+        case exports$1.Patterns.PATTERN011:
+          return (i + j) % 3 === 0;
+        case exports$1.Patterns.PATTERN100:
+          return (Math.floor(i / 2) + Math.floor(j / 3)) % 2 === 0;
+        case exports$1.Patterns.PATTERN101:
+          return i * j % 2 + i * j % 3 === 0;
+        case exports$1.Patterns.PATTERN110:
+          return (i * j % 2 + i * j % 3) % 2 === 0;
+        case exports$1.Patterns.PATTERN111:
+          return (i * j % 3 + (i + j) % 2) % 2 === 0;
+        default:
+          throw new Error("bad maskPattern:" + maskPattern2);
+      }
+    }
+    exports$1.applyMask = function applyMask(pattern, data) {
+      const size = data.size;
+      for (let col = 0; col < size; col++) {
+        for (let row = 0; row < size; row++) {
+          if (data.isReserved(row, col)) continue;
+          data.xor(row, col, getMaskAt(pattern, row, col));
+        }
+      }
+    };
+    exports$1.getBestMask = function getBestMask(data, setupFormatFunc) {
+      const numPatterns = Object.keys(exports$1.Patterns).length;
+      let bestPattern = 0;
+      let lowerPenalty = Infinity;
+      for (let p = 0; p < numPatterns; p++) {
+        setupFormatFunc(p);
+        exports$1.applyMask(p, data);
+        const penalty = exports$1.getPenaltyN1(data) + exports$1.getPenaltyN2(data) + exports$1.getPenaltyN3(data) + exports$1.getPenaltyN4(data);
+        exports$1.applyMask(p, data);
+        if (penalty < lowerPenalty) {
+          lowerPenalty = penalty;
+          bestPattern = p;
+        }
+      }
+      return bestPattern;
+    };
+  })(maskPattern);
+  return maskPattern;
+}
+var errorCorrectionCode = {};
+var hasRequiredErrorCorrectionCode;
+function requireErrorCorrectionCode() {
+  if (hasRequiredErrorCorrectionCode) return errorCorrectionCode;
+  hasRequiredErrorCorrectionCode = 1;
+  const ECLevel = requireErrorCorrectionLevel();
+  const EC_BLOCKS_TABLE = [
+    // L  M  Q  H
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    2,
+    2,
+    1,
+    2,
+    2,
+    4,
+    1,
+    2,
+    4,
+    4,
+    2,
+    4,
+    4,
+    4,
+    2,
+    4,
+    6,
+    5,
+    2,
+    4,
+    6,
+    6,
+    2,
+    5,
+    8,
+    8,
+    4,
+    5,
+    8,
+    8,
+    4,
+    5,
+    8,
+    11,
+    4,
+    8,
+    10,
+    11,
+    4,
+    9,
+    12,
+    16,
+    4,
+    9,
+    16,
+    16,
+    6,
+    10,
+    12,
+    18,
+    6,
+    10,
+    17,
+    16,
+    6,
+    11,
+    16,
+    19,
+    6,
+    13,
+    18,
+    21,
+    7,
+    14,
+    21,
+    25,
+    8,
+    16,
+    20,
+    25,
+    8,
+    17,
+    23,
+    25,
+    9,
+    17,
+    23,
+    34,
+    9,
+    18,
+    25,
+    30,
+    10,
+    20,
+    27,
+    32,
+    12,
+    21,
+    29,
+    35,
+    12,
+    23,
+    34,
+    37,
+    12,
+    25,
+    34,
+    40,
+    13,
+    26,
+    35,
+    42,
+    14,
+    28,
+    38,
+    45,
+    15,
+    29,
+    40,
+    48,
+    16,
+    31,
+    43,
+    51,
+    17,
+    33,
+    45,
+    54,
+    18,
+    35,
+    48,
+    57,
+    19,
+    37,
+    51,
+    60,
+    19,
+    38,
+    53,
+    63,
+    20,
+    40,
+    56,
+    66,
+    21,
+    43,
+    59,
+    70,
+    22,
+    45,
+    62,
+    74,
+    24,
+    47,
+    65,
+    77,
+    25,
+    49,
+    68,
+    81
+  ];
+  const EC_CODEWORDS_TABLE = [
+    // L  M  Q  H
+    7,
+    10,
+    13,
+    17,
+    10,
+    16,
+    22,
+    28,
+    15,
+    26,
+    36,
+    44,
+    20,
+    36,
+    52,
+    64,
+    26,
+    48,
+    72,
+    88,
+    36,
+    64,
+    96,
+    112,
+    40,
+    72,
+    108,
+    130,
+    48,
+    88,
+    132,
+    156,
+    60,
+    110,
+    160,
+    192,
+    72,
+    130,
+    192,
+    224,
+    80,
+    150,
+    224,
+    264,
+    96,
+    176,
+    260,
+    308,
+    104,
+    198,
+    288,
+    352,
+    120,
+    216,
+    320,
+    384,
+    132,
+    240,
+    360,
+    432,
+    144,
+    280,
+    408,
+    480,
+    168,
+    308,
+    448,
+    532,
+    180,
+    338,
+    504,
+    588,
+    196,
+    364,
+    546,
+    650,
+    224,
+    416,
+    600,
+    700,
+    224,
+    442,
+    644,
+    750,
+    252,
+    476,
+    690,
+    816,
+    270,
+    504,
+    750,
+    900,
+    300,
+    560,
+    810,
+    960,
+    312,
+    588,
+    870,
+    1050,
+    336,
+    644,
+    952,
+    1110,
+    360,
+    700,
+    1020,
+    1200,
+    390,
+    728,
+    1050,
+    1260,
+    420,
+    784,
+    1140,
+    1350,
+    450,
+    812,
+    1200,
+    1440,
+    480,
+    868,
+    1290,
+    1530,
+    510,
+    924,
+    1350,
+    1620,
+    540,
+    980,
+    1440,
+    1710,
+    570,
+    1036,
+    1530,
+    1800,
+    570,
+    1064,
+    1590,
+    1890,
+    600,
+    1120,
+    1680,
+    1980,
+    630,
+    1204,
+    1770,
+    2100,
+    660,
+    1260,
+    1860,
+    2220,
+    720,
+    1316,
+    1950,
+    2310,
+    750,
+    1372,
+    2040,
+    2430
+  ];
+  errorCorrectionCode.getBlocksCount = function getBlocksCount(version2, errorCorrectionLevel2) {
+    switch (errorCorrectionLevel2) {
+      case ECLevel.L:
+        return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 0];
+      case ECLevel.M:
+        return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 1];
+      case ECLevel.Q:
+        return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 2];
+      case ECLevel.H:
+        return EC_BLOCKS_TABLE[(version2 - 1) * 4 + 3];
+      default:
+        return void 0;
+    }
+  };
+  errorCorrectionCode.getTotalCodewordsCount = function getTotalCodewordsCount(version2, errorCorrectionLevel2) {
+    switch (errorCorrectionLevel2) {
+      case ECLevel.L:
+        return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 0];
+      case ECLevel.M:
+        return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 1];
+      case ECLevel.Q:
+        return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 2];
+      case ECLevel.H:
+        return EC_CODEWORDS_TABLE[(version2 - 1) * 4 + 3];
+      default:
+        return void 0;
+    }
+  };
+  return errorCorrectionCode;
+}
+var polynomial = {};
+var galoisField = {};
+var hasRequiredGaloisField;
+function requireGaloisField() {
+  if (hasRequiredGaloisField) return galoisField;
+  hasRequiredGaloisField = 1;
+  const EXP_TABLE = new Uint8Array(512);
+  const LOG_TABLE = new Uint8Array(256);
+  (function initTables() {
+    let x = 1;
+    for (let i = 0; i < 255; i++) {
+      EXP_TABLE[i] = x;
+      LOG_TABLE[x] = i;
+      x <<= 1;
+      if (x & 256) {
+        x ^= 285;
+      }
+    }
+    for (let i = 255; i < 512; i++) {
+      EXP_TABLE[i] = EXP_TABLE[i - 255];
+    }
+  })();
+  galoisField.log = function log(n) {
+    if (n < 1) throw new Error("log(" + n + ")");
+    return LOG_TABLE[n];
+  };
+  galoisField.exp = function exp(n) {
+    return EXP_TABLE[n];
+  };
+  galoisField.mul = function mul(x, y) {
+    if (x === 0 || y === 0) return 0;
+    return EXP_TABLE[LOG_TABLE[x] + LOG_TABLE[y]];
+  };
+  return galoisField;
+}
+var hasRequiredPolynomial;
+function requirePolynomial() {
+  if (hasRequiredPolynomial) return polynomial;
+  hasRequiredPolynomial = 1;
+  (function(exports$1) {
+    const GF = requireGaloisField();
+    exports$1.mul = function mul(p1, p2) {
+      const coeff = new Uint8Array(p1.length + p2.length - 1);
+      for (let i = 0; i < p1.length; i++) {
+        for (let j = 0; j < p2.length; j++) {
+          coeff[i + j] ^= GF.mul(p1[i], p2[j]);
+        }
+      }
+      return coeff;
+    };
+    exports$1.mod = function mod(divident, divisor) {
+      let result = new Uint8Array(divident);
+      while (result.length - divisor.length >= 0) {
+        const coeff = result[0];
+        for (let i = 0; i < divisor.length; i++) {
+          result[i] ^= GF.mul(divisor[i], coeff);
+        }
+        let offset = 0;
+        while (offset < result.length && result[offset] === 0) offset++;
+        result = result.slice(offset);
+      }
+      return result;
+    };
+    exports$1.generateECPolynomial = function generateECPolynomial(degree) {
+      let poly = new Uint8Array([1]);
+      for (let i = 0; i < degree; i++) {
+        poly = exports$1.mul(poly, new Uint8Array([1, GF.exp(i)]));
+      }
+      return poly;
+    };
+  })(polynomial);
+  return polynomial;
+}
+var reedSolomonEncoder;
+var hasRequiredReedSolomonEncoder;
+function requireReedSolomonEncoder() {
+  if (hasRequiredReedSolomonEncoder) return reedSolomonEncoder;
+  hasRequiredReedSolomonEncoder = 1;
+  const Polynomial = requirePolynomial();
+  function ReedSolomonEncoder(degree) {
+    this.genPoly = void 0;
+    this.degree = degree;
+    if (this.degree) this.initialize(this.degree);
+  }
+  ReedSolomonEncoder.prototype.initialize = function initialize(degree) {
+    this.degree = degree;
+    this.genPoly = Polynomial.generateECPolynomial(this.degree);
+  };
+  ReedSolomonEncoder.prototype.encode = function encode(data) {
+    if (!this.genPoly) {
+      throw new Error("Encoder not initialized");
+    }
+    const paddedData = new Uint8Array(data.length + this.degree);
+    paddedData.set(data);
+    const remainder = Polynomial.mod(paddedData, this.genPoly);
+    const start = this.degree - remainder.length;
+    if (start > 0) {
+      const buff = new Uint8Array(this.degree);
+      buff.set(remainder, start);
+      return buff;
+    }
+    return remainder;
+  };
+  reedSolomonEncoder = ReedSolomonEncoder;
+  return reedSolomonEncoder;
+}
+var version$1 = {};
+var mode = {};
+var versionCheck = {};
+var hasRequiredVersionCheck;
+function requireVersionCheck() {
+  if (hasRequiredVersionCheck) return versionCheck;
+  hasRequiredVersionCheck = 1;
+  versionCheck.isValid = function isValid(version2) {
+    return !isNaN(version2) && version2 >= 1 && version2 <= 40;
+  };
+  return versionCheck;
+}
+var regex = {};
+var hasRequiredRegex;
+function requireRegex() {
+  if (hasRequiredRegex) return regex;
+  hasRequiredRegex = 1;
+  const numeric = "[0-9]+";
+  const alphanumeric = "[A-Z $%*+\\-./:]+";
+  let kanji = "(?:[u3000-u303F]|[u3040-u309F]|[u30A0-u30FF]|[uFF00-uFFEF]|[u4E00-u9FAF]|[u2605-u2606]|[u2190-u2195]|u203B|[u2010u2015u2018u2019u2025u2026u201Cu201Du2225u2260]|[u0391-u0451]|[u00A7u00A8u00B1u00B4u00D7u00F7])+";
+  kanji = kanji.replace(/u/g, "\\u");
+  const byte = "(?:(?![A-Z0-9 $%*+\\-./:]|" + kanji + ")(?:.|[\r\n]))+";
+  regex.KANJI = new RegExp(kanji, "g");
+  regex.BYTE_KANJI = new RegExp("[^A-Z0-9 $%*+\\-./:]+", "g");
+  regex.BYTE = new RegExp(byte, "g");
+  regex.NUMERIC = new RegExp(numeric, "g");
+  regex.ALPHANUMERIC = new RegExp(alphanumeric, "g");
+  const TEST_KANJI = new RegExp("^" + kanji + "$");
+  const TEST_NUMERIC = new RegExp("^" + numeric + "$");
+  const TEST_ALPHANUMERIC = new RegExp("^[A-Z0-9 $%*+\\-./:]+$");
+  regex.testKanji = function testKanji(str) {
+    return TEST_KANJI.test(str);
+  };
+  regex.testNumeric = function testNumeric(str) {
+    return TEST_NUMERIC.test(str);
+  };
+  regex.testAlphanumeric = function testAlphanumeric(str) {
+    return TEST_ALPHANUMERIC.test(str);
+  };
+  return regex;
+}
+var hasRequiredMode;
+function requireMode() {
+  if (hasRequiredMode) return mode;
+  hasRequiredMode = 1;
+  (function(exports$1) {
+    const VersionCheck = requireVersionCheck();
+    const Regex = requireRegex();
+    exports$1.NUMERIC = {
+      id: "Numeric",
+      bit: 1 << 0,
+      ccBits: [10, 12, 14]
+    };
+    exports$1.ALPHANUMERIC = {
+      id: "Alphanumeric",
+      bit: 1 << 1,
+      ccBits: [9, 11, 13]
+    };
+    exports$1.BYTE = {
+      id: "Byte",
+      bit: 1 << 2,
+      ccBits: [8, 16, 16]
+    };
+    exports$1.KANJI = {
+      id: "Kanji",
+      bit: 1 << 3,
+      ccBits: [8, 10, 12]
+    };
+    exports$1.MIXED = {
+      bit: -1
+    };
+    exports$1.getCharCountIndicator = function getCharCountIndicator(mode2, version2) {
+      if (!mode2.ccBits) throw new Error("Invalid mode: " + mode2);
+      if (!VersionCheck.isValid(version2)) {
+        throw new Error("Invalid version: " + version2);
+      }
+      if (version2 >= 1 && version2 < 10) return mode2.ccBits[0];
+      else if (version2 < 27) return mode2.ccBits[1];
+      return mode2.ccBits[2];
+    };
+    exports$1.getBestModeForData = function getBestModeForData(dataStr) {
+      if (Regex.testNumeric(dataStr)) return exports$1.NUMERIC;
+      else if (Regex.testAlphanumeric(dataStr)) return exports$1.ALPHANUMERIC;
+      else if (Regex.testKanji(dataStr)) return exports$1.KANJI;
+      else return exports$1.BYTE;
+    };
+    exports$1.toString = function toString(mode2) {
+      if (mode2 && mode2.id) return mode2.id;
+      throw new Error("Invalid mode");
+    };
+    exports$1.isValid = function isValid(mode2) {
+      return mode2 && mode2.bit && mode2.ccBits;
+    };
+    function fromString(string) {
+      if (typeof string !== "string") {
+        throw new Error("Param is not a string");
+      }
+      const lcStr = string.toLowerCase();
+      switch (lcStr) {
+        case "numeric":
+          return exports$1.NUMERIC;
+        case "alphanumeric":
+          return exports$1.ALPHANUMERIC;
+        case "kanji":
+          return exports$1.KANJI;
+        case "byte":
+          return exports$1.BYTE;
+        default:
+          throw new Error("Unknown mode: " + string);
+      }
+    }
+    exports$1.from = function from(value, defaultValue) {
+      if (exports$1.isValid(value)) {
+        return value;
+      }
+      try {
+        return fromString(value);
+      } catch (e) {
+        return defaultValue;
+      }
+    };
+  })(mode);
+  return mode;
+}
+var hasRequiredVersion;
+function requireVersion() {
+  if (hasRequiredVersion) return version$1;
+  hasRequiredVersion = 1;
+  (function(exports$1) {
+    const Utils = requireUtils$1();
+    const ECCode = requireErrorCorrectionCode();
+    const ECLevel = requireErrorCorrectionLevel();
+    const Mode = requireMode();
+    const VersionCheck = requireVersionCheck();
+    const G18 = 1 << 12 | 1 << 11 | 1 << 10 | 1 << 9 | 1 << 8 | 1 << 5 | 1 << 2 | 1 << 0;
+    const G18_BCH = Utils.getBCHDigit(G18);
+    function getBestVersionForDataLength(mode2, length, errorCorrectionLevel2) {
+      for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
+        if (length <= exports$1.getCapacity(currentVersion, errorCorrectionLevel2, mode2)) {
+          return currentVersion;
+        }
+      }
+      return void 0;
+    }
+    function getReservedBitsCount(mode2, version2) {
+      return Mode.getCharCountIndicator(mode2, version2) + 4;
+    }
+    function getTotalBitsFromDataArray(segments2, version2) {
+      let totalBits = 0;
+      segments2.forEach(function(data) {
+        const reservedBits = getReservedBitsCount(data.mode, version2);
+        totalBits += reservedBits + data.getBitsLength();
+      });
+      return totalBits;
+    }
+    function getBestVersionForMixedData(segments2, errorCorrectionLevel2) {
+      for (let currentVersion = 1; currentVersion <= 40; currentVersion++) {
+        const length = getTotalBitsFromDataArray(segments2, currentVersion);
+        if (length <= exports$1.getCapacity(currentVersion, errorCorrectionLevel2, Mode.MIXED)) {
+          return currentVersion;
+        }
+      }
+      return void 0;
+    }
+    exports$1.from = function from(value, defaultValue) {
+      if (VersionCheck.isValid(value)) {
+        return parseInt(value, 10);
+      }
+      return defaultValue;
+    };
+    exports$1.getCapacity = function getCapacity(version2, errorCorrectionLevel2, mode2) {
+      if (!VersionCheck.isValid(version2)) {
+        throw new Error("Invalid QR Code version");
+      }
+      if (typeof mode2 === "undefined") mode2 = Mode.BYTE;
+      const totalCodewords = Utils.getSymbolTotalCodewords(version2);
+      const ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
+      const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
+      if (mode2 === Mode.MIXED) return dataTotalCodewordsBits;
+      const usableBits = dataTotalCodewordsBits - getReservedBitsCount(mode2, version2);
+      switch (mode2) {
+        case Mode.NUMERIC:
+          return Math.floor(usableBits / 10 * 3);
+        case Mode.ALPHANUMERIC:
+          return Math.floor(usableBits / 11 * 2);
+        case Mode.KANJI:
+          return Math.floor(usableBits / 13);
+        case Mode.BYTE:
+        default:
+          return Math.floor(usableBits / 8);
+      }
+    };
+    exports$1.getBestVersionForData = function getBestVersionForData(data, errorCorrectionLevel2) {
+      let seg;
+      const ecl = ECLevel.from(errorCorrectionLevel2, ECLevel.M);
+      if (Array.isArray(data)) {
+        if (data.length > 1) {
+          return getBestVersionForMixedData(data, ecl);
+        }
+        if (data.length === 0) {
+          return 1;
+        }
+        seg = data[0];
+      } else {
+        seg = data;
+      }
+      return getBestVersionForDataLength(seg.mode, seg.getLength(), ecl);
+    };
+    exports$1.getEncodedBits = function getEncodedBits(version2) {
+      if (!VersionCheck.isValid(version2) || version2 < 7) {
+        throw new Error("Invalid QR Code version");
+      }
+      let d = version2 << 12;
+      while (Utils.getBCHDigit(d) - G18_BCH >= 0) {
+        d ^= G18 << Utils.getBCHDigit(d) - G18_BCH;
+      }
+      return version2 << 12 | d;
+    };
+  })(version$1);
+  return version$1;
+}
+var formatInfo = {};
+var hasRequiredFormatInfo;
+function requireFormatInfo() {
+  if (hasRequiredFormatInfo) return formatInfo;
+  hasRequiredFormatInfo = 1;
+  const Utils = requireUtils$1();
+  const G15 = 1 << 10 | 1 << 8 | 1 << 5 | 1 << 4 | 1 << 2 | 1 << 1 | 1 << 0;
+  const G15_MASK = 1 << 14 | 1 << 12 | 1 << 10 | 1 << 4 | 1 << 1;
+  const G15_BCH = Utils.getBCHDigit(G15);
+  formatInfo.getEncodedBits = function getEncodedBits(errorCorrectionLevel2, mask) {
+    const data = errorCorrectionLevel2.bit << 3 | mask;
+    let d = data << 10;
+    while (Utils.getBCHDigit(d) - G15_BCH >= 0) {
+      d ^= G15 << Utils.getBCHDigit(d) - G15_BCH;
+    }
+    return (data << 10 | d) ^ G15_MASK;
+  };
+  return formatInfo;
+}
+var segments = {};
+var numericData;
+var hasRequiredNumericData;
+function requireNumericData() {
+  if (hasRequiredNumericData) return numericData;
+  hasRequiredNumericData = 1;
+  const Mode = requireMode();
+  function NumericData(data) {
+    this.mode = Mode.NUMERIC;
+    this.data = data.toString();
+  }
+  NumericData.getBitsLength = function getBitsLength(length) {
+    return 10 * Math.floor(length / 3) + (length % 3 ? length % 3 * 3 + 1 : 0);
+  };
+  NumericData.prototype.getLength = function getLength() {
+    return this.data.length;
+  };
+  NumericData.prototype.getBitsLength = function getBitsLength() {
+    return NumericData.getBitsLength(this.data.length);
+  };
+  NumericData.prototype.write = function write(bitBuffer2) {
+    let i, group, value;
+    for (i = 0; i + 3 <= this.data.length; i += 3) {
+      group = this.data.substr(i, 3);
+      value = parseInt(group, 10);
+      bitBuffer2.put(value, 10);
+    }
+    const remainingNum = this.data.length - i;
+    if (remainingNum > 0) {
+      group = this.data.substr(i);
+      value = parseInt(group, 10);
+      bitBuffer2.put(value, remainingNum * 3 + 1);
+    }
+  };
+  numericData = NumericData;
+  return numericData;
+}
+var alphanumericData;
+var hasRequiredAlphanumericData;
+function requireAlphanumericData() {
+  if (hasRequiredAlphanumericData) return alphanumericData;
+  hasRequiredAlphanumericData = 1;
+  const Mode = requireMode();
+  const ALPHA_NUM_CHARS = [
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "I",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "O",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z",
+    " ",
+    "$",
+    "%",
+    "*",
+    "+",
+    "-",
+    ".",
+    "/",
+    ":"
+  ];
+  function AlphanumericData(data) {
+    this.mode = Mode.ALPHANUMERIC;
+    this.data = data;
+  }
+  AlphanumericData.getBitsLength = function getBitsLength(length) {
+    return 11 * Math.floor(length / 2) + 6 * (length % 2);
+  };
+  AlphanumericData.prototype.getLength = function getLength() {
+    return this.data.length;
+  };
+  AlphanumericData.prototype.getBitsLength = function getBitsLength() {
+    return AlphanumericData.getBitsLength(this.data.length);
+  };
+  AlphanumericData.prototype.write = function write(bitBuffer2) {
+    let i;
+    for (i = 0; i + 2 <= this.data.length; i += 2) {
+      let value = ALPHA_NUM_CHARS.indexOf(this.data[i]) * 45;
+      value += ALPHA_NUM_CHARS.indexOf(this.data[i + 1]);
+      bitBuffer2.put(value, 11);
+    }
+    if (this.data.length % 2) {
+      bitBuffer2.put(ALPHA_NUM_CHARS.indexOf(this.data[i]), 6);
+    }
+  };
+  alphanumericData = AlphanumericData;
+  return alphanumericData;
+}
+var byteData;
+var hasRequiredByteData;
+function requireByteData() {
+  if (hasRequiredByteData) return byteData;
+  hasRequiredByteData = 1;
+  const Mode = requireMode();
+  function ByteData(data) {
+    this.mode = Mode.BYTE;
+    if (typeof data === "string") {
+      this.data = new TextEncoder().encode(data);
+    } else {
+      this.data = new Uint8Array(data);
+    }
+  }
+  ByteData.getBitsLength = function getBitsLength(length) {
+    return length * 8;
+  };
+  ByteData.prototype.getLength = function getLength() {
+    return this.data.length;
+  };
+  ByteData.prototype.getBitsLength = function getBitsLength() {
+    return ByteData.getBitsLength(this.data.length);
+  };
+  ByteData.prototype.write = function(bitBuffer2) {
+    for (let i = 0, l = this.data.length; i < l; i++) {
+      bitBuffer2.put(this.data[i], 8);
+    }
+  };
+  byteData = ByteData;
+  return byteData;
+}
+var kanjiData;
+var hasRequiredKanjiData;
+function requireKanjiData() {
+  if (hasRequiredKanjiData) return kanjiData;
+  hasRequiredKanjiData = 1;
+  const Mode = requireMode();
+  const Utils = requireUtils$1();
+  function KanjiData(data) {
+    this.mode = Mode.KANJI;
+    this.data = data;
+  }
+  KanjiData.getBitsLength = function getBitsLength(length) {
+    return length * 13;
+  };
+  KanjiData.prototype.getLength = function getLength() {
+    return this.data.length;
+  };
+  KanjiData.prototype.getBitsLength = function getBitsLength() {
+    return KanjiData.getBitsLength(this.data.length);
+  };
+  KanjiData.prototype.write = function(bitBuffer2) {
+    let i;
+    for (i = 0; i < this.data.length; i++) {
+      let value = Utils.toSJIS(this.data[i]);
+      if (value >= 33088 && value <= 40956) {
+        value -= 33088;
+      } else if (value >= 57408 && value <= 60351) {
+        value -= 49472;
+      } else {
+        throw new Error(
+          "Invalid SJIS character: " + this.data[i] + "\nMake sure your charset is UTF-8"
+        );
+      }
+      value = (value >>> 8 & 255) * 192 + (value & 255);
+      bitBuffer2.put(value, 13);
+    }
+  };
+  kanjiData = KanjiData;
+  return kanjiData;
+}
+var dijkstra = { exports: {} };
+var hasRequiredDijkstra;
+function requireDijkstra() {
+  if (hasRequiredDijkstra) return dijkstra.exports;
+  hasRequiredDijkstra = 1;
+  (function(module) {
+    var dijkstra2 = {
+      single_source_shortest_paths: function(graph, s, d) {
+        var predecessors = {};
+        var costs = {};
+        costs[s] = 0;
+        var open = dijkstra2.PriorityQueue.make();
+        open.push(s, 0);
+        var closest, u, v, cost_of_s_to_u, adjacent_nodes, cost_of_e, cost_of_s_to_u_plus_cost_of_e, cost_of_s_to_v, first_visit;
+        while (!open.empty()) {
+          closest = open.pop();
+          u = closest.value;
+          cost_of_s_to_u = closest.cost;
+          adjacent_nodes = graph[u] || {};
+          for (v in adjacent_nodes) {
+            if (adjacent_nodes.hasOwnProperty(v)) {
+              cost_of_e = adjacent_nodes[v];
+              cost_of_s_to_u_plus_cost_of_e = cost_of_s_to_u + cost_of_e;
+              cost_of_s_to_v = costs[v];
+              first_visit = typeof costs[v] === "undefined";
+              if (first_visit || cost_of_s_to_v > cost_of_s_to_u_plus_cost_of_e) {
+                costs[v] = cost_of_s_to_u_plus_cost_of_e;
+                open.push(v, cost_of_s_to_u_plus_cost_of_e);
+                predecessors[v] = u;
+              }
+            }
+          }
+        }
+        if (typeof d !== "undefined" && typeof costs[d] === "undefined") {
+          var msg = ["Could not find a path from ", s, " to ", d, "."].join("");
+          throw new Error(msg);
+        }
+        return predecessors;
+      },
+      extract_shortest_path_from_predecessor_list: function(predecessors, d) {
+        var nodes = [];
+        var u = d;
+        while (u) {
+          nodes.push(u);
+          predecessors[u];
+          u = predecessors[u];
+        }
+        nodes.reverse();
+        return nodes;
+      },
+      find_path: function(graph, s, d) {
+        var predecessors = dijkstra2.single_source_shortest_paths(graph, s, d);
+        return dijkstra2.extract_shortest_path_from_predecessor_list(
+          predecessors,
+          d
+        );
+      },
+      /**
+       * A very naive priority queue implementation.
+       */
+      PriorityQueue: {
+        make: function(opts) {
+          var T = dijkstra2.PriorityQueue, t = {}, key;
+          opts = opts || {};
+          for (key in T) {
+            if (T.hasOwnProperty(key)) {
+              t[key] = T[key];
+            }
+          }
+          t.queue = [];
+          t.sorter = opts.sorter || T.default_sorter;
+          return t;
+        },
+        default_sorter: function(a, b) {
+          return a.cost - b.cost;
+        },
+        /**
+         * Add a new item to the queue and ensure the highest priority element
+         * is at the front of the queue.
+         */
+        push: function(value, cost) {
+          var item = { value, cost };
+          this.queue.push(item);
+          this.queue.sort(this.sorter);
+        },
+        /**
+         * Return the highest priority element in the queue.
+         */
+        pop: function() {
+          return this.queue.shift();
+        },
+        empty: function() {
+          return this.queue.length === 0;
+        }
+      }
+    };
+    {
+      module.exports = dijkstra2;
+    }
+  })(dijkstra);
+  return dijkstra.exports;
+}
+var hasRequiredSegments;
+function requireSegments() {
+  if (hasRequiredSegments) return segments;
+  hasRequiredSegments = 1;
+  (function(exports$1) {
+    const Mode = requireMode();
+    const NumericData = requireNumericData();
+    const AlphanumericData = requireAlphanumericData();
+    const ByteData = requireByteData();
+    const KanjiData = requireKanjiData();
+    const Regex = requireRegex();
+    const Utils = requireUtils$1();
+    const dijkstra2 = requireDijkstra();
+    function getStringByteLength(str) {
+      return unescape(encodeURIComponent(str)).length;
+    }
+    function getSegments(regex2, mode2, str) {
+      const segments2 = [];
+      let result;
+      while ((result = regex2.exec(str)) !== null) {
+        segments2.push({
+          data: result[0],
+          index: result.index,
+          mode: mode2,
+          length: result[0].length
+        });
+      }
+      return segments2;
+    }
+    function getSegmentsFromString(dataStr) {
+      const numSegs = getSegments(Regex.NUMERIC, Mode.NUMERIC, dataStr);
+      const alphaNumSegs = getSegments(Regex.ALPHANUMERIC, Mode.ALPHANUMERIC, dataStr);
+      let byteSegs;
+      let kanjiSegs;
+      if (Utils.isKanjiModeEnabled()) {
+        byteSegs = getSegments(Regex.BYTE, Mode.BYTE, dataStr);
+        kanjiSegs = getSegments(Regex.KANJI, Mode.KANJI, dataStr);
+      } else {
+        byteSegs = getSegments(Regex.BYTE_KANJI, Mode.BYTE, dataStr);
+        kanjiSegs = [];
+      }
+      const segs = numSegs.concat(alphaNumSegs, byteSegs, kanjiSegs);
+      return segs.sort(function(s1, s2) {
+        return s1.index - s2.index;
+      }).map(function(obj) {
+        return {
+          data: obj.data,
+          mode: obj.mode,
+          length: obj.length
+        };
+      });
+    }
+    function getSegmentBitsLength(length, mode2) {
+      switch (mode2) {
+        case Mode.NUMERIC:
+          return NumericData.getBitsLength(length);
+        case Mode.ALPHANUMERIC:
+          return AlphanumericData.getBitsLength(length);
+        case Mode.KANJI:
+          return KanjiData.getBitsLength(length);
+        case Mode.BYTE:
+          return ByteData.getBitsLength(length);
+      }
+    }
+    function mergeSegments(segs) {
+      return segs.reduce(function(acc, curr) {
+        const prevSeg = acc.length - 1 >= 0 ? acc[acc.length - 1] : null;
+        if (prevSeg && prevSeg.mode === curr.mode) {
+          acc[acc.length - 1].data += curr.data;
+          return acc;
+        }
+        acc.push(curr);
+        return acc;
+      }, []);
+    }
+    function buildNodes(segs) {
+      const nodes = [];
+      for (let i = 0; i < segs.length; i++) {
+        const seg = segs[i];
+        switch (seg.mode) {
+          case Mode.NUMERIC:
+            nodes.push([
+              seg,
+              { data: seg.data, mode: Mode.ALPHANUMERIC, length: seg.length },
+              { data: seg.data, mode: Mode.BYTE, length: seg.length }
+            ]);
+            break;
+          case Mode.ALPHANUMERIC:
+            nodes.push([
+              seg,
+              { data: seg.data, mode: Mode.BYTE, length: seg.length }
+            ]);
+            break;
+          case Mode.KANJI:
+            nodes.push([
+              seg,
+              { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
+            ]);
+            break;
+          case Mode.BYTE:
+            nodes.push([
+              { data: seg.data, mode: Mode.BYTE, length: getStringByteLength(seg.data) }
+            ]);
+        }
+      }
+      return nodes;
+    }
+    function buildGraph(nodes, version2) {
+      const table = {};
+      const graph = { start: {} };
+      let prevNodeIds = ["start"];
+      for (let i = 0; i < nodes.length; i++) {
+        const nodeGroup = nodes[i];
+        const currentNodeIds = [];
+        for (let j = 0; j < nodeGroup.length; j++) {
+          const node = nodeGroup[j];
+          const key = "" + i + j;
+          currentNodeIds.push(key);
+          table[key] = { node, lastCount: 0 };
+          graph[key] = {};
+          for (let n = 0; n < prevNodeIds.length; n++) {
+            const prevNodeId = prevNodeIds[n];
+            if (table[prevNodeId] && table[prevNodeId].node.mode === node.mode) {
+              graph[prevNodeId][key] = getSegmentBitsLength(table[prevNodeId].lastCount + node.length, node.mode) - getSegmentBitsLength(table[prevNodeId].lastCount, node.mode);
+              table[prevNodeId].lastCount += node.length;
+            } else {
+              if (table[prevNodeId]) table[prevNodeId].lastCount = node.length;
+              graph[prevNodeId][key] = getSegmentBitsLength(node.length, node.mode) + 4 + Mode.getCharCountIndicator(node.mode, version2);
+            }
+          }
+        }
+        prevNodeIds = currentNodeIds;
+      }
+      for (let n = 0; n < prevNodeIds.length; n++) {
+        graph[prevNodeIds[n]].end = 0;
+      }
+      return { map: graph, table };
+    }
+    function buildSingleSegment(data, modesHint) {
+      let mode2;
+      const bestMode = Mode.getBestModeForData(data);
+      mode2 = Mode.from(modesHint, bestMode);
+      if (mode2 !== Mode.BYTE && mode2.bit < bestMode.bit) {
+        throw new Error('"' + data + '" cannot be encoded with mode ' + Mode.toString(mode2) + ".\n Suggested mode is: " + Mode.toString(bestMode));
+      }
+      if (mode2 === Mode.KANJI && !Utils.isKanjiModeEnabled()) {
+        mode2 = Mode.BYTE;
+      }
+      switch (mode2) {
+        case Mode.NUMERIC:
+          return new NumericData(data);
+        case Mode.ALPHANUMERIC:
+          return new AlphanumericData(data);
+        case Mode.KANJI:
+          return new KanjiData(data);
+        case Mode.BYTE:
+          return new ByteData(data);
+      }
+    }
+    exports$1.fromArray = function fromArray(array) {
+      return array.reduce(function(acc, seg) {
+        if (typeof seg === "string") {
+          acc.push(buildSingleSegment(seg, null));
+        } else if (seg.data) {
+          acc.push(buildSingleSegment(seg.data, seg.mode));
+        }
+        return acc;
+      }, []);
+    };
+    exports$1.fromString = function fromString(data, version2) {
+      const segs = getSegmentsFromString(data, Utils.isKanjiModeEnabled());
+      const nodes = buildNodes(segs);
+      const graph = buildGraph(nodes, version2);
+      const path = dijkstra2.find_path(graph.map, "start", "end");
+      const optimizedSegs = [];
+      for (let i = 1; i < path.length - 1; i++) {
+        optimizedSegs.push(graph.table[path[i]].node);
+      }
+      return exports$1.fromArray(mergeSegments(optimizedSegs));
+    };
+    exports$1.rawSplit = function rawSplit(data) {
+      return exports$1.fromArray(
+        getSegmentsFromString(data, Utils.isKanjiModeEnabled())
+      );
+    };
+  })(segments);
+  return segments;
+}
+var hasRequiredQrcode;
+function requireQrcode() {
+  if (hasRequiredQrcode) return qrcode;
+  hasRequiredQrcode = 1;
+  const Utils = requireUtils$1();
+  const ECLevel = requireErrorCorrectionLevel();
+  const BitBuffer = requireBitBuffer();
+  const BitMatrix = requireBitMatrix();
+  const AlignmentPattern = requireAlignmentPattern();
+  const FinderPattern = requireFinderPattern();
+  const MaskPattern = requireMaskPattern();
+  const ECCode = requireErrorCorrectionCode();
+  const ReedSolomonEncoder = requireReedSolomonEncoder();
+  const Version = requireVersion();
+  const FormatInfo = requireFormatInfo();
+  const Mode = requireMode();
+  const Segments = requireSegments();
+  function setupFinderPattern(matrix, version2) {
+    const size = matrix.size;
+    const pos = FinderPattern.getPositions(version2);
+    for (let i = 0; i < pos.length; i++) {
+      const row = pos[i][0];
+      const col = pos[i][1];
+      for (let r = -1; r <= 7; r++) {
+        if (row + r <= -1 || size <= row + r) continue;
+        for (let c = -1; c <= 7; c++) {
+          if (col + c <= -1 || size <= col + c) continue;
+          if (r >= 0 && r <= 6 && (c === 0 || c === 6) || c >= 0 && c <= 6 && (r === 0 || r === 6) || r >= 2 && r <= 4 && c >= 2 && c <= 4) {
+            matrix.set(row + r, col + c, true, true);
+          } else {
+            matrix.set(row + r, col + c, false, true);
+          }
+        }
+      }
+    }
+  }
+  function setupTimingPattern(matrix) {
+    const size = matrix.size;
+    for (let r = 8; r < size - 8; r++) {
+      const value = r % 2 === 0;
+      matrix.set(r, 6, value, true);
+      matrix.set(6, r, value, true);
+    }
+  }
+  function setupAlignmentPattern(matrix, version2) {
+    const pos = AlignmentPattern.getPositions(version2);
+    for (let i = 0; i < pos.length; i++) {
+      const row = pos[i][0];
+      const col = pos[i][1];
+      for (let r = -2; r <= 2; r++) {
+        for (let c = -2; c <= 2; c++) {
+          if (r === -2 || r === 2 || c === -2 || c === 2 || r === 0 && c === 0) {
+            matrix.set(row + r, col + c, true, true);
+          } else {
+            matrix.set(row + r, col + c, false, true);
+          }
+        }
+      }
+    }
+  }
+  function setupVersionInfo(matrix, version2) {
+    const size = matrix.size;
+    const bits = Version.getEncodedBits(version2);
+    let row, col, mod;
+    for (let i = 0; i < 18; i++) {
+      row = Math.floor(i / 3);
+      col = i % 3 + size - 8 - 3;
+      mod = (bits >> i & 1) === 1;
+      matrix.set(row, col, mod, true);
+      matrix.set(col, row, mod, true);
+    }
+  }
+  function setupFormatInfo(matrix, errorCorrectionLevel2, maskPattern2) {
+    const size = matrix.size;
+    const bits = FormatInfo.getEncodedBits(errorCorrectionLevel2, maskPattern2);
+    let i, mod;
+    for (i = 0; i < 15; i++) {
+      mod = (bits >> i & 1) === 1;
+      if (i < 6) {
+        matrix.set(i, 8, mod, true);
+      } else if (i < 8) {
+        matrix.set(i + 1, 8, mod, true);
+      } else {
+        matrix.set(size - 15 + i, 8, mod, true);
+      }
+      if (i < 8) {
+        matrix.set(8, size - i - 1, mod, true);
+      } else if (i < 9) {
+        matrix.set(8, 15 - i - 1 + 1, mod, true);
+      } else {
+        matrix.set(8, 15 - i - 1, mod, true);
+      }
+    }
+    matrix.set(size - 8, 8, 1, true);
+  }
+  function setupData(matrix, data) {
+    const size = matrix.size;
+    let inc = -1;
+    let row = size - 1;
+    let bitIndex = 7;
+    let byteIndex = 0;
+    for (let col = size - 1; col > 0; col -= 2) {
+      if (col === 6) col--;
+      while (true) {
+        for (let c = 0; c < 2; c++) {
+          if (!matrix.isReserved(row, col - c)) {
+            let dark = false;
+            if (byteIndex < data.length) {
+              dark = (data[byteIndex] >>> bitIndex & 1) === 1;
+            }
+            matrix.set(row, col - c, dark);
+            bitIndex--;
+            if (bitIndex === -1) {
+              byteIndex++;
+              bitIndex = 7;
+            }
+          }
+        }
+        row += inc;
+        if (row < 0 || size <= row) {
+          row -= inc;
+          inc = -inc;
+          break;
+        }
+      }
+    }
+  }
+  function createData(version2, errorCorrectionLevel2, segments2) {
+    const buffer = new BitBuffer();
+    segments2.forEach(function(data) {
+      buffer.put(data.mode.bit, 4);
+      buffer.put(data.getLength(), Mode.getCharCountIndicator(data.mode, version2));
+      data.write(buffer);
+    });
+    const totalCodewords = Utils.getSymbolTotalCodewords(version2);
+    const ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
+    const dataTotalCodewordsBits = (totalCodewords - ecTotalCodewords) * 8;
+    if (buffer.getLengthInBits() + 4 <= dataTotalCodewordsBits) {
+      buffer.put(0, 4);
+    }
+    while (buffer.getLengthInBits() % 8 !== 0) {
+      buffer.putBit(0);
+    }
+    const remainingByte = (dataTotalCodewordsBits - buffer.getLengthInBits()) / 8;
+    for (let i = 0; i < remainingByte; i++) {
+      buffer.put(i % 2 ? 17 : 236, 8);
+    }
+    return createCodewords(buffer, version2, errorCorrectionLevel2);
+  }
+  function createCodewords(bitBuffer2, version2, errorCorrectionLevel2) {
+    const totalCodewords = Utils.getSymbolTotalCodewords(version2);
+    const ecTotalCodewords = ECCode.getTotalCodewordsCount(version2, errorCorrectionLevel2);
+    const dataTotalCodewords = totalCodewords - ecTotalCodewords;
+    const ecTotalBlocks = ECCode.getBlocksCount(version2, errorCorrectionLevel2);
+    const blocksInGroup2 = totalCodewords % ecTotalBlocks;
+    const blocksInGroup1 = ecTotalBlocks - blocksInGroup2;
+    const totalCodewordsInGroup1 = Math.floor(totalCodewords / ecTotalBlocks);
+    const dataCodewordsInGroup1 = Math.floor(dataTotalCodewords / ecTotalBlocks);
+    const dataCodewordsInGroup2 = dataCodewordsInGroup1 + 1;
+    const ecCount = totalCodewordsInGroup1 - dataCodewordsInGroup1;
+    const rs = new ReedSolomonEncoder(ecCount);
+    let offset = 0;
+    const dcData = new Array(ecTotalBlocks);
+    const ecData = new Array(ecTotalBlocks);
+    let maxDataSize = 0;
+    const buffer = new Uint8Array(bitBuffer2.buffer);
+    for (let b = 0; b < ecTotalBlocks; b++) {
+      const dataSize = b < blocksInGroup1 ? dataCodewordsInGroup1 : dataCodewordsInGroup2;
+      dcData[b] = buffer.slice(offset, offset + dataSize);
+      ecData[b] = rs.encode(dcData[b]);
+      offset += dataSize;
+      maxDataSize = Math.max(maxDataSize, dataSize);
+    }
+    const data = new Uint8Array(totalCodewords);
+    let index = 0;
+    let i, r;
+    for (i = 0; i < maxDataSize; i++) {
+      for (r = 0; r < ecTotalBlocks; r++) {
+        if (i < dcData[r].length) {
+          data[index++] = dcData[r][i];
+        }
+      }
+    }
+    for (i = 0; i < ecCount; i++) {
+      for (r = 0; r < ecTotalBlocks; r++) {
+        data[index++] = ecData[r][i];
+      }
+    }
+    return data;
+  }
+  function createSymbol(data, version2, errorCorrectionLevel2, maskPattern2) {
+    let segments2;
+    if (Array.isArray(data)) {
+      segments2 = Segments.fromArray(data);
+    } else if (typeof data === "string") {
+      let estimatedVersion = version2;
+      if (!estimatedVersion) {
+        const rawSegments = Segments.rawSplit(data);
+        estimatedVersion = Version.getBestVersionForData(rawSegments, errorCorrectionLevel2);
+      }
+      segments2 = Segments.fromString(data, estimatedVersion || 40);
+    } else {
+      throw new Error("Invalid data");
+    }
+    const bestVersion = Version.getBestVersionForData(segments2, errorCorrectionLevel2);
+    if (!bestVersion) {
+      throw new Error("The amount of data is too big to be stored in a QR Code");
+    }
+    if (!version2) {
+      version2 = bestVersion;
+    } else if (version2 < bestVersion) {
+      throw new Error(
+        "\nThe chosen QR Code version cannot contain this amount of data.\nMinimum version required to store current data is: " + bestVersion + ".\n"
+      );
+    }
+    const dataBits = createData(version2, errorCorrectionLevel2, segments2);
+    const moduleCount = Utils.getSymbolSize(version2);
+    const modules = new BitMatrix(moduleCount);
+    setupFinderPattern(modules, version2);
+    setupTimingPattern(modules);
+    setupAlignmentPattern(modules, version2);
+    setupFormatInfo(modules, errorCorrectionLevel2, 0);
+    if (version2 >= 7) {
+      setupVersionInfo(modules, version2);
+    }
+    setupData(modules, dataBits);
+    if (isNaN(maskPattern2)) {
+      maskPattern2 = MaskPattern.getBestMask(
+        modules,
+        setupFormatInfo.bind(null, modules, errorCorrectionLevel2)
+      );
+    }
+    MaskPattern.applyMask(maskPattern2, modules);
+    setupFormatInfo(modules, errorCorrectionLevel2, maskPattern2);
+    return {
+      modules,
+      version: version2,
+      errorCorrectionLevel: errorCorrectionLevel2,
+      maskPattern: maskPattern2,
+      segments: segments2
+    };
+  }
+  qrcode.create = function create(data, options) {
+    if (typeof data === "undefined" || data === "") {
+      throw new Error("No input text");
+    }
+    let errorCorrectionLevel2 = ECLevel.M;
+    let version2;
+    let mask;
+    if (typeof options !== "undefined") {
+      errorCorrectionLevel2 = ECLevel.from(options.errorCorrectionLevel, ECLevel.M);
+      version2 = Version.from(options.version);
+      mask = MaskPattern.from(options.maskPattern);
+      if (options.toSJISFunc) {
+        Utils.setToSJISFunction(options.toSJISFunc);
+      }
+    }
+    return createSymbol(data, version2, errorCorrectionLevel2, mask);
+  };
+  return qrcode;
+}
+var canvas = {};
+var utils = {};
+var hasRequiredUtils;
+function requireUtils() {
+  if (hasRequiredUtils) return utils;
+  hasRequiredUtils = 1;
+  (function(exports$1) {
+    function hex2rgba(hex) {
+      if (typeof hex === "number") {
+        hex = hex.toString();
+      }
+      if (typeof hex !== "string") {
+        throw new Error("Color should be defined as hex string");
+      }
+      let hexCode = hex.slice().replace("#", "").split("");
+      if (hexCode.length < 3 || hexCode.length === 5 || hexCode.length > 8) {
+        throw new Error("Invalid hex color: " + hex);
+      }
+      if (hexCode.length === 3 || hexCode.length === 4) {
+        hexCode = Array.prototype.concat.apply([], hexCode.map(function(c) {
+          return [c, c];
+        }));
+      }
+      if (hexCode.length === 6) hexCode.push("F", "F");
+      const hexValue = parseInt(hexCode.join(""), 16);
+      return {
+        r: hexValue >> 24 & 255,
+        g: hexValue >> 16 & 255,
+        b: hexValue >> 8 & 255,
+        a: hexValue & 255,
+        hex: "#" + hexCode.slice(0, 6).join("")
+      };
+    }
+    exports$1.getOptions = function getOptions(options) {
+      if (!options) options = {};
+      if (!options.color) options.color = {};
+      const margin = typeof options.margin === "undefined" || options.margin === null || options.margin < 0 ? 4 : options.margin;
+      const width = options.width && options.width >= 21 ? options.width : void 0;
+      const scale = options.scale || 4;
+      return {
+        width,
+        scale: width ? 4 : scale,
+        margin,
+        color: {
+          dark: hex2rgba(options.color.dark || "#000000ff"),
+          light: hex2rgba(options.color.light || "#ffffffff")
+        },
+        type: options.type,
+        rendererOpts: options.rendererOpts || {}
+      };
+    };
+    exports$1.getScale = function getScale(qrSize, opts) {
+      return opts.width && opts.width >= qrSize + opts.margin * 2 ? opts.width / (qrSize + opts.margin * 2) : opts.scale;
+    };
+    exports$1.getImageWidth = function getImageWidth(qrSize, opts) {
+      const scale = exports$1.getScale(qrSize, opts);
+      return Math.floor((qrSize + opts.margin * 2) * scale);
+    };
+    exports$1.qrToImageData = function qrToImageData(imgData, qr, opts) {
+      const size = qr.modules.size;
+      const data = qr.modules.data;
+      const scale = exports$1.getScale(size, opts);
+      const symbolSize = Math.floor((size + opts.margin * 2) * scale);
+      const scaledMargin = opts.margin * scale;
+      const palette = [opts.color.light, opts.color.dark];
+      for (let i = 0; i < symbolSize; i++) {
+        for (let j = 0; j < symbolSize; j++) {
+          let posDst = (i * symbolSize + j) * 4;
+          let pxColor = opts.color.light;
+          if (i >= scaledMargin && j >= scaledMargin && i < symbolSize - scaledMargin && j < symbolSize - scaledMargin) {
+            const iSrc = Math.floor((i - scaledMargin) / scale);
+            const jSrc = Math.floor((j - scaledMargin) / scale);
+            pxColor = palette[data[iSrc * size + jSrc] ? 1 : 0];
+          }
+          imgData[posDst++] = pxColor.r;
+          imgData[posDst++] = pxColor.g;
+          imgData[posDst++] = pxColor.b;
+          imgData[posDst] = pxColor.a;
+        }
+      }
+    };
+  })(utils);
+  return utils;
+}
+var hasRequiredCanvas;
+function requireCanvas() {
+  if (hasRequiredCanvas) return canvas;
+  hasRequiredCanvas = 1;
+  (function(exports$1) {
+    const Utils = requireUtils();
+    function clearCanvas(ctx, canvas2, size) {
+      ctx.clearRect(0, 0, canvas2.width, canvas2.height);
+      if (!canvas2.style) canvas2.style = {};
+      canvas2.height = size;
+      canvas2.width = size;
+      canvas2.style.height = size + "px";
+      canvas2.style.width = size + "px";
+    }
+    function getCanvasElement() {
+      try {
+        return document.createElement("canvas");
+      } catch (e) {
+        throw new Error("You need to specify a canvas element");
+      }
+    }
+    exports$1.render = function render(qrData, canvas2, options) {
+      let opts = options;
+      let canvasEl = canvas2;
+      if (typeof opts === "undefined" && (!canvas2 || !canvas2.getContext)) {
+        opts = canvas2;
+        canvas2 = void 0;
+      }
+      if (!canvas2) {
+        canvasEl = getCanvasElement();
+      }
+      opts = Utils.getOptions(opts);
+      const size = Utils.getImageWidth(qrData.modules.size, opts);
+      const ctx = canvasEl.getContext("2d");
+      const image = ctx.createImageData(size, size);
+      Utils.qrToImageData(image.data, qrData, opts);
+      clearCanvas(ctx, canvasEl, size);
+      ctx.putImageData(image, 0, 0);
+      return canvasEl;
+    };
+    exports$1.renderToDataURL = function renderToDataURL(qrData, canvas2, options) {
+      let opts = options;
+      if (typeof opts === "undefined" && (!canvas2 || !canvas2.getContext)) {
+        opts = canvas2;
+        canvas2 = void 0;
+      }
+      if (!opts) opts = {};
+      const canvasEl = exports$1.render(qrData, canvas2, opts);
+      const type = opts.type || "image/png";
+      const rendererOpts = opts.rendererOpts || {};
+      return canvasEl.toDataURL(type, rendererOpts.quality);
+    };
+  })(canvas);
+  return canvas;
+}
+var svgTag = {};
+var hasRequiredSvgTag;
+function requireSvgTag() {
+  if (hasRequiredSvgTag) return svgTag;
+  hasRequiredSvgTag = 1;
+  const Utils = requireUtils();
+  function getColorAttrib(color, attrib) {
+    const alpha = color.a / 255;
+    const str = attrib + '="' + color.hex + '"';
+    return alpha < 1 ? str + " " + attrib + '-opacity="' + alpha.toFixed(2).slice(1) + '"' : str;
+  }
+  function svgCmd(cmd, x, y) {
+    let str = cmd + x;
+    if (typeof y !== "undefined") str += " " + y;
+    return str;
+  }
+  function qrToPath(data, size, margin) {
+    let path = "";
+    let moveBy = 0;
+    let newRow = false;
+    let lineLength = 0;
+    for (let i = 0; i < data.length; i++) {
+      const col = Math.floor(i % size);
+      const row = Math.floor(i / size);
+      if (!col && !newRow) newRow = true;
+      if (data[i]) {
+        lineLength++;
+        if (!(i > 0 && col > 0 && data[i - 1])) {
+          path += newRow ? svgCmd("M", col + margin, 0.5 + row + margin) : svgCmd("m", moveBy, 0);
+          moveBy = 0;
+          newRow = false;
+        }
+        if (!(col + 1 < size && data[i + 1])) {
+          path += svgCmd("h", lineLength);
+          lineLength = 0;
+        }
+      } else {
+        moveBy++;
+      }
+    }
+    return path;
+  }
+  svgTag.render = function render(qrData, options, cb) {
+    const opts = Utils.getOptions(options);
+    const size = qrData.modules.size;
+    const data = qrData.modules.data;
+    const qrcodesize = size + opts.margin * 2;
+    const bg = !opts.color.light.a ? "" : "<path " + getColorAttrib(opts.color.light, "fill") + ' d="M0 0h' + qrcodesize + "v" + qrcodesize + 'H0z"/>';
+    const path = "<path " + getColorAttrib(opts.color.dark, "stroke") + ' d="' + qrToPath(data, size, opts.margin) + '"/>';
+    const viewBox = 'viewBox="0 0 ' + qrcodesize + " " + qrcodesize + '"';
+    const width = !opts.width ? "" : 'width="' + opts.width + '" height="' + opts.width + '" ';
+    const svgTag2 = '<svg xmlns="http://www.w3.org/2000/svg" ' + width + viewBox + ' shape-rendering="crispEdges">' + bg + path + "</svg>\n";
+    if (typeof cb === "function") {
+      cb(null, svgTag2);
+    }
+    return svgTag2;
+  };
+  return svgTag;
+}
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser;
+  hasRequiredBrowser = 1;
+  const canPromise2 = requireCanPromise();
+  const QRCode2 = requireQrcode();
+  const CanvasRenderer = requireCanvas();
+  const SvgRenderer = requireSvgTag();
+  function renderCanvas(renderFunc, canvas2, text, opts, cb) {
+    const args = [].slice.call(arguments, 1);
+    const argsNum = args.length;
+    const isLastArgCb = typeof args[argsNum - 1] === "function";
+    if (!isLastArgCb && !canPromise2()) {
+      throw new Error("Callback required as last argument");
+    }
+    if (isLastArgCb) {
+      if (argsNum < 2) {
+        throw new Error("Too few arguments provided");
+      }
+      if (argsNum === 2) {
+        cb = text;
+        text = canvas2;
+        canvas2 = opts = void 0;
+      } else if (argsNum === 3) {
+        if (canvas2.getContext && typeof cb === "undefined") {
+          cb = opts;
+          opts = void 0;
+        } else {
+          cb = opts;
+          opts = text;
+          text = canvas2;
+          canvas2 = void 0;
+        }
+      }
+    } else {
+      if (argsNum < 1) {
+        throw new Error("Too few arguments provided");
+      }
+      if (argsNum === 1) {
+        text = canvas2;
+        canvas2 = opts = void 0;
+      } else if (argsNum === 2 && !canvas2.getContext) {
+        opts = text;
+        text = canvas2;
+        canvas2 = void 0;
+      }
+      return new Promise(function(resolve, reject) {
+        try {
+          const data = QRCode2.create(text, opts);
+          resolve(renderFunc(data, canvas2, opts));
+        } catch (e) {
+          reject(e);
+        }
+      });
+    }
+    try {
+      const data = QRCode2.create(text, opts);
+      cb(null, renderFunc(data, canvas2, opts));
+    } catch (e) {
+      cb(e);
+    }
+  }
+  browser.create = QRCode2.create;
+  browser.toCanvas = renderCanvas.bind(null, CanvasRenderer.render);
+  browser.toDataURL = renderCanvas.bind(null, CanvasRenderer.renderToDataURL);
+  browser.toString = renderCanvas.bind(null, function(data, _, opts) {
+    return SvgRenderer.render(data, opts);
+  });
+  return browser;
+}
+var browserExports = requireBrowser();
+const QRCode = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
+const qrCodeModalHTML = '<div class="idvc-modal-background" id="idvc-modal-background">\n    <div class="el-loading-spinner" id="idvc-loading-spinner">\n        <svg viewBox="25 25 50 50" class="circular">\n            <circle cx="50" cy="50" r="20" fill="none" class="path"></circle>\n        </svg>\n    </div>\n</div>\n<div class="idvc-modal idvc-modal_qr-code" id="idvc-modal">\n    <div class="idvc-modal__header-wrap qr-code__header">\n        <div class="idvc-modal__close-btn" id="idvc-close-modal-btn"></div>\n        <div class="idvc-modal__header">\n            <h2 class="idvc-modal__header__content idvc-modal__header__content_qr-code">\n                Verify Documents by Phone\n            </h2>\n        </div>\n    </div>\n    <div class="idvc-modal__body idvc-modal__body_qr-code">\n        <div class="idvc-modal__body_process_ready" id="idvc-modal__body_process_ready">\n            <h3 class="idvc-modal__body_process_ready-header">Scan the QR Сode below to continue on your mobile device</h3>\n            <div class="idvc-modal__body_process_ready__canvas-container">\n                <canvas class="idvc-modal__body_process_ready-canvas" id="idvc-modal__body_process_ready-canvas"></canvas>\n            </div>\n            <div class="idvc-modal__body_process_ready-info qr-code__header">\n                <svg width="14" height="14" viewBox="0 0 14 14" fill="none" xmlns="http://www.w3.org/2000/svg">\n                    <path d="M7 0C8.97933 0.052 10.6278 0.736833 11.9455 2.0545C13.2632 3.37217 13.948 5.02067 14 7C13.948 8.97933 13.2632 10.6278 11.9455 11.9455C10.6278 13.2632 8.97933 13.948 7 14C5.02067 13.948 3.37217 13.2632 2.0545 11.9455C0.736833 10.6278 0.052 8.97933 0 7C0.052 5.02067 0.736833 3.37217 2.0545 2.0545C3.37217 0.736833 5.02067 0.052 7 0ZM7 3C6.729 3 6.505 3.099 6.328 3.297C6.151 3.495 6.07283 3.72933 6.0935 4L6.453 8C6.474 8.146 6.53383 8.26317 6.6325 8.3515C6.73117 8.43983 6.8535 8.48417 6.9995 8.4845C7.1455 8.48483 7.26783 8.4405 7.3665 8.3515C7.46517 8.2625 7.525 8.14533 7.546 8L7.9055 4C7.9265 3.729 7.84833 3.49467 7.671 3.297C7.49367 3.09933 7.26967 3.00033 6.999 3H7ZM7 11C7.22933 10.9897 7.4195 10.9115 7.5705 10.7655C7.7215 10.6195 7.797 10.432 7.797 10.203C7.797 9.974 7.7215 9.78383 7.5705 9.6325C7.4195 9.48117 7.22933 9.40567 7 9.406C6.77067 9.40633 6.5805 9.48183 6.4295 9.6325C6.2785 9.78317 6.203 9.97333 6.203 10.203C6.203 10.4327 6.2785 10.6202 6.4295 10.7655C6.5805 10.9108 6.77067 10.989 7 11Z" fill="#F7BA2A"/>\n                </svg>\n                <span class="idvc-modal__body_process_ready-info__text">Any images you have uploaded will be lost if you scan the QR code and continue the process on your mobile device</span>\n            </div>\n        </div>\n\n        <div class="idvc-modal__body_process_validating d-none" id="idvc-modal__body_process_validating">\n            <div class="el-loading-spinner el-loading-spinner_qr-code" id="idvc-validating-spinner">\n                <svg viewBox="25 25 50 50" class="circular circular__background">\n                    <circle cx="50" cy="50" r="20" fill="none" class="path path__background"></circle>\n                </svg>\n                <svg viewBox="25 25 50 50" class="circular">\n                    <circle cx="50" cy="50" r="20" fill="none" class="path"></circle>\n                </svg>\n                <span class="idvc-modal__body_process_validating-info__text">The verification process is currently being completed using a mobile device ...</span>\n            </div>\n        </div>\n\n        <div class="idvc-modal__body_process_done d-none" id="result-success">\n            <div class="idvc-modal__body_process_done-container">\n                <svg\n                        width="64"\n                        height="64"\n                        viewBox="0 0 64 64"\n                        fill="none"\n                        xmlns="http://www.w3.org/2000/svg">\n                    <path d="M31.5 0.5C40.407 0.734 47.8253 3.81575 53.7548 9.74525C59.6842 15.6748 62.766 23.093 63 32C62.766 40.907 59.6842 48.3253 53.7548 54.2548C47.8253 60.1842 40.407 63.266 31.5 63.5C22.593 63.266 15.1748 60.1842 9.24525 54.2548C3.31575 48.3253 0.234 40.907 0 32C0.234 23.093 3.31575 15.6748 9.24525 9.74525C15.1748 3.81575 22.593 0.734 31.5 0.5ZM27.5625 38.1875L20.601 31.226C20.0385 30.71 19.3942 30.452 18.6682 30.452C17.9422 30.452 17.3092 30.7212 16.7693 31.2597C16.2292 31.7982 15.96 32.4193 15.9615 33.1227C15.963 33.8263 16.221 34.4593 16.7355 35.0218L25.6657 43.952C26.1817 44.468 26.8148 44.726 27.5648 44.726C28.3148 44.726 28.9478 44.468 29.4638 43.952L47.9565 25.4593C48.66 24.7558 48.8828 23.9 48.6247 22.892C48.3667 21.884 47.7337 21.251 46.7257 20.993C45.7178 20.735 44.862 20.9578 44.1585 21.6612L27.5625 38.1875Z" fill="#5FCA71"/>\n                </svg>\n                <div class="idvc-modal__body_process_done__text" id="result__text-success">\n                    Success\n                </div>\n            </div>\n        </div>\n\n        <div class="idvc-modal__body_process_done d-none" id="result-error">\n            <div class="idvc-modal__body_process_done-container">\n                <svg\n                        xmlns="http://www.w3.org/2000/svg"\n                        width="64"\n                        height="64"\n                        fill="#ff0000"\n                        viewBox="0 0 512 512">\n                    <path d="M502.876 379.713l-189.486-316.329c-6.088-9.895-14.349-17.903-24.154-23.52l-0.329-0.174c-20.048-11.267-45.677-11.292-65.788 0.022-10.123 5.785-18.372 13.786-24.282 23.381l-0.167 0.291c-0.022 0.045-0.042 0.066-0.064 0.109l-189.619 316.546c-18.512 32.098-7.501 73.127 24.596 91.642 9.476 5.56 20.852 8.88 32.997 8.972h379.12c37.046-0.406 66.736-30.765 66.347-67.804-0.137-12.231-3.526-23.642-9.34-33.446l0.171 0.31zM233.656 189.931c0.138-12.246 10.097-22.12 22.363-22.12s22.225 9.874 22.363 22.107v89.466c0 0.002 0 0.003 0 0.005 0 12.347-10.010 22.356-22.356 22.356-0.002 0-0.004 0-0.005 0h0c-0.002 0-0.005 0-0.008 0-12.345 0-22.352-10.005-22.357-22.348v-0zM278.413 368.985c0 12.368-10.026 22.394-22.394 22.394s-22.394-10.026-22.394-22.394c0-12.367 10.024-22.392 22.391-22.394v0c0.001 0 0.002 0 0.002 0 12.368 0 22.394 10.026 22.394 22.394v0z"/>\n                </svg>\n                <div class="idvc-modal__body_process_done__text" id="result__text-error">\n                    Validation Failed\n                </div>\n            </div>\n        </div>\n        <div class="idvc-modal__footer_qr-code">\n            <button type="button" class="btn btn--primary" id="idvc-qr-code-terminate-process-btn">\n                <span>Done</span>\n            </button>\n        </div>\n    </div>\n</div>\n';
+class QRCodeModal extends Modal {
+  constructor(mountEl, applicantId, domainApi, embeddedAppConnectionId, qrCodeLinkOrigin, state = QRCodeModalState.READY) {
+    super(mountEl);
+    this.applicantId = applicantId;
+    this.state = state;
+    this.domainApi = domainApi;
+    this.embeddedAppConnectionId = embeddedAppConnectionId;
+    this.qrCodeLinkOrigin = qrCodeLinkOrigin;
+    this.initQRCodeURL();
+    if (state === QRCodeModalState.READY) {
+      this.generateQR(this.QRCodeURL);
+    }
+  }
+  init(html2 = qrCodeModalHTML) {
+    super.init(html2);
+    this.qrCodeCanvas = this.container.querySelector("#idvc-modal__body_process_ready-canvas");
+    this.successResultContainer = this.container.querySelector("#result-success");
+    this.errorResultContainer = this.container.querySelector("#result-error");
+    this.processReadyContainer = this.container.querySelector("#idvc-modal__body_process_ready");
+    this.processValidatingContainer = this.container.querySelector("#idvc-modal__body_process_validating");
+    this.terminateProcessingButton = this.container.querySelector("#idvc-qr-code-terminate-process-btn");
+    this.mappedState = {
+      ready: this.processReadyContainer,
+      validating: this.processValidatingContainer,
+      doneWithSuccess: this.successResultContainer,
+      doneWithError: this.errorResultContainer
+    };
+    this.terminateProcessHandler();
+  }
+  initQRCodeURL() {
+    this.QRCodeURL = `${this.qrCodeLinkOrigin}/embedded?requestId=${this.applicantId}&embeddedAppConnectionId=${this.embeddedAppConnectionId}&qrCode=true`;
+  }
+  set state(newState) {
+    this.modalState = newState;
+    try {
+      this.changeModalBodyView(this.modalState);
+    } catch (e) {
+      throw new Error(`Wrong modal state, error: ${e}`);
+    }
+  }
+  terminateProcessHandler() {
+    this.terminateProcessingButton.addEventListener("click", () => {
+      const terminateEmbeddedEvent = new CustomEvent("terminateEmbedded", { bubbles: true });
+      this.terminateProcessingButton.dispatchEvent(terminateEmbeddedEvent);
+    });
+  }
+  changeModalBodyView(modalState) {
+    Object.entries(this.mappedState).forEach(([state, container]) => {
+      if (state === modalState) {
+        container.classList.remove("d-none");
+      } else {
+        container.classList.add("d-none");
+      }
+    });
+    modalState === QRCodeModalState.VALIDATING ? this.terminateProcessingButton.classList.remove("d-none") : this.terminateProcessingButton.classList.add("d-none");
+  }
+  async generateQR(url) {
+    try {
+      await QRCode.toCanvas(this.qrCodeCanvas, url, {
+        width: this.qrCodeCanvas.width
+      });
+    } catch (e) {
+      throw new Error(`generate qr code error: ${e}`);
+    }
+  }
+  show() {
+    this.prepareBackgroundStyles();
+    super.show();
+  }
+}
+const browserRE = /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|ipad|iris|kindle|Android|Silk|lge |maemo|midp|mmp|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows (ce|phone)|xda|xiino/i;
+const browserREAlt = /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i;
+const isiOS = () => [
+  "iPad Simulator",
+  "iPhone Simulator",
+  "iPad",
+  "iPhone"
+].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
+const checkTouchPoints = () => navigator.maxTouchPoints > 0;
+const isMobile = () => {
+  const { userAgent } = navigator;
+  const mediaQueryCoarse = window.matchMedia("(any-pointer: coarse)");
+  const hasTouches = checkTouchPoints();
+  const isMobileUserAgent = () => browserRE.test(userAgent) || browserREAlt.test(userAgent.substring(0, 4)) || isiOS();
+  const isTouchable = () => window.PointerEvent && hasTouches;
+  const isTouchScreen = () => mediaQueryCoarse.matches;
+  const isSurface = () => userAgent.indexOf("Windows") !== -1 && isTouchable();
+  return {
+    isMobileUserAgent,
+    isTouchable,
+    isTouchScreen,
+    isSurface
+  };
+};
+const checkIfMobile = () => {
+  const mc = isMobile();
+  const isMobileUserAgent = mc.isMobileUserAgent();
+  const isTouchable = mc.isTouchable();
+  const isTouchScreen = mc.isTouchScreen();
+  const isSurface = mc.isSurface();
+  return isMobileUserAgent && isTouchable && isTouchScreen || isSurface;
+};
+const version = "2.9.0";
+const packageJson = {
+  version
+};
+class Wrapper {
+  constructor(config, IDVCModule) {
+    this.wrapperContainerId = "idvc-wrapper-container";
+    console.info(`%cIDVCO version: ${packageJson.version}`, "background-color:#f48020; color:#fff; padding: 4px 8px");
+    if (window.location.hostname === "localhost") {
+      console.info("%c You can pass DVS Online domainApi in config. Ex: {domainApi: 'https://localhost:8000'}", "background: #FFCC00; color: #000");
+    }
+    this.config = config;
+    this.IDVCModule = IDVCModule;
+    this.beforeMount(config);
+  }
+  get isEmbeddedFromQR() {
+    return getQueryParam("qrCode") === "true";
+  }
+  get QRCodeIsAvailable() {
+    return !this.isEmbeddedFromQR && !this.config.demoMode && this.options.showQrCode && !checkIfMobile();
+  }
+  updateConfig(newConfig) {
+    this.configs.libConfig = this.prepareConfig(newConfig);
+    this.lib.reloadComponent(this.configs.libConfig);
+  }
+  /**
+   * reinitialize the library with new applicant id
+   */
+  async setApplicant(applicantId) {
+    this.lib.loading = true;
+    try {
+      this.configs.applicantId = applicantId;
+      this.validationModal.hide();
+      const isValidApplicant = await this.checkApplicantIsValid();
+      if (isValidApplicant) {
+        await this.restart();
+        this.lib.loading = false;
+      } else {
+        this.lib.loading = false;
+        throw new Error();
+      }
+    } catch (e) {
+      this.lib.loading = false;
+      this.onError(e);
+    }
+  }
+  async restart() {
+    if (this.lib.initialized) {
+      this.lib.restart();
+    } else {
+      await this.start();
+    }
+  }
+  showLoader(val, bottomText, topText) {
+    if (this.lib) {
+      this.lib.showLoader(val, bottomText, topText);
+    }
+  }
+  wrapIDVCComponent() {
+    const idvcContainer = document.getElementById(this.configs.mountElement);
+    if (idvcContainer) {
+      idvcContainer.classList.add("hidden-element");
+      idvcContainer.outerHTML = `<div id="${this.wrapperContainerId}">${idvcContainer.outerHTML}</div>`;
+    } else {
+      throw new Error("Mount element isn't found");
+    }
+  }
+  async beforeMount(config) {
+    try {
+      this.configs = new Configs(config);
+      this.api = new Api(this.configs.publicKey, this.configs.domainApi);
+      this.lib = new Lib();
+      this.embeddedAppConnectionId = getQueryParam("embeddedAppConnectionId") || createGuid();
+      this.mountValidationModal();
+      this.configs.validate();
+      this.configs.onGetOptionsStart();
+      this.options = await this.api.getOptions(this.configs.domainId);
+      this.configs.onGetOptionsComplete(this.options);
+      if (!this.config.preferApiConfig) {
+        this.options = this.applyWrapperConfigSettings(this.options);
+      }
+      await this.mount();
+    } catch (e) {
+      this.onError(e);
+    }
+  }
+  applyWrapperConfigSettings(wrapperSettingsFromApi) {
+    var _a, _b;
+    if ((_a = this.config) == null ? void 0 : _a.wrapperSettings) {
+      const copy = structuredClone(wrapperSettingsFromApi);
+      const wrapperSettings = ((_b = this.config) == null ? void 0 : _b.wrapperSettings) || {};
+      const keys = Object.keys(wrapperSettings);
+      keys.forEach((key) => {
+        const value = wrapperSettings[key];
+        if (typeof value !== "undefined") {
+          copy[key] = value;
+        }
+      });
+      return copy;
+    }
+    return wrapperSettingsFromApi;
+  }
+  mountQRCodeButton() {
+    var _a;
+    const mountElementBtns = document.getElementById("card-steps");
+    if (mountElementBtns) {
+      mountElementBtns.insertAdjacentHTML("afterend", html);
+    }
+    this.qrCodeBtn = document.getElementById("qr-code-wrap__button");
+    (_a = this.qrCodeBtn) == null ? void 0 : _a.addEventListener("click", () => {
+      this.QRCodeModal.show();
+    });
+  }
+  async mount() {
+    try {
+      const isValidApplicant = await this.checkApplicantIsValid();
+      if (isValidApplicant && this.options.showConsentForm) {
+        this.wrapIDVCComponent();
+        this.form = new ConsentForm({
+          mountElementID: this.wrapperContainerId,
+          consentBodyText: this.options.consentText,
+          consentCheckboxText: this.options.checkboxText
+        });
+        this.form.form.addEventListener("proceedEvent", async () => {
+          var _a;
+          (_a = document.getElementById(this.configs.mountElement)) == null ? void 0 : _a.classList.remove("hidden-element");
+        }, { once: true });
+      }
+      if (isValidApplicant) {
+        await this.start();
+        this.showSpinner();
+        if (this.QRCodeIsAvailable) {
+          this.mountQR();
+        }
+        if (this.isEmbeddedFromQR) {
+          this.api.longPollingRequest(
+            `IsClosed/${this.configs.applicantId}`,
+            { method: "GET" },
+            () => {
+              this.unmount();
+            }
+          );
+          this.api.longPollingRequest(
+            `Open/${this.configs.applicantId}`,
+            { method: "POST" },
+            () => {
+            }
+          );
+        }
+      } else {
+        throw new Error();
+      }
+    } catch (e) {
+      this.onError(e);
+    }
+  }
+  unmount() {
+    const target = document.getElementById(this.configs.libConfig.el);
+    target.remove();
+  }
+  async checkApplicantIsValid() {
+    return this.api.checkApplicantIdIsNotClosed({
+      applicantId: this.configs.applicantId,
+      demoMode: this.configs.demoMode,
+      faceAuth: this.configs.isAuth,
+      faceOnly: this.configs.faceOnly
+    });
+  }
+  prepareConfig(options) {
+    const libSettings = JSON.parse(options);
+    libSettings.documentTypes = prepareDocumentTypes(libSettings);
+    return libSettings;
+  }
+  showSpinner() {
+    this.validationModal.hideSpinner();
+    this.validationModal.closable = false;
+  }
+  async submit(model) {
+    try {
+      const submitProcessSpinner = {
+        top: "Document has been submitted for processing",
+        bottom: "Please wait for the response"
+      };
+      this.lib.showLoader(true, submitProcessSpinner.bottom, submitProcessSpinner.top);
+      const postModel = await this.createPostModel(
+        model,
+        this.configs.isAuth || this.configs.faceOnly
+      );
+      const postData = {
+        applicantId: postModel.applicantId,
+        model: postModel,
+        embeddedAppConnectionId: this.embeddedAppConnectionId
+      };
+      this.validationOutput = await this.api.validateApplicant(
+        postData,
+        this.configs.demoMode,
+        this.configs.isAuth
+      );
+      this.lib.showLoader(false);
+      this.configs.onValidate(this.validationOutput);
+      this.showSpinner();
+      this.showValidationSuccess();
+    } catch (e) {
+      this.lib.loading = false;
+      this.onError(e);
+    }
+  }
+  showValidationSuccess() {
+    const validation = new Validation(this.validationOutput, this.validationModal);
+    validation.prepareModal();
+    validation.showModal();
+  }
+  async createPostModel(model, isFaceAuth) {
+    return {
+      applicantId: this.configs.applicantId,
+      ...model,
+      ...{ documentType: isFaceAuth ? 10 : model.documentType },
+      clientVersion: this.lib.version,
+      clientType: ClientType.WebLibStandalone
+    };
+  }
+  async start() {
+    await this.loadOptions();
+    this.lib.configs = {
+      IdvcConfig: this.configs.libConfig,
+      CSSStylesConfig: this.configs.cssStylesConfig,
+      CSSVariablesConfig: this.configs.cssVariablesConfig
+    };
+    this.lib.mixSubmit("submit", this.submit.bind(this));
+    if (this.configs.IDVCDownloadVersion === "latest" && this.configs.libConfig.useCDN) {
+      const currentProductionIdvcVersion = await this.api.getCurrentIdvcVersion();
+      await this.lib.initializeLibrary(
+        !!this.configs.libConfig.useCDN,
+        currentProductionIdvcVersion
+      );
+    } else {
+      await this.lib.initializeLibrary(
+        !!this.configs.libConfig.useCDN,
+        this.configs.IDVCDownloadVersion,
+        this.IDVCModule
+      );
+    }
+    this.mountValidationModal();
+  }
+  mountQR() {
+    this.mountQRCodeModal();
+    this.mountQRCodeButton();
+  }
+  async loadOptions() {
+    this.configs.parseFromWeb(this.options);
+  }
+  async forceClose() {
+    try {
+      this.lib.loading = true;
+      const res = await this.api.forceClose(this.configs.applicantId);
+      if (res) {
+        this.configs.onValidate({
+          ...this.validationOutput,
+          forceComplete: true
+        });
+        this.validationOutput.status = ResponseStatus.COMPLETE;
+        this.showValidationSuccess();
+      } else {
+        throw new Error();
+      }
+    } catch (e) {
+      this.onError(e);
+    } finally {
+      this.lib.loading = false;
+    }
+  }
+  mountValidationModal() {
+    this.validationModal = new ValidationModal(this.configs.mountElement);
+    this.validationModal.addCompleteHandler(this.forceClose.bind(this));
+  }
+  mountQRCodeModal() {
+    this.QRCodeModal = new QRCodeModal(
+      this.configs.mountElement,
+      this.configs.applicantId,
+      this.configs.domainApi,
+      this.embeddedAppConnectionId,
+      this.configs.qrCodeLinkOrigin
+    );
+    this.QRCodeModal.hide();
+    this.api.longPollingRequest(
+      `Status/${this.configs.applicantId}`,
+      { method: "GET" },
+      (status) => {
+        this.processEmbeddedAppStart(status);
+      }
+    );
+    this.QRCodeModal.modalContainer.addEventListener("terminateEmbedded", () => {
+      this.api.closeEmbeddedApplication(
+        this.configs.applicantId,
+        () => {
+          this.QRCodeModal.hide();
+          this.qrCodeBtn.disabled = true;
+          this.api.longPollingRequest(
+            `Status/${this.configs.applicantId}`,
+            { method: "GET" },
+            (status) => {
+              this.processEmbeddedAppStart(status);
+              this.qrCodeBtn.disabled = false;
+            }
+          );
+        }
+      );
+    });
+  }
+  processEmbeddedAppStart(status) {
+    const getFirstStepModeState = this.configs.getFirstStepModeState();
+    if (status === EmbeddedStatus.OPEN) {
+      this.QRCodeModal.state = QRCodeModalState.VALIDATING;
+      this.QRCodeModal.closable = false;
+      this.QRCodeModal.show();
+      this.api.longPollingRequest(
+        `ValidationResponse/${this.configs.applicantId}/${this.embeddedAppConnectionId}`,
+        { method: "GET" },
+        (data) => {
+          this.processEmbeddedAppEnd(data);
+        }
+      );
+      if (this.configs.firstStepMode) {
+        this.configs.firstStepMode.video = false;
+        this.configs.firstStepMode.uploader = true;
+      }
+      this.lib.updateDocumentTypes(this.configs.libConfig.documentTypes);
+    } else if (status === EmbeddedStatus.CLOSED || status === EmbeddedStatus.NEVER_OPEN) {
+      const firstStepMode = getFirstStepModeState();
+      if (firstStepMode && this.configs.firstStepMode) {
+        [this.configs.firstStepMode.video, this.configs.firstStepMode.uploader] = [
+          firstStepMode.video,
+          firstStepMode.uploader
+        ];
+      }
+      this.QRCodeModal.state = QRCodeModalState.READY;
+      this.QRCodeModal.closable = true;
+      this.api.longPollingRequest(
+        `IsOpen/${this.configs.applicantId}`,
+        { method: "GET" },
+        (isOpen) => {
+          if (isOpen) {
+            this.processEmbeddedAppStart(EmbeddedStatus.OPEN);
+          }
+        }
+      );
+    } else if (status === EmbeddedStatus.CLOSED_FOREVER) {
+      this.QRCodeModal.state = QRCodeModalState.DONE_WITH_ERROR;
+      this.QRCodeModal.closable = false;
+    }
+  }
+  processEmbeddedAppEnd(data) {
+    if ((data == null ? void 0 : data.status) === ResponseStatus.SUCCESS) {
+      this.QRCodeModal.state = QRCodeModalState.DONE_WITH_SUCCESS;
+    } else {
+      this.api.longPollingRequest(
+        `Status/${this.configs.applicantId}`,
+        { method: "GET" },
+        (status) => {
+          this.processEmbeddedAppStart(status);
+          this.qrCodeBtn.disabled = false;
+        }
+      );
+    }
+    this.QRCodeModal.closable = false;
+    this.validationOutput = data;
+    this.configs.onValidate(this.validationOutput);
+  }
+  onError(e) {
+    var _a, _b;
+    if ((_a = this.configs) == null ? void 0 : _a.onError) {
+      this.configs.onError(e);
+      const buttons = {
+        tryAgain: false,
+        complete: false
+      };
+      this.validationModal.type = ValidationStatus.DANGER;
+      this.validationModal.header = e.header || "Something Went Wrong";
+      this.validationModal.content = e.content || "Try again later";
+      if (["HttpError", "ValidationError", "FaceAuthorizationError"].includes(e.name)) {
+        buttons.tryAgain = true;
+      }
+      this.validationModal.buttons = buttons;
+      this.validationModal.showSpinner(false);
+      if (this.form) {
+        this.form.form.remove();
+      }
+      (_b = document.getElementById(this.configs.mountElement)) == null ? void 0 : _b.classList.remove("hidden-element");
+      this.validationModal.show();
+    }
+    return e;
+  }
+}
+export {
+  Wrapper as default
+};
+//# sourceMappingURL=wrapper.es.js.map