@microblink/blinkid-core 7.1.0 → 7.2.1

package/dist/blinkid-core.js

@@ -3,279 +3,380 @@
  * Copyright 2019 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-const j = Symbol("Comlink.proxy"), q = Symbol("Comlink.endpoint"), N = Symbol("Comlink.releaseProxy"), I = Symbol("Comlink.finalizer"), T = Symbol("Comlink.thrown"), U = (e) => typeof e == "object" && e !== null || typeof e == "function", G = {
-  canHandle: (e) => U(e) && e[j],
-  serialize(e) {
-    const { port1: r, port2: t } = new MessageChannel();
-    return V(e, r), [t, [t]];
+const proxyMarker = Symbol("Comlink.proxy");
+const createEndpoint = Symbol("Comlink.endpoint");
+const releaseProxy = Symbol("Comlink.releaseProxy");
+const finalizer = Symbol("Comlink.finalizer");
+const throwMarker = Symbol("Comlink.thrown");
+const isObject = (val) => typeof val === "object" && val !== null || typeof val === "function";
+const proxyTransferHandler = {
+  canHandle: (val) => isObject(val) && val[proxyMarker],
+  serialize(obj) {
+    const { port1, port2 } = new MessageChannel();
+    expose(obj, port1);
+    return [port2, [port2]];
   },
-  deserialize(e) {
-    return e.start(), B(e);
+  deserialize(port) {
+    port.start();
+    return wrap(port);
   }
-}, J = {
-  canHandle: (e) => U(e) && T 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, []];
+};
+const throwTransferHandler = {
+  canHandle: (value) => isObject(value) && throwMarker in value,
+  serialize({ value }) {
+    let serialized;
+    if (value instanceof Error) {
+      serialized = {
+        isError: true,
+        value: {
+          message: value.message,
+          name: value.name,
+          stack: value.stack
+        }
+      };
+    } else {
+      serialized = { isError: false, value };
+    }
+    return [serialized, []];
   },
-  deserialize(e) {
-    throw e.isError ? Object.assign(new Error(e.value.message), e.value) : e.value;
+  deserialize(serialized) {
+    if (serialized.isError) {
+      throw Object.assign(new Error(serialized.value.message), serialized.value);
+    }
+    throw serialized.value;
   }
-}, z = /* @__PURE__ */ new Map([
-  ["proxy", G],
-  ["throw", J]
+};
+const transferHandlers = /* @__PURE__ */ new Map([
+  ["proxy", proxyTransferHandler],
+  ["throw", throwTransferHandler]
 ]);
-function K(e, r) {
-  for (const t of e)
-    if (r === t || t === "*" || t instanceof RegExp && t.test(r))
-      return !0;
-  return !1;
+function isAllowedOrigin(allowedOrigins, origin) {
+  for (const allowedOrigin of allowedOrigins) {
+    if (origin === allowedOrigin || allowedOrigin === "*") {
+      return true;
+    }
+    if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+      return true;
+    }
+  }
+  return false;
 }
-function V(e, r = globalThis, t = ["*"]) {
-  r.addEventListener("message", function n(o) {
-    if (!o || !o.data)
+function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+  ep.addEventListener("message", function callback(ev) {
+    if (!ev || !ev.data) {
       return;
-    if (!K(t, o.origin)) {
-      console.warn(`Invalid origin '${o.origin}' for comlink proxy`);
+    }
+    if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+      console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
       return;
     }
-    const { id: a, type: i, path: s } = Object.assign({ path: [] }, o.data), c = (o.data.argumentList || []).map(w);
-    let u;
+    const { id, type: type2, path } = Object.assign({ path: [] }, ev.data);
+    const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+    let returnValue;
     try {
-      const l = s.slice(0, -1).reduce((f, E) => f[E], e), d = s.reduce((f, E) => f[E], e);
-      switch (i) {
+      const parent = path.slice(0, -1).reduce((obj2, prop) => obj2[prop], obj);
+      const rawValue = path.reduce((obj2, prop) => obj2[prop], obj);
+      switch (type2) {
         case "GET":
-          u = d;
+          {
+            returnValue = rawValue;
+          }
           break;
         case "SET":
-          l[s.slice(-1)[0]] = w(o.data.value), u = !0;
+          {
+            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+            returnValue = true;
+          }
           break;
         case "APPLY":
-          u = d.apply(l, c);
+          {
+            returnValue = rawValue.apply(parent, argumentList);
+          }
           break;
         case "CONSTRUCT":
           {
-            const f = new d(...c);
-            u = D(f);
+            const value = new rawValue(...argumentList);
+            returnValue = proxy(value);
           }
           break;
         case "ENDPOINT":
           {
-            const { port1: f, port2: E } = new MessageChannel();
-            V(e, E), u = ee(f, [f]);
+            const { port1, port2 } = new MessageChannel();
+            expose(obj, port2);
+            returnValue = transfer(port1, [port1]);
           }
           break;
         case "RELEASE":
-          u = void 0;
+          {
+            returnValue = void 0;
+          }
           break;
         default:
           return;
       }
-    } catch (l) {
-      u = { value: l, [T]: 0 };
+    } catch (value) {
+      returnValue = { value, [throwMarker]: 0 };
     }
-    Promise.resolve(u).catch((l) => ({ value: l, [T]: 0 })).then((l) => {
-      const [d, f] = A(l);
-      r.postMessage(Object.assign(Object.assign({}, d), { id: a }), f), i === "RELEASE" && (r.removeEventListener("message", n), _(r), I in e && typeof e[I] == "function" && e[I]());
-    }).catch((l) => {
-      const [d, f] = A({
+    Promise.resolve(returnValue).catch((value) => {
+      return { value, [throwMarker]: 0 };
+    }).then((returnValue2) => {
+      const [wireValue, transferables] = toWireValue(returnValue2);
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+      if (type2 === "RELEASE") {
+        ep.removeEventListener("message", callback);
+        closeEndPoint(ep);
+        if (finalizer in obj && typeof obj[finalizer] === "function") {
+          obj[finalizer]();
+        }
+      }
+    }).catch((error) => {
+      const [wireValue, transferables] = toWireValue({
         value: new TypeError("Unserializable return value"),
-        [T]: 0
+        [throwMarker]: 0
       });
-      r.postMessage(Object.assign(Object.assign({}, d), { id: a }), f);
+      ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
     });
-  }), r.start && r.start();
+  });
+  if (ep.start) {
+    ep.start();
+  }
 }
-function Y(e) {
-  return e.constructor.name === "MessagePort";
+function isMessagePort(endpoint) {
+  return endpoint.constructor.name === "MessagePort";
 }
-function _(e) {
-  Y(e) && e.close();
+function closeEndPoint(endpoint) {
+  if (isMessagePort(endpoint))
+    endpoint.close();
 }
-function B(e, r) {
-  const t = /* @__PURE__ */ new Map();
-  return e.addEventListener("message", function(o) {
-    const { data: a } = o;
-    if (!a || !a.id)
+function wrap(ep, target) {
+  const pendingListeners = /* @__PURE__ */ new Map();
+  ep.addEventListener("message", function handleMessage(ev) {
+    const { data } = ev;
+    if (!data || !data.id) {
       return;
-    const i = t.get(a.id);
-    if (i)
-      try {
-        i(a);
-      } finally {
-        t.delete(a.id);
-      }
-  }), P(e, t, [], r);
+    }
+    const resolver = pendingListeners.get(data.id);
+    if (!resolver) {
+      return;
+    }
+    try {
+      resolver(data);
+    } finally {
+      pendingListeners.delete(data.id);
+    }
+  });
+  return createProxy(ep, pendingListeners, [], target);
 }
-function v(e) {
-  if (e)
+function throwIfProxyReleased(isReleased) {
+  if (isReleased) {
     throw new Error("Proxy has been released and is not useable");
+  }
 }
-function H(e) {
-  return S(e, /* @__PURE__ */ new Map(), {
+function releaseEndpoint(ep) {
+  return requestResponseMessage(ep, /* @__PURE__ */ new Map(), {
     type: "RELEASE"
   }).then(() => {
-    _(e);
+    closeEndPoint(ep);
   });
 }
-const k = /* @__PURE__ */ new WeakMap(), R = "FinalizationRegistry" in globalThis && new FinalizationRegistry((e) => {
-  const r = (k.get(e) || 0) - 1;
-  k.set(e, r), r === 0 && H(e);
+const proxyCounter = /* @__PURE__ */ new WeakMap();
+const proxyFinalizers = "FinalizationRegistry" in globalThis && new FinalizationRegistry((ep) => {
+  const newCount = (proxyCounter.get(ep) || 0) - 1;
+  proxyCounter.set(ep, newCount);
+  if (newCount === 0) {
+    releaseEndpoint(ep);
+  }
 });
-function X(e, r) {
-  const t = (k.get(r) || 0) + 1;
-  k.set(r, t), R && R.register(e, r, e);
+function registerProxy(proxy2, ep) {
+  const newCount = (proxyCounter.get(ep) || 0) + 1;
+  proxyCounter.set(ep, newCount);
+  if (proxyFinalizers) {
+    proxyFinalizers.register(proxy2, ep, proxy2);
+  }
 }
-function Q(e) {
-  R && R.unregister(e);
+function unregisterProxy(proxy2) {
+  if (proxyFinalizers) {
+    proxyFinalizers.unregister(proxy2);
+  }
 }
-function P(e, r, t = [], n = function() {
+function createProxy(ep, pendingListeners, path = [], target = function() {
 }) {
-  let o = !1;
-  const a = new Proxy(n, {
-    get(i, s) {
-      if (v(o), s === N)
+  let isProxyReleased = false;
+  const proxy2 = new Proxy(target, {
+    get(_target, prop) {
+      throwIfProxyReleased(isProxyReleased);
+      if (prop === releaseProxy) {
         return () => {
-          Q(a), H(e), r.clear(), o = !0;
+          unregisterProxy(proxy2);
+          releaseEndpoint(ep);
+          pendingListeners.clear();
+          isProxyReleased = true;
         };
-      if (s === "then") {
-        if (t.length === 0)
-          return { then: () => a };
-        const c = S(e, r, {
+      }
+      if (prop === "then") {
+        if (path.length === 0) {
+          return { then: () => proxy2 };
+        }
+        const r = requestResponseMessage(ep, pendingListeners, {
           type: "GET",
-          path: t.map((u) => u.toString())
-        }).then(w);
-        return c.then.bind(c);
+          path: path.map((p) => p.toString())
+        }).then(fromWireValue);
+        return r.then.bind(r);
       }
-      return P(e, r, [...t, s]);
+      return createProxy(ep, pendingListeners, [...path, prop]);
     },
-    set(i, s, c) {
-      v(o);
-      const [u, l] = A(c);
-      return S(e, r, {
+    set(_target, prop, rawValue) {
+      throwIfProxyReleased(isProxyReleased);
+      const [value, transferables] = toWireValue(rawValue);
+      return requestResponseMessage(ep, pendingListeners, {
         type: "SET",
-        path: [...t, s].map((d) => d.toString()),
-        value: u
-      }, l).then(w);
+        path: [...path, prop].map((p) => p.toString()),
+        value
+      }, transferables).then(fromWireValue);
     },
-    apply(i, s, c) {
-      v(o);
-      const u = t[t.length - 1];
-      if (u === q)
-        return S(e, r, {
+    apply(_target, _thisArg, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const last = path[path.length - 1];
+      if (last === createEndpoint) {
+        return requestResponseMessage(ep, pendingListeners, {
           type: "ENDPOINT"
-        }).then(w);
-      if (u === "bind")
-        return P(e, r, t.slice(0, -1));
-      const [l, d] = x(c);
-      return S(e, r, {
+        }).then(fromWireValue);
+      }
+      if (last === "bind") {
+        return createProxy(ep, pendingListeners, path.slice(0, -1));
+      }
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
         type: "APPLY",
-        path: t.map((f) => f.toString()),
-        argumentList: l
-      }, d).then(w);
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
     },
-    construct(i, s) {
-      v(o);
-      const [c, u] = x(s);
-      return S(e, r, {
+    construct(_target, rawArgumentList) {
+      throwIfProxyReleased(isProxyReleased);
+      const [argumentList, transferables] = processArguments(rawArgumentList);
+      return requestResponseMessage(ep, pendingListeners, {
         type: "CONSTRUCT",
-        path: t.map((l) => l.toString()),
-        argumentList: c
-      }, u).then(w);
+        path: path.map((p) => p.toString()),
+        argumentList
+      }, transferables).then(fromWireValue);
     }
   });
-  return X(a, e), a;
+  registerProxy(proxy2, ep);
+  return proxy2;
 }
-function Z(e) {
-  return Array.prototype.concat.apply([], e);
+function myFlat(arr) {
+  return Array.prototype.concat.apply([], arr);
 }
-function x(e) {
-  const r = e.map(A);
-  return [r.map((t) => t[0]), Z(r.map((t) => t[1]))];
+function processArguments(argumentList) {
+  const processed = argumentList.map(toWireValue);
+  return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
 }
-const $ = /* @__PURE__ */ new WeakMap();
-function ee(e, r) {
-  return $.set(e, r), e;
+const transferCache = /* @__PURE__ */ new WeakMap();
+function transfer(obj, transfers) {
+  transferCache.set(obj, transfers);
+  return obj;
 }
-function D(e) {
-  return Object.assign(e, { [j]: !0 });
+function proxy(obj) {
+  return Object.assign(obj, { [proxyMarker]: true });
 }
-function A(e) {
-  for (const [r, t] of z)
-    if (t.canHandle(e)) {
-      const [n, o] = t.serialize(e);
+function toWireValue(value) {
+  for (const [name, handler] of transferHandlers) {
+    if (handler.canHandle(value)) {
+      const [serializedValue, transferables] = handler.serialize(value);
       return [
         {
           type: "HANDLER",
-          name: r,
-          value: n
+          name,
+          value: serializedValue
         },
-        o
+        transferables
       ];
     }
+  }
   return [
     {
       type: "RAW",
-      value: e
+      value
     },
-    $.get(e) || []
+    transferCache.get(value) || []
   ];
 }
-function w(e) {
-  switch (e.type) {
+function fromWireValue(value) {
+  switch (value.type) {
     case "HANDLER":
-      return z.get(e.name).deserialize(e.value);
+      return transferHandlers.get(value.name).deserialize(value.value);
     case "RAW":
-      return e.value;
+      return value.value;
   }
 }
-function S(e, r, t, n) {
-  return new Promise((o) => {
-    const a = re();
-    r.set(a, o), e.start && e.start(), e.postMessage(Object.assign({ id: a }, t), n);
+function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+  return new Promise((resolve) => {
+    const id = generateUUID();
+    pendingListeners.set(id, resolve);
+    if (ep.start) {
+      ep.start();
+    }
+    ep.postMessage(Object.assign({ id }, msg), transfers);
   });
 }
-function re() {
+function generateUUID() {
   return new Array(4).fill(0).map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16)).join("-");
 }
-var te = /* @__PURE__ */ function() {
-  function e(r, t) {
-    for (var n = 0; n < t.length; n++) {
-      var o = t[n];
-      o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(r, o.key, o);
+var _createClass = /* @__PURE__ */ function() {
+  function defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
     }
   }
-  return function(r, t, n) {
-    return t && e(r.prototype, t), n && e(r, n), r;
+  return function(Constructor, protoProps, staticProps) {
+    if (protoProps) defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) defineProperties(Constructor, staticProps);
+    return Constructor;
   };
-}(), ne = oe(["", ""], ["", ""]);
-function oe(e, r) {
-  return Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(r) } }));
+}();
+var _templateObject = _taggedTemplateLiteral(["", ""], ["", ""]);
+function _taggedTemplateLiteral(strings, raw) {
+  return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } }));
 }
-function ae(e, r) {
-  if (!(e instanceof r))
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
     throw new TypeError("Cannot call a class as a function");
+  }
 }
-var m = function() {
-  function e() {
-    for (var r = this, t = arguments.length, n = Array(t), o = 0; o < t; o++)
-      n[o] = arguments[o];
-    return ae(this, e), this.tag = function(a) {
-      for (var i = arguments.length, s = Array(i > 1 ? i - 1 : 0), c = 1; c < i; c++)
-        s[c - 1] = arguments[c];
-      return typeof a == "function" ? r.interimTag.bind(r, a) : typeof a == "string" ? r.transformEndResult(a) : (a = a.map(r.transformString.bind(r)), r.transformEndResult(a.reduce(r.processSubstitutions.bind(r, s))));
-    }, n.length > 0 && Array.isArray(n[0]) && (n = n[0]), this.transformers = n.map(function(a) {
-      return typeof a == "function" ? a() : a;
-    }), this.tag;
+var TemplateTag = function() {
+  function TemplateTag2() {
+    var _this = this;
+    for (var _len = arguments.length, transformers = Array(_len), _key = 0; _key < _len; _key++) {
+      transformers[_key] = arguments[_key];
+    }
+    _classCallCheck(this, TemplateTag2);
+    this.tag = function(strings) {
+      for (var _len2 = arguments.length, expressions = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        expressions[_key2 - 1] = arguments[_key2];
+      }
+      if (typeof strings === "function") {
+        return _this.interimTag.bind(_this, strings);
+      }
+      if (typeof strings === "string") {
+        return _this.transformEndResult(strings);
+      }
+      strings = strings.map(_this.transformString.bind(_this));
+      return _this.transformEndResult(strings.reduce(_this.processSubstitutions.bind(_this, expressions)));
+    };
+    if (transformers.length > 0 && Array.isArray(transformers[0])) {
+      transformers = transformers[0];
+    }
+    this.transformers = transformers.map(function(transformer) {
+      return typeof transformer === "function" ? transformer() : transformer;
+    });
+    return this.tag;
   }
-  return te(e, [{
+  _createClass(TemplateTag2, [{
     key: "interimTag",
     /**
      * An intermediary template tag that receives a template tag and passes the result of calling the template with the received
@@ -285,10 +386,11 @@ var m = function() {
      * @param  {...*}            ...substitutions - `substitutions` is an array of all substitutions in the template
      * @return {*}                                - the final processed value
      */
-    value: function(t, n) {
-      for (var o = arguments.length, a = Array(o > 2 ? o - 2 : 0), i = 2; i < o; i++)
-        a[i - 2] = arguments[i];
-      return this.tag(ne, t.apply(void 0, [n].concat(a)));
+    value: function interimTag(previousTag, template) {
+      for (var _len3 = arguments.length, substitutions = Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+        substitutions[_key3 - 2] = arguments[_key3];
+      }
+      return this.tag(_templateObject, previousTag.apply(void 0, [template].concat(substitutions)));
     }
     /**
      * Performs bulk processing on the tagged template, transforming each substitution and then
@@ -300,9 +402,9 @@ var m = function() {
      */
   }, {
     key: "processSubstitutions",
-    value: function(t, n, o) {
-      var a = this.transformSubstitution(t.shift(), n);
-      return "".concat(n, a, o);
+    value: function processSubstitutions(substitutions, resultSoFar, remainingPart) {
+      var substitution = this.transformSubstitution(substitutions.shift(), resultSoFar);
+      return "".concat(resultSoFar, substitution, remainingPart);
     }
     /**
      * Iterate through each transformer, applying the transformer's `onString` method to the template
@@ -312,11 +414,11 @@ var m = function() {
      */
   }, {
     key: "transformString",
-    value: function(t) {
-      var n = function(a, i) {
-        return i.onString ? i.onString(a) : a;
+    value: function transformString(str) {
+      var cb = function cb2(res, transform) {
+        return transform.onString ? transform.onString(res) : res;
       };
-      return this.transformers.reduce(n, t);
+      return this.transformers.reduce(cb, str);
     }
     /**
      * When a substitution is encountered, iterates through each transformer and applies the transformer's
@@ -327,11 +429,11 @@ var m = function() {
      */
   }, {
     key: "transformSubstitution",
-    value: function(t, n) {
-      var o = function(i, s) {
-        return s.onSubstitution ? s.onSubstitution(i, n) : i;
+    value: function transformSubstitution(substitution, resultSoFar) {
+      var cb = function cb2(res, transform) {
+        return transform.onSubstitution ? transform.onSubstitution(res, resultSoFar) : res;
       };
-      return this.transformers.reduce(o, t);
+      return this.transformers.reduce(cb, substitution);
     }
     /**
      * Iterates through each transformer, applying the transformer's `onEndResult` method to the
@@ -341,240 +443,369 @@ var m = function() {
      */
   }, {
     key: "transformEndResult",
-    value: function(t) {
-      var n = function(a, i) {
-        return i.onEndResult ? i.onEndResult(a) : a;
+    value: function transformEndResult(endResult) {
+      var cb = function cb2(res, transform) {
+        return transform.onEndResult ? transform.onEndResult(res) : res;
       };
-      return this.transformers.reduce(n, t);
+      return this.transformers.reduce(cb, endResult);
     }
-  }]), e;
-}(), g = function() {
-  var r = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
+  }]);
+  return TemplateTag2;
+}();
+var trimResultTransformer = function trimResultTransformer2() {
+  var side = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
   return {
-    onEndResult: function(n) {
-      if (r === "")
-        return n.trim();
-      if (r = r.toLowerCase(), r === "start" || r === "left")
-        return n.replace(/^\s*/, "");
-      if (r === "end" || r === "right")
-        return n.replace(/\s*$/, "");
-      throw new Error("Side not supported: " + r);
+    onEndResult: function onEndResult(endResult) {
+      if (side === "") {
+        return endResult.trim();
+      }
+      side = side.toLowerCase();
+      if (side === "start" || side === "left") {
+        return endResult.replace(/^\s*/, "");
+      }
+      if (side === "end" || side === "right") {
+        return endResult.replace(/\s*$/, "");
+      }
+      throw new Error("Side not supported: " + side);
     }
   };
 };
-function ie(e) {
-  if (Array.isArray(e)) {
-    for (var r = 0, t = Array(e.length); r < e.length; r++)
-      t[r] = e[r];
-    return t;
-  } else
-    return Array.from(e);
+function _toConsumableArray(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+    return arr2;
+  } else {
+    return Array.from(arr);
+  }
 }
-var p = function() {
-  var r = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "initial";
+var stripIndentTransformer = function stripIndentTransformer2() {
+  var type2 = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "initial";
   return {
-    onEndResult: function(n) {
-      if (r === "initial") {
-        var o = n.match(/^[^\S\n]*(?=\S)/gm), a = o && Math.min.apply(Math, ie(o.map(function(s) {
-          return s.length;
+    onEndResult: function onEndResult(endResult) {
+      if (type2 === "initial") {
+        var match = endResult.match(/^[^\S\n]*(?=\S)/gm);
+        var indent = match && Math.min.apply(Math, _toConsumableArray(match.map(function(el) {
+          return el.length;
         })));
-        if (a) {
-          var i = new RegExp("^.{" + a + "}", "gm");
-          return n.replace(i, "");
+        if (indent) {
+          var regexp = new RegExp("^.{" + indent + "}", "gm");
+          return endResult.replace(regexp, "");
         }
-        return n;
+        return endResult;
+      }
+      if (type2 === "all") {
+        return endResult.replace(/^[^\S\n]+/gm, "");
       }
-      if (r === "all")
-        return n.replace(/^[^\S\n]+/gm, "");
-      throw new Error("Unknown type: " + r);
+      throw new Error("Unknown type: " + type2);
     }
   };
-}, b = function(r, t) {
+};
+var replaceResultTransformer = function replaceResultTransformer2(replaceWhat, replaceWith) {
   return {
-    onEndResult: function(o) {
-      if (r == null || t == null)
+    onEndResult: function onEndResult(endResult) {
+      if (replaceWhat == null || replaceWith == null) {
         throw new Error("replaceResultTransformer requires at least 2 arguments.");
-      return o.replace(r, t);
+      }
+      return endResult.replace(replaceWhat, replaceWith);
     }
   };
-}, y = function(r, t) {
+};
+var replaceSubstitutionTransformer = function replaceSubstitutionTransformer2(replaceWhat, replaceWith) {
   return {
-    onSubstitution: function(o, a) {
-      if (r == null || t == null)
+    onSubstitution: function onSubstitution(substitution, resultSoFar) {
+      if (replaceWhat == null || replaceWith == null) {
         throw new Error("replaceSubstitutionTransformer requires at least 2 arguments.");
-      return o == null ? o : o.toString().replace(r, t);
+      }
+      if (substitution == null) {
+        return substitution;
+      } else {
+        return substitution.toString().replace(replaceWhat, replaceWith);
+      }
     }
   };
-}, se = {
+};
+var defaults = {
   separator: "",
   conjunction: "",
-  serial: !1
-}, h = function() {
-  var r = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : se;
+  serial: false
+};
+var inlineArrayTransformer = function inlineArrayTransformer2() {
+  var opts = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : defaults;
   return {
-    onSubstitution: function(n, o) {
-      if (Array.isArray(n)) {
-        var a = n.length, i = r.separator, s = r.conjunction, c = r.serial, u = o.match(/(\n?[^\S\n]+)$/);
-        if (u ? n = n.join(i + u[1]) : n = n.join(i + " "), s && a > 1) {
-          var l = n.lastIndexOf(i);
-          n = n.slice(0, l) + (c ? i : "") + " " + s + n.slice(l + 1);
+    onSubstitution: function onSubstitution(substitution, resultSoFar) {
+      if (Array.isArray(substitution)) {
+        var arrayLength = substitution.length;
+        var separator = opts.separator;
+        var conjunction = opts.conjunction;
+        var serial = opts.serial;
+        var indent = resultSoFar.match(/(\n?[^\S\n]+)$/);
+        if (indent) {
+          substitution = substitution.join(separator + indent[1]);
+        } else {
+          substitution = substitution.join(separator + " ");
+        }
+        if (conjunction && arrayLength > 1) {
+          var separatorIndex = substitution.lastIndexOf(separator);
+          substitution = substitution.slice(0, separatorIndex) + (serial ? separator : "") + " " + conjunction + substitution.slice(separatorIndex + 1);
         }
       }
-      return n;
+      return substitution;
     }
   };
-}, F = function(r) {
+};
+var splitStringTransformer = function splitStringTransformer2(splitBy) {
   return {
-    onSubstitution: function(n, o) {
-      return typeof n == "string" && n.includes(r) && (n = n.split(r)), n;
+    onSubstitution: function onSubstitution(substitution, resultSoFar) {
+      {
+        if (typeof substitution === "string" && substitution.includes(splitBy)) {
+          substitution = substitution.split(splitBy);
+        }
+      }
+      return substitution;
     }
   };
-}, L = function(r) {
-  return r != null && !Number.isNaN(r) && typeof r != "boolean";
-}, ue = function() {
+};
+var isValidValue = function isValidValue2(x) {
+  return x != null && !Number.isNaN(x) && typeof x !== "boolean";
+};
+var removeNonPrintingValuesTransformer = function removeNonPrintingValuesTransformer2() {
   return {
-    onSubstitution: function(t) {
-      return Array.isArray(t) ? t.filter(L) : L(t) ? t : "";
+    onSubstitution: function onSubstitution(substitution) {
+      if (Array.isArray(substitution)) {
+        return substitution.filter(isValidValue);
+      }
+      if (isValidValue(substitution)) {
+        return substitution;
+      }
+      return "";
     }
   };
 };
-new m(h({ separator: "," }), p, g);
-new m(h({ separator: ",", conjunction: "and" }), p, g);
-new m(h({ separator: ",", conjunction: "or" }), p, g);
-new m(F(`
-`), ue, h, p, g);
-new m(F(`
-`), h, p, g, y(/&/g, "&amp;"), y(/</g, "&lt;"), y(/>/g, "&gt;"), y(/"/g, "&quot;"), y(/'/g, "&#x27;"), y(/`/g, "&#x60;"));
-new m(b(/(?:\n(?:\s*))+/g, " "), g);
-var ce = new m(b(/(?:\n\s*)/g, ""), g);
-new m(h({ separator: "," }), b(/(?:\s+)/g, " "), g);
-new m(h({ separator: ",", conjunction: "or" }), b(/(?:\s+)/g, " "), g);
-new m(h({ separator: ",", conjunction: "and" }), b(/(?:\s+)/g, " "), g);
-new m(h, p, g);
-new m(h, b(/(?:\s+)/g, " "), g);
-new m(p, g);
-var le = new m(p("all"), g);
-const O = "application/javascript", fe = (e, r = {}) => {
-  const t = {
-    skipSameOrigin: !0,
-    useBlob: !0,
-    ...r
+new TemplateTag(inlineArrayTransformer({ separator: "," }), stripIndentTransformer, trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: ",", conjunction: "and" }), stripIndentTransformer, trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: ",", conjunction: "or" }), stripIndentTransformer, trimResultTransformer);
+new TemplateTag(splitStringTransformer("\n"), removeNonPrintingValuesTransformer, inlineArrayTransformer, stripIndentTransformer, trimResultTransformer);
+new TemplateTag(splitStringTransformer("\n"), inlineArrayTransformer, stripIndentTransformer, trimResultTransformer, replaceSubstitutionTransformer(/&/g, "&amp;"), replaceSubstitutionTransformer(/</g, "&lt;"), replaceSubstitutionTransformer(/>/g, "&gt;"), replaceSubstitutionTransformer(/"/g, "&quot;"), replaceSubstitutionTransformer(/'/g, "&#x27;"), replaceSubstitutionTransformer(/`/g, "&#x60;"));
+new TemplateTag(replaceResultTransformer(/(?:\n(?:\s*))+/g, " "), trimResultTransformer);
+var oneLineTrim = new TemplateTag(replaceResultTransformer(/(?:\n\s*)/g, ""), trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: "," }), replaceResultTransformer(/(?:\s+)/g, " "), trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: ",", conjunction: "or" }), replaceResultTransformer(/(?:\s+)/g, " "), trimResultTransformer);
+new TemplateTag(inlineArrayTransformer({ separator: ",", conjunction: "and" }), replaceResultTransformer(/(?:\s+)/g, " "), trimResultTransformer);
+new TemplateTag(inlineArrayTransformer, stripIndentTransformer, trimResultTransformer);
+new TemplateTag(inlineArrayTransformer, replaceResultTransformer(/(?:\s+)/g, " "), trimResultTransformer);
+new TemplateTag(stripIndentTransformer, trimResultTransformer);
+var stripIndents = new TemplateTag(stripIndentTransformer("all"), trimResultTransformer);
+const type = "application/javascript";
+const getCrossOriginWorkerURL = (originalWorkerUrl, _options = {}) => {
+  const options = {
+    skipSameOrigin: true,
+    useBlob: true,
+    ..._options
   };
-  if (t.skipSameOrigin && new URL(e).origin === self.location.origin)
-    return Promise.resolve(e);
-  let n;
+  if (options.skipSameOrigin && new URL(originalWorkerUrl).origin === self.location.origin) {
+    return Promise.resolve(originalWorkerUrl);
+  }
+  let signal;
   try {
-    const o = new AbortController();
-    n = o.signal;
-    const a = setTimeout(() => {
-      o.abort();
-    }, 3e3), i = () => {
-      clearTimeout(a), o.abort();
+    const controller = new AbortController();
+    signal = controller.signal;
+    const timeout = setTimeout(() => {
+      controller.abort();
+    }, 3e3);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      controller.abort();
     };
-    n.addEventListener("abort", i);
-  } catch {
+    signal.addEventListener("abort", cleanup);
+  } catch (error) {
   }
   return new Promise(
-    (o, a) => void fetch(e, {
+    (resolve, reject) => void fetch(originalWorkerUrl, {
       // abort if the worker is not fetched in a reasonable time
-      signal: n
-    }).then((i) => i.text()).then((i) => {
-      const s = new URL(e).href.split("/");
-      s.pop();
-      const c = le`
+      signal
+    }).then((res) => res.text()).then((codeString) => {
+      const workerPath = new URL(originalWorkerUrl).href.split("/");
+      workerPath.pop();
+      const importScriptsFix = stripIndents`
             const _importScripts = importScripts;
-            const _fixImports = (url) => new URL(url, '${s.join("/") + "/"}').href;
+            const _fixImports = (url) => new URL(url, '${workerPath.join("/") + "/"}').href;
             importScripts = (...urls) => _importScripts(...urls.map(_fixImports));
           `;
-      let u = "";
-      if (t.useBlob) {
-        const l = new Blob([c + i], { type: O });
-        u = URL.createObjectURL(l);
-      } else
-        u = `data:${O},` + encodeURIComponent(c + i);
-      o(u);
+      let finalURL = "";
+      if (options.useBlob) {
+        const blob = new Blob([importScriptsFix + codeString], { type });
+        finalURL = URL.createObjectURL(blob);
+      } else {
+        finalURL = `data:${type},` + encodeURIComponent(importScriptsFix + codeString);
+      }
+      resolve(finalURL);
     }).catch(() => {
-      a(new Error(`Failed to fetch worker from ${e}`));
+      reject(new Error(`Failed to fetch worker from ${originalWorkerUrl}`));
     })
   );
-}, me = async (e = window.location.href) => {
-  const r = await fe(
-    new URL("resources/blinkid-worker.js", e).toString()
-  ), t = await fetch(r, { method: "HEAD" }), n = t.headers.get("content-type"), o = n?.includes("javascript");
-  if (n?.includes("html"))
+};
+const createProxyWorker = async (resourcesLocation = window.location.href) => {
+  const workerUrl = await getCrossOriginWorkerURL(
+    new URL("resources/blinkid-worker.js", resourcesLocation).toString()
+  );
+  const response = await fetch(workerUrl, { method: "HEAD" });
+  const contentType = response.headers.get("content-type");
+  const isJavascript = contentType?.includes("javascript");
+  const isHtml = contentType?.includes("html");
+  if (isHtml) {
     throw new Error(
-      ce`${r} resolved to a resource with the content type ${n}.
+      oneLineTrim`${workerUrl} resolved to a resource with the content type ${contentType}.
       This is likely an issue with the server configuration redirecting to an index.html file.
       Check that your resources are properly hosted`
     );
-  if (!o)
-    throw new Error(`Worker file is not a JavaScript file: ${n}`);
-  if (!t.ok)
+  }
+  if (!isJavascript) {
+    throw new Error(`Worker file is not a JavaScript file: ${contentType}`);
+  }
+  if (!response.ok) {
     throw new Error(
-      `Worker file not found or inaccessible: ${t.status} ${t.statusText}`
+      `Worker file not found or inaccessible: ${response.status} ${response.statusText}`
     );
-  const i = new Worker(r, {
+  }
+  const worker = new Worker(workerUrl, {
     type: "module"
   });
-  i.onerror = (c) => {
-    console.error("Worker error:", c), s[N]();
+  worker.onerror = (e) => {
+    console.error("Worker error:", e);
+    proxyWorker[releaseProxy]();
   };
-  const s = B(i);
-  return s;
+  const proxyWorker = wrap(worker);
+  return proxyWorker;
 };
-let C = (e = 21) => crypto.getRandomValues(new Uint8Array(e)).reduce((r, t) => (t &= 63, t < 36 ? r += t.toString(36) : t < 62 ? r += (t - 26).toString(36).toUpperCase() : t > 62 ? r += "-" : r += "_", r), "");
-const M = "blinkid-userid";
-function ge() {
-  if (!de())
-    return C();
-  const r = localStorage.getItem(M);
-  if (r)
-    return r;
-  const t = C();
-  return localStorage.setItem(M, t), t;
+let nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+  byte &= 63;
+  if (byte < 36) {
+    id += byte.toString(36);
+  } else if (byte < 62) {
+    id += (byte - 26).toString(36).toUpperCase();
+  } else if (byte > 62) {
+    id += "-";
+  } else {
+    id += "_";
+  }
+  return id;
+}, "");
+const key = "blinkid-userid";
+function getUserId() {
+  const hasLocalStorage = testLocalStorage();
+  if (!hasLocalStorage) {
+    return nanoid();
+  }
+  const previousId = localStorage.getItem(key);
+  if (previousId) {
+    return previousId;
+  }
+  const randomId = nanoid();
+  localStorage.setItem(key, randomId);
+  return randomId;
 }
-function de() {
+function testLocalStorage() {
   try {
-    return localStorage.setItem("test", "test"), localStorage.removeItem("test"), !0;
+    localStorage.setItem("test", "test");
+    localStorage.removeItem("test");
+    return true;
   } catch {
-    return !1;
+    return false;
   }
 }
-async function he(e, r) {
-  const t = await me(e.resourcesLocation);
-  e.userId || (e.userId = ge()), e.resourcesLocation || (e.resourcesLocation = window.location.href), e.useLightweightBuild === void 0 && (e.useLightweightBuild = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
-    navigator.userAgent
-  ));
-  const n = r ? D(r) : void 0;
+const defaultSessionSettings = {
+  inputImageSource: "video",
+  scanningMode: "automatic",
+  scanningSettings: {
+    allowUncertainFrontSideScan: false,
+    blurDetectionLevel: "mid",
+    glareDetectionLevel: "mid",
+    tiltDetectionLevel: "mid",
+    skipImagesWithBlur: true,
+    skipImagesWithGlare: true,
+    skipImagesOccludedByHand: true,
+    skipImagesWithInadequateLightingConditions: true,
+    combineResultsFromMultipleInputImages: true,
+    croppedImageSettings: {
+      dotsPerInch: 250,
+      extensionFactor: 0,
+      returnDocumentImage: false,
+      returnFaceImage: false,
+      returnSignatureImage: false
+    },
+    customDocumentAnonymizationSettings: [],
+    customDocumentRules: [],
+    enableBarcodeScanOnly: false,
+    enableCharacterValidation: true,
+    inputImageMargin: 0.02,
+    maxAllowedMismatchesPerField: 0,
+    recognitionModeFilter: {
+      enableBarcodeId: true,
+      enableFullDocumentRecognition: true,
+      enableMrzId: true,
+      enableMrzPassport: true,
+      enableMrzVisa: true,
+      enablePhotoId: true
+    },
+    returnInputImages: false,
+    scanCroppedDocumentImage: false,
+    scanPassportDataPageOnly: true,
+    scanUnsupportedBack: false,
+    anonymizationMode: "full-result"
+  }
+};
+async function loadBlinkIdCore(settings, progressCallback) {
+  const remoteWorker = await createProxyWorker(settings.resourcesLocation);
+  if (!settings.userId) {
+    settings.userId = getUserId();
+  }
+  if (!settings.resourcesLocation) {
+    settings.resourcesLocation = window.location.href;
+  }
+  if (settings.useLightweightBuild === void 0) {
+    settings.useLightweightBuild = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(
+      navigator.userAgent
+    );
+  }
+  const proxyProgressCallback = progressCallback ? proxy(progressCallback) : void 0;
   try {
-    return await t.initBlinkId(
-      e,
-      n
-    ), t;
-  } catch (o) {
+    await remoteWorker.initBlinkId(
+      settings,
+      defaultSessionSettings,
+      proxyProgressCallback
+    );
+    return remoteWorker;
+  } catch (error) {
     throw new Error("Failed to initialize BlinkID", {
-      cause: o
+      cause: error
     });
   }
 }
-function pe(e) {
-  return {
-    data: e.data,
-    width: e.width,
-    height: e.height,
-    colorSpace: e.colorSpace
+function createCustomImageData(imageData) {
+  const customImageData = {
+    data: imageData.data,
+    width: imageData.width,
+    height: imageData.height,
+    colorSpace: imageData.colorSpace
   };
+  return customImageData;
+}
+const testSymbol = Symbol();
+globalThis.__BLINKID_CORE__ ||= testSymbol;
+if (globalThis.__BLINKID_CORE__ !== testSymbol) {
+  console.warn(
+    "Detected multiple instances of @microblink/blinkid-core. This can lead to unexpected behavior."
+  );
 }
-const W = Symbol();
-globalThis.__BLINKID_CORE__ ||= W;
-globalThis.__BLINKID_CORE__ !== W && console.warn(
-  "Detected multiple instances of @microblink/blinkid-core. This can lead to unexpected behavior."
-);
 export {
-  pe as createCustomImageData,
-  me as createProxyWorker,
-  fe as getCrossOriginWorkerURL,
-  ge as getUserId,
-  he as loadBlinkIdCore,
-  de as testLocalStorage
+  createCustomImageData,
+  createProxyWorker,
+  defaultSessionSettings,
+  getCrossOriginWorkerURL,
+  getUserId,
+  loadBlinkIdCore,
+  testLocalStorage
 };
+//# sourceMappingURL=blinkid-core.js.map