@microblink/blinkid-verify-core 3.20.0-rc.0

package/dist/blinkid-verify-core.js

@@ -0,0 +1,1229 @@
+class We {
+  /**
+   * Injected function for queing ping events.
+   */
+  #t;
+  /**
+   * Injected function for triggering sending of queued pinglets.
+   */
+  #a;
+  constructor({ pingFn: r, sendPingletsFn: n }) {
+    this.#t = r, this.#a = n;
+  }
+  /**
+   * Safely send a ping event, handling errors gracefully
+   */
+  async #e(r) {
+    try {
+      await this.#t(r);
+    } catch (n) {
+      console.warn("UX analytics ping failed:", n);
+    }
+  }
+  /**
+   * Safely send queued pinglets, handling errors gracefully
+   */
+  async sendPinglets() {
+    try {
+      await this.#a();
+    } catch (r) {
+      console.warn("Send pinglets failed:", r);
+    }
+  }
+  /**
+   * Create a camera permission ping
+   */
+  #n(r) {
+    return {
+      schemaName: "ping.sdk.camera.permission",
+      schemaVersion: "1.0.0",
+      data: r
+    };
+  }
+  /**
+   * Create a standardized UX event ping
+   */
+  #r(r) {
+    return {
+      schemaName: "ping.sdk.ux.event",
+      schemaVersion: "1.0.0",
+      data: r
+    };
+  }
+  #o(r) {
+    if (r instanceof Error)
+      return r.message;
+    if (typeof r == "object" && r !== null)
+      try {
+        return JSON.stringify(r);
+      } catch {
+        return String(r);
+      }
+    return String(r);
+  }
+  logCameraStartedEvent() {
+    return this.#e(this.#r({
+      eventType: "CameraStarted"
+    }));
+  }
+  logCameraClosedEvent() {
+    return this.#e(this.#r({
+      eventType: "CameraClosed"
+    }));
+  }
+  logHelpOpenedEvent() {
+    return this.#e(this.#r({
+      eventType: "HelpOpened"
+    }));
+  }
+  logHelpClosedEvent(r) {
+    return this.#e(this.#r({
+      eventType: "HelpClosed",
+      helpCloseType: r ? "ContentFullyViewed" : "ContentSkipped"
+    }));
+  }
+  logHelpTooltipDisplayedEvent() {
+    return this.#e(this.#r({
+      eventType: "HelpTooltipDisplayed"
+    }));
+  }
+  logCloseButtonClickedEvent() {
+    return this.#e(this.#r({
+      eventType: "CloseButtonClicked"
+    }));
+  }
+  logOnboardingDisplayedEvent() {
+    return this.#e(this.#r({
+      eventType: "OnboardingInfoDisplayed"
+    }));
+  }
+  logAlertDisplayedEvent(r) {
+    return this.#e(this.#r({
+      eventType: "AlertDisplayed",
+      alertType: r
+    }));
+  }
+  logErrorMessageEvent(r) {
+    return this.#e(this.#r({
+      eventType: "ErrorMessage",
+      errorMessageType: r
+    }));
+  }
+  logAppMovedToBackgroundEvent() {
+    return this.#e(this.#r({
+      eventType: "AppMovedToBackground"
+    }));
+  }
+  logStepTimeoutEvent() {
+    return this.#e(this.#r({
+      eventType: "StepTimeout"
+    }));
+  }
+  logCameraInputInfo(r) {
+    return this.#e({
+      schemaName: "ping.sdk.camera.input.info",
+      schemaVersion: "1.0.2",
+      data: r
+    });
+  }
+  logHardwareCameraInfo(r) {
+    return this.#e({
+      schemaName: "ping.hardware.camera.info",
+      schemaVersion: "1.0.3",
+      data: {
+        availableCameras: r
+      }
+    });
+  }
+  logCameraPermissionCheck(r) {
+    return this.#e(this.#n({
+      eventType: "CameraPermissionCheck",
+      cameraPermissionGranted: r
+    }));
+  }
+  logCameraPermissionRequest() {
+    return this.#e(this.#n({
+      eventType: "CameraPermissionRequest"
+    }));
+  }
+  logCameraPermissionUserResponse(r) {
+    return this.#e(this.#n({
+      eventType: "CameraPermissionUserResponse",
+      cameraPermissionGranted: r
+    }));
+  }
+  logDeviceOrientation(r) {
+    return this.#e({
+      schemaName: "ping.sdk.scan.conditions",
+      schemaVersion: "1.0.0",
+      data: {
+        updateType: "DeviceOrientation",
+        deviceOrientation: r
+      }
+    });
+  }
+  logFlashlightState(r) {
+    return this.#e({
+      schemaName: "ping.sdk.scan.conditions",
+      schemaVersion: "1.0.0",
+      data: {
+        updateType: "FlashlightState",
+        flashlightOn: r
+      }
+    });
+  }
+  logDeviceInfo(r) {
+    return this.#e({
+      schemaName: "ping.browser.device.info",
+      schemaVersion: "1.0.0",
+      data: r
+    });
+  }
+  logErrorEvent({ origin: r, error: n, errorType: t, sessionNumber: a }) {
+    return this.#e({
+      schemaName: "ping.error",
+      schemaVersion: "1.0.0",
+      sessionNumber: a,
+      data: {
+        errorType: t,
+        errorMessage: `${r}: ${this.#o(n)}`,
+        stackTrace: n instanceof Error ? n.stack : void 0
+      }
+    });
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const D = Symbol("Comlink.proxy"), ee = Symbol("Comlink.endpoint"), B = Symbol("Comlink.releaseProxy"), k = Symbol("Comlink.finalizer"), C = Symbol("Comlink.thrown"), H = (e) => typeof e == "object" && e !== null || typeof e == "function", re = {
+  canHandle: (e) => H(e) && e[D],
+  serialize(e) {
+    const { port1: r, port2: n } = new MessageChannel();
+    return U(e, r), [n, [n]];
+  },
+  deserialize(e) {
+    return e.start(), $(e);
+  }
+}, ne = {
+  canHandle: (e) => H(e) && C in e,
+  serialize({ value: e }) {
+    let r;
+    return e instanceof Error ? r = {
+      isError: !0,
+      value: {
+        message: e.message,
+        name: e.name,
+        stack: e.stack
+      }
+    } : r = { isError: !1, value: e }, [r, []];
+  },
+  deserialize(e) {
+    throw e.isError ? Object.assign(new Error(e.value.message), e.value) : e.value;
+  }
+}, j = /* @__PURE__ */ new Map([
+  ["proxy", re],
+  ["throw", ne]
+]);
+function te(e, r) {
+  for (const n of e)
+    if (r === n || n === "*" || n instanceof RegExp && n.test(r))
+      return !0;
+  return !1;
+}
+function U(e, r = globalThis, n = ["*"]) {
+  r.addEventListener("message", function t(a) {
+    if (!a || !a.data)
+      return;
+    if (!te(n, a.origin)) {
+      console.warn(`Invalid origin '${a.origin}' for comlink proxy`);
+      return;
+    }
+    const { id: o, type: i, path: s } = Object.assign({ path: [] }, a.data), l = (a.data.argumentList || []).map(w);
+    let c;
+    try {
+      const u = s.slice(0, -1).reduce((f, p) => f[p], e), m = s.reduce((f, p) => f[p], e);
+      switch (i) {
+        case "GET":
+          c = m;
+          break;
+        case "SET":
+          u[s.slice(-1)[0]] = w(a.data.value), c = !0;
+          break;
+        case "APPLY":
+          c = m.apply(u, l);
+          break;
+        case "CONSTRUCT":
+          {
+            const f = new m(...l);
+            c = q(f);
+          }
+          break;
+        case "ENDPOINT":
+          {
+            const { port1: f, port2: p } = new MessageChannel();
+            U(e, p), c = Q(f, [f]);
+          }
+          break;
+        case "RELEASE":
+          c = void 0;
+          break;
+        default:
+          return;
+      }
+    } catch (u) {
+      c = { value: u, [C]: 0 };
+    }
+    Promise.resolve(c).catch((u) => ({ value: u, [C]: 0 })).then((u) => {
+      const [m, f] = L(u);
+      r.postMessage(Object.assign(Object.assign({}, m), { id: o }), f), i === "RELEASE" && (r.removeEventListener("message", t), W(r), k in e && typeof e[k] == "function" && e[k]());
+    }).catch((u) => {
+      const [m, f] = L({
+        value: new TypeError("Unserializable return value"),
+        [C]: 0
+      });
+      r.postMessage(Object.assign(Object.assign({}, m), { id: o }), f);
+    });
+  }), r.start && r.start();
+}
+function ae(e) {
+  return e.constructor.name === "MessagePort";
+}
+function W(e) {
+  ae(e) && e.close();
+}
+function $(e, r) {
+  const n = /* @__PURE__ */ new Map();
+  return e.addEventListener("message", function(a) {
+    const { data: o } = a;
+    if (!o || !o.id)
+      return;
+    const i = n.get(o.id);
+    if (i)
+      try {
+        i(o);
+      } finally {
+        n.delete(o.id);
+      }
+  }), A(e, n, [], r);
+}
+function R(e) {
+  if (e)
+    throw new Error("Proxy has been released and is not useable");
+}
+function G(e) {
+  return b(e, /* @__PURE__ */ new Map(), {
+    type: "RELEASE"
+  }).then(() => {
+    W(e);
+  });
+}
+const M = /* @__PURE__ */ new WeakMap(), x = "FinalizationRegistry" in globalThis && new FinalizationRegistry((e) => {
+  const r = (M.get(e) || 0) - 1;
+  M.set(e, r), r === 0 && G(e);
+});
+function oe(e, r) {
+  const n = (M.get(r) || 0) + 1;
+  M.set(r, n), x && x.register(e, r, e);
+}
+function ie(e) {
+  x && x.unregister(e);
+}
+function A(e, r, n = [], t = function() {
+}) {
+  let a = !1;
+  const o = new Proxy(t, {
+    get(i, s) {
+      if (R(a), s === B)
+        return () => {
+          ie(o), G(e), r.clear(), a = !0;
+        };
+      if (s === "then") {
+        if (n.length === 0)
+          return { then: () => o };
+        const l = b(e, r, {
+          type: "GET",
+          path: n.map((c) => c.toString())
+        }).then(w);
+        return l.then.bind(l);
+      }
+      return A(e, r, [...n, s]);
+    },
+    set(i, s, l) {
+      R(a);
+      const [c, u] = L(l);
+      return b(e, r, {
+        type: "SET",
+        path: [...n, s].map((m) => m.toString()),
+        value: c
+      }, u).then(w);
+    },
+    apply(i, s, l) {
+      R(a);
+      const c = n[n.length - 1];
+      if (c === ee)
+        return b(e, r, {
+          type: "ENDPOINT"
+        }).then(w);
+      if (c === "bind")
+        return A(e, r, n.slice(0, -1));
+      const [u, m] = I(l);
+      return b(e, r, {
+        type: "APPLY",
+        path: n.map((f) => f.toString()),
+        argumentList: u
+      }, m).then(w);
+    },
+    construct(i, s) {
+      R(a);
+      const [l, c] = I(s);
+      return b(e, r, {
+        type: "CONSTRUCT",
+        path: n.map((u) => u.toString()),
+        argumentList: l
+      }, c).then(w);
+    }
+  });
+  return oe(o, e), o;
+}
+function se(e) {
+  return Array.prototype.concat.apply([], e);
+}
+function I(e) {
+  const r = e.map(L);
+  return [r.map((n) => n[0]), se(r.map((n) => n[1]))];
+}
+const z = /* @__PURE__ */ new WeakMap();
+function Q(e, r) {
+  return z.set(e, r), e;
+}
+function q(e) {
+  return Object.assign(e, { [D]: !0 });
+}
+function L(e) {
+  for (const [r, n] of j)
+    if (n.canHandle(e)) {
+      const [t, a] = n.serialize(e);
+      return [
+        {
+          type: "HANDLER",
+          name: r,
+          value: t
+        },
+        a
+      ];
+    }
+  return [
+    {
+      type: "RAW",
+      value: e
+    },
+    z.get(e) || []
+  ];
+}
+function w(e) {
+  switch (e.type) {
+    case "HANDLER":
+      return j.get(e.name).deserialize(e.value);
+    case "RAW":
+      return e.value;
+  }
+}
+function b(e, r, n, t) {
+  return new Promise((a) => {
+    const o = ce();
+    r.set(o, a), e.start && e.start(), e.postMessage(Object.assign({ id: o }, n), t);
+  });
+}
+function ce() {
+  return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
+}
+var le = /* @__PURE__ */ function() {
+  function e(r, n) {
+    for (var t = 0; t < n.length; t++) {
+      var a = n[t];
+      a.enumerable = a.enumerable || !1, a.configurable = !0, "value" in a && (a.writable = !0), Object.defineProperty(r, a.key, a);
+    }
+  }
+  return function(r, n, t) {
+    return n && e(r.prototype, n), t && e(r, t), r;
+  };
+}(), ue = fe(["", ""], ["", ""]);
+function fe(e, r) {
+  return Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(r) } }));
+}
+function de(e, r) {
+  if (!(e instanceof r))
+    throw new TypeError("Cannot call a class as a function");
+}
+var d = function() {
+  function e() {
+    for (var r = this, n = arguments.length, t = Array(n), a = 0; a < n; a++)
+      t[a] = arguments[a];
+    return de(this, e), this.tag = function(o) {
+      for (var i = arguments.length, s = Array(i > 1 ? i - 1 : 0), l = 1; l < i; l++)
+        s[l - 1] = arguments[l];
+      return typeof o == "function" ? r.interimTag.bind(r, o) : typeof o == "string" ? r.transformEndResult(o) : (o = o.map(r.transformString.bind(r)), r.transformEndResult(o.reduce(r.processSubstitutions.bind(r, s))));
+    }, t.length > 0 && Array.isArray(t[0]) && (t = t[0]), this.transformers = t.map(function(o) {
+      return typeof o == "function" ? o() : o;
+    }), this.tag;
+  }
+  return le(e, [{
+    key: "interimTag",
+    /**
+     * An intermediary template tag that receives a template tag and passes the result of calling the template with the received
+     * template tag to our own template tag.
+     * @param  {Function}        nextTag          - the received template tag
+     * @param  {Array<String>}   template         - the template to process
+     * @param  {...*}            ...substitutions - `substitutions` is an array of all substitutions in the template
+     * @return {*}                                - the final processed value
+     */
+    value: function(n, t) {
+      for (var a = arguments.length, o = Array(a > 2 ? a - 2 : 0), i = 2; i < a; i++)
+        o[i - 2] = arguments[i];
+      return this.tag(ue, n.apply(void 0, [t].concat(o)));
+    }
+    /**
+     * Performs bulk processing on the tagged template, transforming each substitution and then
+     * concatenating the resulting values into a string.
+     * @param  {Array<*>} substitutions - an array of all remaining substitutions present in this template
+     * @param  {String}   resultSoFar   - this iteration's result string so far
+     * @param  {String}   remainingPart - the template chunk after the current substitution
+     * @return {String}                 - the result of joining this iteration's processed substitution with the result
+     */
+  }, {
+    key: "processSubstitutions",
+    value: function(n, t, a) {
+      var o = this.transformSubstitution(n.shift(), t);
+      return "".concat(t, o, a);
+    }
+    /**
+     * Iterate through each transformer, applying the transformer's `onString` method to the template
+     * strings before all substitutions are processed.
+     * @param {String}  str - The input string
+     * @return {String}     - The final results of processing each transformer
+     */
+  }, {
+    key: "transformString",
+    value: function(n) {
+      var t = function(o, i) {
+        return i.onString ? i.onString(o) : o;
+      };
+      return this.transformers.reduce(t, n);
+    }
+    /**
+     * When a substitution is encountered, iterates through each transformer and applies the transformer's
+     * `onSubstitution` method to the substitution.
+     * @param  {*}      substitution - The current substitution
+     * @param  {String} resultSoFar  - The result up to and excluding this substitution.
+     * @return {*}                   - The final result of applying all substitution transformations.
+     */
+  }, {
+    key: "transformSubstitution",
+    value: function(n, t) {
+      var a = function(i, s) {
+        return s.onSubstitution ? s.onSubstitution(i, t) : i;
+      };
+      return this.transformers.reduce(a, n);
+    }
+    /**
+     * Iterates through each transformer, applying the transformer's `onEndResult` method to the
+     * template literal after all substitutions have finished processing.
+     * @param  {String} endResult - The processed template, just before it is returned from the tag
+     * @return {String}           - The final results of processing each transformer
+     */
+  }, {
+    key: "transformEndResult",
+    value: function(n) {
+      var t = function(o, i) {
+        return i.onEndResult ? i.onEndResult(o) : o;
+      };
+      return this.transformers.reduce(t, n);
+    }
+  }]), e;
+}(), g = function() {
+  var r = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
+  return {
+    onEndResult: function(t) {
+      if (r === "")
+        return t.trim();
+      if (r = r.toLowerCase(), r === "start" || r === "left")
+        return t.replace(/^\s*/, "");
+      if (r === "end" || r === "right")
+        return t.replace(/\s*$/, "");
+      throw new Error("Side not supported: " + r);
+    }
+  };
+};
+function ge(e) {
+  if (Array.isArray(e)) {
+    for (var r = 0, n = Array(e.length); r < e.length; r++)
+      n[r] = e[r];
+    return n;
+  } else
+    return Array.from(e);
+}
+var y = function() {
+  var r = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "initial";
+  return {
+    onEndResult: function(t) {
+      if (r === "initial") {
+        var a = t.match(/^[^\S\n]*(?=\S)/gm), o = a && Math.min.apply(Math, ge(a.map(function(s) {
+          return s.length;
+        })));
+        if (o) {
+          var i = new RegExp("^.{" + o + "}", "gm");
+          return t.replace(i, "");
+        }
+        return t;
+      }
+      if (r === "all")
+        return t.replace(/^[^\S\n]+/gm, "");
+      throw new Error("Unknown type: " + r);
+    }
+  };
+}, E = function(r, n) {
+  return {
+    onEndResult: function(a) {
+      if (r == null || n == null)
+        throw new Error("replaceResultTransformer requires at least 2 arguments.");
+      return a.replace(r, n);
+    }
+  };
+}, S = function(r, n) {
+  return {
+    onSubstitution: function(a, o) {
+      if (r == null || n == null)
+        throw new Error("replaceSubstitutionTransformer requires at least 2 arguments.");
+      return a == null ? a : a.toString().replace(r, n);
+    }
+  };
+}, me = {
+  separator: "",
+  conjunction: "",
+  serial: !1
+}, v = function() {
+  var r = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : me;
+  return {
+    onSubstitution: function(t, a) {
+      if (Array.isArray(t)) {
+        var o = t.length, i = r.separator, s = r.conjunction, l = r.serial, c = a.match(/(\n?[^\S\n]+)$/);
+        if (c ? t = t.join(i + c[1]) : t = t.join(i + " "), s && o > 1) {
+          var u = t.lastIndexOf(i);
+          t = t.slice(0, u) + (l ? i : "") + " " + s + t.slice(u + 1);
+        }
+      }
+      return t;
+    }
+  };
+}, Y = function(r) {
+  return {
+    onSubstitution: function(t, a) {
+      return typeof t == "string" && t.includes(r) && (t = t.split(r)), t;
+    }
+  };
+}, O = function(r) {
+  return r != null && !Number.isNaN(r) && typeof r != "boolean";
+}, he = function() {
+  return {
+    onSubstitution: function(n) {
+      return Array.isArray(n) ? n.filter(O) : O(n) ? n : "";
+    }
+  };
+};
+new d(v({ separator: "," }), y, g);
+new d(v({ separator: ",", conjunction: "and" }), y, g);
+new d(v({ separator: ",", conjunction: "or" }), y, g);
+new d(Y(`
+`), he, v, y, g);
+new d(Y(`
+`), v, y, g, S(/&/g, "&amp;"), S(/</g, "&lt;"), S(/>/g, "&gt;"), S(/"/g, "&quot;"), S(/'/g, "&#x27;"), S(/`/g, "&#x60;"));
+new d(E(/(?:\n(?:\s*))+/g, " "), g);
+var ve = new d(E(/(?:\n\s*)/g, ""), g);
+new d(v({ separator: "," }), E(/(?:\s+)/g, " "), g);
+new d(v({ separator: ",", conjunction: "or" }), E(/(?:\s+)/g, " "), g);
+new d(v({ separator: ",", conjunction: "and" }), E(/(?:\s+)/g, " "), g);
+new d(v, y, g);
+new d(v, E(/(?:\s+)/g, " "), g);
+new d(y, g);
+new d(y("all"), g);
+const F = "application/javascript", pe = (e, r = {}) => {
+  const n = {
+    skipSameOrigin: !0,
+    useBlob: !0,
+    ...r
+  };
+  if (n.skipSameOrigin && new URL(e).origin === self.location.origin)
+    return Promise.resolve(e);
+  let t;
+  try {
+    const a = new AbortController();
+    t = a.signal;
+    const o = setTimeout(() => {
+      a.abort();
+    }, 3e3), i = () => {
+      clearTimeout(o), a.abort();
+    };
+    t.addEventListener("abort", i);
+  } catch {
+  }
+  return new Promise((a, o) => void fetch(e, {
+    // abort if the worker is not fetched in a reasonable time
+    signal: t
+  }).then((i) => i.text()).then((i) => {
+    let s = "";
+    if (n.useBlob) {
+      const l = new Blob([i], { type: F });
+      s = URL.createObjectURL(l);
+    } else
+      s = `data:${F},` + encodeURIComponent(i);
+    a(s);
+  }).catch(() => {
+    o(new Error(`Failed to fetch worker from ${e}`));
+  }));
+}, ye = "FrameTransferError";
+class N extends Error {
+  constructor(r, n) {
+    super(r, n), this.name = ye;
+  }
+}
+const we = (e, r) => {
+  const n = r instanceof Error && r.message ? `: ${r.message}` : "";
+  return r instanceof Error ? new N(`${e}${n}`, {
+    cause: r
+  }) : new N(`${e}${n}`);
+}, Se = (e) => e.startsWith("data:"), be = (e) => e.startsWith("blob:"), Ee = (e) => !Se(e) && !be(e), Te = async (e) => {
+  const r = await fetch(e, { method: "HEAD" }), n = r.headers.get("content-type"), t = n?.includes("javascript");
+  if (n?.includes("html"))
+    throw new Error(ve`${e} resolved to a resource with the content type ${n}.
+      This is likely an issue with the server configuration redirecting to an index.html file.
+      Check that your resources are properly hosted`);
+  if (!t)
+    throw new Error(`Worker file is not a JavaScript file: ${n}`);
+  if (!r.ok)
+    throw new Error(`Worker file not found or inaccessible: ${r.status} ${r.statusText}`);
+};
+async function Re(e, r) {
+  const n = await pe(new URL(`resources/${r}`, e).toString());
+  Ee(n) && await Te(n);
+  const t = new Worker(n, {
+    type: "module"
+  }), a = $(t);
+  return t.onerror = (i) => {
+    console.error("Worker error:", i), a[B]();
+  }, new Proxy(a, {
+    get(i, s, l) {
+      return s === "createScanningSession" ? async (...c) => {
+        const u = await i.createScanningSession(...c);
+        return new Proxy(u, {
+          get(f, p, X) {
+            return p === "process" ? (T) => {
+              const J = {
+                data: T.data,
+                width: T.width,
+                height: T.height,
+                colorSpace: T.colorSpace ?? "srgb"
+              };
+              let V;
+              try {
+                V = Q(J, [
+                  T.data.buffer
+                ]);
+              } catch (Z) {
+                throw we("Failed to transfer frame to worker", Z);
+              }
+              return f.process(V);
+            } : Reflect.get(f, p, X);
+          }
+        });
+      } : Reflect.get(i, s, l);
+    }
+  });
+}
+function Ce() {
+  const e = navigator.userAgent;
+  if (/iPad/.test(e) || /Macintosh/.test(e) && navigator.maxTouchPoints > 1)
+    return "iPad";
+  if (/iPhone/.test(e))
+    return "iPhone";
+  if (/Macintosh/.test(e))
+    return "Mac";
+}
+const Me = [
+  // 1. In-App Browsers
+  {
+    name: "Facebook In-App",
+    regex: /FBAV\/([\d.]+)/,
+    getVersion: (e) => e[1]
+  },
+  {
+    name: "Instagram In-App",
+    regex: /Instagram ([\d.]+)/,
+    getVersion: (e) => e[1]
+  },
+  { name: "TikTok In-App", regex: /TikTok/, getVersion: () => "" },
+  // 2. Niche/Alternate Browsers (must be checked before generic Chrome)
+  { name: "Edge", regex: /Edg\/([\d.]+)/, getVersion: (e) => e[1] },
+  {
+    name: "DuckDuckGo",
+    regex: /DuckDuckGo\/([\d.]+)/,
+    getVersion: (e) => e[1]
+  },
+  {
+    name: "Vivaldi",
+    regex: /Vivaldi\/([\d.]+)/,
+    getVersion: (e) => e[1]
+  },
+  { name: "Opera", regex: /OPR\/([\d.]+)/, getVersion: (e) => e[1] },
+  {
+    name: "Samsung Browser",
+    regex: /SamsungBrowser\/([\d.]+)/,
+    getVersion: (e) => e[1]
+  },
+  // 3. Platform-specific browsers (e.g., on iOS)
+  {
+    name: "Firefox",
+    regex: /FxiOS\/([\S]+)/,
+    // Firefox on iOS
+    getVersion: (e) => e[1]
+  },
+  {
+    name: "Chrome",
+    regex: /CriOS\/([\S]+)/,
+    // Chrome on iOS
+    getVersion: (e) => e[1]
+  },
+  // 4. WebViews (must be checked before generic Chrome/Safari)
+  {
+    name: "Android WebView",
+    regex: /; wv\)/,
+    getVersion: (e, r) => r.match(/Chrome\/([\d.]+)/)?.[1] ?? ""
+  },
+  // 5. Major Mainstream Browsers (the final fallbacks)
+  {
+    name: "Brave",
+    regex: /Brave/,
+    getVersion: (e, r) => r.match(/Chrome\/([\d.]+)/)?.[1] ?? ""
+  },
+  {
+    name: "Chrome",
+    regex: /Chrome\/([\d.]+)/,
+    getVersion: (e) => e[1]
+  },
+  {
+    name: "Firefox",
+    regex: /Firefox\/([\d.]+)/,
+    getVersion: (e) => e[1]
+  },
+  {
+    name: "Safari",
+    regex: /Version\/([\d.]+).*Safari/,
+    getVersion: (e) => e[1]
+  }
+];
+function xe() {
+  const e = navigator.userAgent;
+  for (const r of Me) {
+    const n = e.match(r.regex);
+    if (n)
+      return {
+        name: r.name,
+        version: r.getVersion(n, e)
+      };
+  }
+  if (window.webkit?.messageHandlers) {
+    const r = e.match(/OS ([\d_]+)/);
+    return {
+      name: "iOS WebView",
+      version: r ? r[1].replace(/_/g, ".") : ""
+    };
+  }
+  return { name: "Unknown", version: "" };
+}
+function Le(e, r) {
+  if (!r.versionRegex)
+    return "";
+  const n = e.match(r.versionRegex);
+  return n?.[1] ? r.versionTransform ? r.versionTransform(n[1]) : n[1] : "";
+}
+function ke() {
+  const e = navigator.userAgent, r = {
+    "10.0": "10 or 11",
+    "6.3": "8.1",
+    "6.2": "8",
+    "6.1": "7"
+  }, n = [
+    {
+      os: "iPadOS",
+      condition: /Macintosh/.test(e) && navigator.maxTouchPoints > 1,
+      versionRegex: /Mac OS X ([\d_]+)/,
+      versionTransform: (t) => t.replace(/_/g, ".")
+    },
+    {
+      os: "iOS",
+      condition: /iPhone/.test(e),
+      versionRegex: /iPhone OS ([\d_]+)/,
+      versionTransform: (t) => t.replace(/_/g, ".")
+    },
+    {
+      os: "macOS",
+      condition: /Macintosh/.test(e),
+      versionRegex: /Mac OS X ([\d_]+)/,
+      versionTransform: (t) => t.replace(/_/g, ".")
+    },
+    {
+      os: "Windows",
+      condition: /Win/.test(e),
+      versionRegex: /Windows NT ([\d.]+)/,
+      versionTransform: (t) => r[t] || t
+    },
+    {
+      os: "Android",
+      condition: /Android/.test(e),
+      versionRegex: /Android ([\d.]+)/
+    },
+    {
+      os: "Linux",
+      condition: /Linux/.test(e)
+    }
+  ];
+  for (const t of n)
+    if (t.condition) {
+      const a = Le(e, t);
+      return { os: t.os, version: a };
+    }
+  return { os: "", version: "" };
+}
+function Pe(e, r) {
+  const n = Ce();
+  let t = "";
+  if (r?.model)
+    t = r.model;
+  else if (n)
+    t = n;
+  else {
+    const l = e.match(/Android.*?; ([^)]+)\)/);
+    l?.[1] && (t = l[1]);
+  }
+  let a = ["Desktop"];
+  r?.formFactors?.length ? a = r.formFactors : r?.mobile ? a = ["Mobile"] : n && (n === "iPhone" ? a = ["Mobile"] : n === "iPad" && (a = ["Tablet"]));
+  let o = "";
+  r?.platform ? o = r.platform : o = ke().os;
+  let i = "", s = "";
+  if (r?.brands?.length)
+    i = (r.brands.find((c) => !/not.a.brand/i.test(c.brand) && c.brand !== "Chromium") ?? r.brands.find((c) => !/not.a.brand/i.test(c.brand)))?.brand ?? "", r.fullVersionList ? s = r.fullVersionList.find((c) => c.brand === i)?.version ?? "" : s = r.brands.find((c) => c.brand === i)?.version ?? "";
+  else {
+    const l = xe();
+    i = l.name, s = l.version;
+  }
+  return t === "" && o === "macOS" && (t = "Mac"), {
+    model: t,
+    formFactors: a,
+    platform: o,
+    browser: {
+      brand: i,
+      version: s
+    }
+  };
+}
+function Ae() {
+  const r = document.createElement("canvas").getContext("webgl");
+  if (r && r instanceof WebGLRenderingContext) {
+    const n = r.getExtension("WEBGL_debug_renderer_info");
+    return {
+      renderer: n ? r.getParameter(n.UNMASKED_RENDERER_WEBGL) : r.getParameter(r.RENDERER),
+      shadingLanguageVersion: r.getParameter(r.SHADING_LANGUAGE_VERSION),
+      vendor: n ? r.getParameter(n.UNMASKED_VENDOR_WEBGL) : r.getParameter(r.VENDOR),
+      version: r.getParameter(r.VERSION)
+    };
+  }
+}
+function Ve() {
+  try {
+    const e = "__storage_test__";
+    return window.localStorage.setItem(e, e), window.localStorage.removeItem(e), !0;
+  } catch {
+    return !1;
+  }
+}
+async function Ie() {
+  let e;
+  try {
+    e = await navigator.userAgentData?.getHighEntropyValues([
+      "brands",
+      "mobile",
+      "platform",
+      "architecture",
+      "bitness",
+      "formFactors",
+      "model",
+      "platformVersion",
+      "fullVersionList",
+      "wow64"
+    ]);
+  } catch {
+  }
+  return e;
+}
+async function $e() {
+  const e = await Ie();
+  return {
+    userAgentData: e,
+    userAgent: navigator.userAgent,
+    threads: navigator.hardwareConcurrency,
+    memory: navigator.deviceMemory,
+    gpu: Ae(),
+    screen: {
+      screenWidth: window.screen.width,
+      screenHeight: window.screen.height,
+      devicePixelRatio: window.devicePixelRatio,
+      physicalScreenWidth: window.screen.width * window.devicePixelRatio,
+      physicalScreenHeight: window.screen.height * window.devicePixelRatio,
+      maxTouchPoints: navigator.maxTouchPoints
+    },
+    browserStorageSupport: {
+      cookieEnabled: navigator.cookieEnabled,
+      localStorageEnabled: Ve()
+    },
+    derivedDeviceInfo: Pe(navigator.userAgent, e)
+  };
+}
+let _ = (e = 21) => crypto.getRandomValues(new Uint8Array(e)).reduce((r, n) => (n &= 63, n < 36 ? r += n.toString(36) : n < 62 ? r += (n - 26).toString(36).toUpperCase() : n > 62 ? r += "-" : r += "_", r), "");
+function Oe(e) {
+  if (!Fe())
+    return _();
+  const n = localStorage.getItem(e);
+  if (n)
+    return n;
+  const t = _();
+  return localStorage.setItem(e, t), t;
+}
+function Fe() {
+  try {
+    return localStorage.setItem("test", "test"), localStorage.removeItem("test"), !0;
+  } catch {
+    return !1;
+  }
+}
+const Ne = "blinkid-verify-userid";
+async function Ge(e, r) {
+  e.resourcesLocation ??= window.location.href;
+  const n = await Re(
+    e.resourcesLocation,
+    "blinkid-verify-worker.js"
+  );
+  e.userId ??= Oe(Ne);
+  const t = r ? q(r) : void 0;
+  try {
+    return await n.initBlinkIdVerify(
+      e,
+      t
+    ), n;
+  } catch (a) {
+    throw new Error("Failed to initialize BlinkID Verify", {
+      cause: a
+    });
+  }
+}
+function ze(e, r, n, t) {
+  return {
+    imageFront: P(e.frontFrame),
+    imageBack: P(e.backFrame),
+    imageBarcode: P(e.barcodeFrame),
+    options: {
+      treatExpirationAsFraud: n.treatExpirationAsFraud,
+      screenMatchLevel: h(n.screenAnalysisMatchLevel),
+      photocopyMatchLevel: t?.photocopyMatchLevel,
+      photoForgeryMatchLevel: t?.photoForgeryMatchLevel,
+      staticSecurityFeaturesMatchLevel: h(
+        n.staticSecurityFeaturesMatchLevel
+      ),
+      barcodeAnomalyMatchLevel: h(
+        n.barcodeAnomalyMatchLevel
+      ),
+      dataMatchMatchLevel: h(n.dataMatchMatchLevel),
+      blurMatchLevel: h(
+        n.imageQualitySettings?.blurMatchLevel
+      ),
+      glareMatchLevel: h(
+        n.imageQualitySettings?.glareMatchLevel
+      ),
+      lightingMatchLevel: h(
+        n.imageQualitySettings?.lightingMatchLevel
+      ),
+      sharpnessMatchLevel: h(
+        n.imageQualitySettings?.sharpnessMatchLevel
+      ),
+      handOcclusionMatchLevel: h(
+        n.imageQualitySettings?.handOcclusionMatchLevel
+      ),
+      dpiMatchLevel: h(
+        n.imageQualitySettings?.dpiMatchLevel
+      ),
+      tiltMatchLevel: h(
+        n.imageQualitySettings?.tiltMatchLevel
+      ),
+      imageQualityInterpretation: He(
+        n.imageQualitySettings?.interpretation
+      ),
+      anonymizationMode: t?.anonymizationMode,
+      returnFaceImage: t?.returnFaceImage,
+      returnFullDocumentImage: t?.returnFullDocumentImage,
+      returnSignatureImage: t?.returnSignatureImage,
+      returnImageFormat: t?.returnImageFormat,
+      generativeAiMatchLevel: t?.generativeAiMatchLevel
+    },
+    useCase: {
+      documentVerificationPolicy: Be(
+        n.useCase?.verificationPolicy
+      ),
+      verificationContext: je(
+        n.useCase?.verificationContext
+      ),
+      manualReviewStrategy: De(
+        n.useCase?.manualReviewStrategy
+      ),
+      manualReviewSensitivity: _e(
+        n.useCase?.manualReviewSensitivity
+      ),
+      captureConditions: Ue(
+        n.useCase?.captureConditions
+      )
+    },
+    captureSessionId: r
+  };
+}
+function _e(e) {
+  switch (e) {
+    case "low":
+      return "Low";
+    case "default":
+      return "Default";
+    case "high":
+      return "High";
+    default:
+      return;
+  }
+}
+function De(e) {
+  switch (e) {
+    case "never":
+      return "Never";
+    case "rejected-and-accepted":
+      return "RejectedAndAccepted";
+    case "rejected-only":
+      return "RejectedOnly";
+    case "accepted-only":
+      return "AcceptedOnly";
+    default:
+      return;
+  }
+}
+function Be(e) {
+  switch (e) {
+    case "permissive":
+      return "Permissive";
+    case "standard":
+      return "Standard";
+    case "strict":
+      return "Strict";
+    case "very-strict":
+      return "VeryStrict";
+    default:
+      return;
+  }
+}
+function He(e) {
+  switch (e) {
+    case "ignore":
+      return "Ignore";
+    case "conservative":
+      return "Conservative";
+    case "high-assurance":
+      return "HighAssurance";
+    case "high-conversion":
+      return "HighConversion";
+    case "very-high-conversion":
+      return "VeryHighConversion";
+    default:
+      return;
+  }
+}
+function je(e) {
+  switch (e) {
+    case "in-person":
+      return "InPerson";
+    case "remote":
+      return "Remote";
+    default:
+      return;
+  }
+}
+function Ue(e) {
+  switch (e) {
+    case "no-control":
+      return "NoControl";
+    case "basic":
+      return "Basic";
+    case "hybrid":
+      return "Hybrid";
+    default:
+      return;
+  }
+}
+function h(e) {
+  switch (e) {
+    case "disabled":
+      return "Disabled";
+    case "level-1":
+      return "Level1";
+    case "level-2":
+      return "Level2";
+    case "level-3":
+      return "Level3";
+    case "level-4":
+      return "Level4";
+    case "level-5":
+      return "Level5";
+    case "level-6":
+      return "Level6";
+    case "level-7":
+      return "Level7";
+    case "level-8":
+      return "Level8";
+    case "level-9":
+      return "Level9";
+    case "level-10":
+      return "Level10";
+    default:
+      return;
+  }
+}
+function P(e) {
+  if (e?.jpegBytes)
+    return {
+      base64: btoa(
+        new Uint8Array(e.jpegBytes).reduce(
+          (r, n) => r + String.fromCharCode(n),
+          ""
+        )
+      )
+    };
+}
+const K = Symbol();
+globalThis.__BLINKID_VERIFY_CORE__ ||= K;
+globalThis.__BLINKID_VERIFY_CORE__ !== K && console.warn(
+  "Detected multiple instances of @microblink/blinkid-core. This can lead to unexpected behavior."
+);
+export {
+  We as AnalyticService,
+  ze as GeneratePayloadForBlinkidVerifyRequest,
+  Pe as createDerivedDeviceInfo,
+  Re as createProxyWorker,
+  pe as getCrossOriginWorkerURL,
+  $e as getDeviceInfo,
+  Ie as getUserAgentData,
+  Oe as getUserId,
+  Ge as loadBlinkIdVerifyCore
+};