@richard.fadiora/liveness-detection 4.2.13 → 4.3.0

package/dist/index.js

@@ -0,0 +1,645 @@
+import { verifyLiveness as bt } from "./api-BpiDoGOd.js";
+import { L as k } from "./LivenessCheck-DxxnvHvi.js";
+import { a as _t, u as St } from "./LivenessCheck-DxxnvHvi.js";
+import { Injectable as W, ViewChild as K, Input as l, Output as H, Component as q, EventEmitter as A } from "@angular/core";
+import { CommonModule as G } from "@angular/common";
+var w = function(e, r) {
+  return w = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(t, n) {
+    t.__proto__ = n;
+  } || function(t, n) {
+    for (var o in n) Object.prototype.hasOwnProperty.call(n, o) && (t[o] = n[o]);
+  }, w(e, r);
+};
+function d(e, r) {
+  if (typeof r != "function" && r !== null)
+    throw new TypeError("Class extends value " + String(r) + " is not a constructor or null");
+  w(e, r);
+  function t() {
+    this.constructor = e;
+  }
+  e.prototype = r === null ? Object.create(r) : (t.prototype = r.prototype, new t());
+}
+function E(e) {
+  var r = typeof Symbol == "function" && Symbol.iterator, t = r && e[r], n = 0;
+  if (t) return t.call(e);
+  if (e && typeof e.length == "number") return {
+    next: function() {
+      return e && n >= e.length && (e = void 0), { value: e && e[n++], done: !e };
+    }
+  };
+  throw new TypeError(r ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function O(e, r) {
+  var t = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!t) return e;
+  var n = t.call(e), o, i = [], s;
+  try {
+    for (; (r === void 0 || r-- > 0) && !(o = n.next()).done; ) i.push(o.value);
+  } catch (c) {
+    s = { error: c };
+  } finally {
+    try {
+      o && !o.done && (t = n.return) && t.call(n);
+    } finally {
+      if (s) throw s.error;
+    }
+  }
+  return i;
+}
+function C(e, r, t) {
+  if (t || arguments.length === 2) for (var n = 0, o = r.length, i; n < o; n++)
+    (i || !(n in r)) && (i || (i = Array.prototype.slice.call(r, 0, n)), i[n] = r[n]);
+  return e.concat(i || Array.prototype.slice.call(r));
+}
+function f(e) {
+  return typeof e == "function";
+}
+function R(e) {
+  var r = function(n) {
+    Error.call(n), n.stack = new Error().stack;
+  }, t = e(r);
+  return t.prototype = Object.create(Error.prototype), t.prototype.constructor = t, t;
+}
+var g = R(function(e) {
+  return function(t) {
+    e(this), this.message = t ? t.length + ` errors occurred during unsubscription:
+` + t.map(function(n, o) {
+      return o + 1 + ") " + n.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = t;
+  };
+});
+function x(e, r) {
+  if (e) {
+    var t = e.indexOf(r);
+    0 <= t && e.splice(t, 1);
+  }
+}
+var _ = function() {
+  function e(r) {
+    this.initialTeardown = r, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var r, t, n, o, i;
+    if (!this.closed) {
+      this.closed = !0;
+      var s = this._parentage;
+      if (s)
+        if (this._parentage = null, Array.isArray(s))
+          try {
+            for (var c = E(s), p = c.next(); !p.done; p = c.next()) {
+              var S = p.value;
+              S.remove(this);
+            }
+          } catch (h) {
+            r = { error: h };
+          } finally {
+            try {
+              p && !p.done && (t = c.return) && t.call(c);
+            } finally {
+              if (r) throw r.error;
+            }
+          }
+        else
+          s.remove(this);
+      var j = this.initialTeardown;
+      if (f(j))
+        try {
+          j();
+        } catch (h) {
+          i = h instanceof g ? h.errors : [h];
+        }
+      var P = this._finalizers;
+      if (P) {
+        this._finalizers = null;
+        try {
+          for (var y = E(P), v = y.next(); !v.done; v = y.next()) {
+            var $ = v.value;
+            try {
+              I($);
+            } catch (h) {
+              i = i ?? [], h instanceof g ? i = C(C([], O(i)), O(h.errors)) : i.push(h);
+            }
+          }
+        } catch (h) {
+          n = { error: h };
+        } finally {
+          try {
+            v && !v.done && (o = y.return) && o.call(y);
+          } finally {
+            if (n) throw n.error;
+          }
+        }
+      }
+      if (i)
+        throw new g(i);
+    }
+  }, e.prototype.add = function(r) {
+    var t;
+    if (r && r !== this)
+      if (this.closed)
+        I(r);
+      else {
+        if (r instanceof e) {
+          if (r.closed || r._hasParent(this))
+            return;
+          r._addParent(this);
+        }
+        (this._finalizers = (t = this._finalizers) !== null && t !== void 0 ? t : []).push(r);
+      }
+  }, e.prototype._hasParent = function(r) {
+    var t = this._parentage;
+    return t === r || Array.isArray(t) && t.includes(r);
+  }, e.prototype._addParent = function(r) {
+    var t = this._parentage;
+    this._parentage = Array.isArray(t) ? (t.push(r), t) : t ? [t, r] : r;
+  }, e.prototype._removeParent = function(r) {
+    var t = this._parentage;
+    t === r ? this._parentage = null : Array.isArray(t) && x(t, r);
+  }, e.prototype.remove = function(r) {
+    var t = this._finalizers;
+    t && x(t, r), r instanceof e && r._removeParent(this);
+  }, e.EMPTY = function() {
+    var r = new e();
+    return r.closed = !0, r;
+  }(), e;
+}(), V = _.EMPTY;
+function F(e) {
+  return e instanceof _ || e && "closed" in e && f(e.remove) && f(e.add) && f(e.unsubscribe);
+}
+function I(e) {
+  f(e) ? e() : e.unsubscribe();
+}
+var J = {
+  Promise: void 0
+}, Q = {
+  setTimeout: function(e, r) {
+    for (var t = [], n = 2; n < arguments.length; n++)
+      t[n - 2] = arguments[n];
+    return setTimeout.apply(void 0, C([e, r], O(t)));
+  },
+  clearTimeout: function(e) {
+    return clearTimeout(e);
+  },
+  delegate: void 0
+};
+function X(e) {
+  Q.setTimeout(function() {
+    throw e;
+  });
+}
+function U() {
+}
+function m(e) {
+  e();
+}
+var Y = function(e) {
+  d(r, e);
+  function r(t) {
+    var n = e.call(this) || this;
+    return n.isStopped = !1, t ? (n.destination = t, F(t) && t.add(n)) : n.destination = tt, n;
+  }
+  return r.create = function(t, n, o) {
+    return new T(t, n, o);
+  }, r.prototype.next = function(t) {
+    this.isStopped || this._next(t);
+  }, r.prototype.error = function(t) {
+    this.isStopped || (this.isStopped = !0, this._error(t));
+  }, r.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, r.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+  }, r.prototype._next = function(t) {
+    this.destination.next(t);
+  }, r.prototype._error = function(t) {
+    try {
+      this.destination.error(t);
+    } finally {
+      this.unsubscribe();
+    }
+  }, r.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, r;
+}(_), z = function() {
+  function e(r) {
+    this.partialObserver = r;
+  }
+  return e.prototype.next = function(r) {
+    var t = this.partialObserver;
+    if (t.next)
+      try {
+        t.next(r);
+      } catch (n) {
+        b(n);
+      }
+  }, e.prototype.error = function(r) {
+    var t = this.partialObserver;
+    if (t.error)
+      try {
+        t.error(r);
+      } catch (n) {
+        b(n);
+      }
+    else
+      b(r);
+  }, e.prototype.complete = function() {
+    var r = this.partialObserver;
+    if (r.complete)
+      try {
+        r.complete();
+      } catch (t) {
+        b(t);
+      }
+  }, e;
+}(), T = function(e) {
+  d(r, e);
+  function r(t, n, o) {
+    var i = e.call(this) || this, s;
+    return f(t) || !t ? s = {
+      next: t ?? void 0,
+      error: n ?? void 0,
+      complete: o ?? void 0
+    } : s = t, i.destination = new z(s), i;
+  }
+  return r;
+}(Y);
+function b(e) {
+  X(e);
+}
+function N(e) {
+  throw e;
+}
+var tt = {
+  closed: !0,
+  next: U,
+  error: N,
+  complete: U
+}, rt = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function et(e) {
+  return e;
+}
+function nt(e) {
+  return e.length === 0 ? et : e.length === 1 ? e[0] : function(t) {
+    return e.reduce(function(n, o) {
+      return o(n);
+    }, t);
+  };
+}
+var M = function() {
+  function e(r) {
+    r && (this._subscribe = r);
+  }
+  return e.prototype.lift = function(r) {
+    var t = new e();
+    return t.source = this, t.operator = r, t;
+  }, e.prototype.subscribe = function(r, t, n) {
+    var o = this, i = it(r) ? r : new T(r, t, n);
+    return m(function() {
+      var s = o, c = s.operator, p = s.source;
+      i.add(c ? c.call(i, p) : p ? o._subscribe(i) : o._trySubscribe(i));
+    }), i;
+  }, e.prototype._trySubscribe = function(r) {
+    try {
+      return this._subscribe(r);
+    } catch (t) {
+      r.error(t);
+    }
+  }, e.prototype.forEach = function(r, t) {
+    var n = this;
+    return t = B(t), new t(function(o, i) {
+      var s = new T({
+        next: function(c) {
+          try {
+            r(c);
+          } catch (p) {
+            i(p), s.unsubscribe();
+          }
+        },
+        error: i,
+        complete: o
+      });
+      n.subscribe(s);
+    });
+  }, e.prototype._subscribe = function(r) {
+    var t;
+    return (t = this.source) === null || t === void 0 ? void 0 : t.subscribe(r);
+  }, e.prototype[rt] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var r = [], t = 0; t < arguments.length; t++)
+      r[t] = arguments[t];
+    return nt(r)(this);
+  }, e.prototype.toPromise = function(r) {
+    var t = this;
+    return r = B(r), new r(function(n, o) {
+      var i;
+      t.subscribe(function(s) {
+        return i = s;
+      }, function(s) {
+        return o(s);
+      }, function() {
+        return n(i);
+      });
+    });
+  }, e.create = function(r) {
+    return new e(r);
+  }, e;
+}();
+function B(e) {
+  var r;
+  return (r = e ?? J.Promise) !== null && r !== void 0 ? r : Promise;
+}
+function ot(e) {
+  return e && f(e.next) && f(e.error) && f(e.complete);
+}
+function it(e) {
+  return e && e instanceof Y || ot(e) && F(e);
+}
+var st = R(function(e) {
+  return function() {
+    e(this), this.name = "ObjectUnsubscribedError", this.message = "object unsubscribed";
+  };
+}), Z = function(e) {
+  d(r, e);
+  function r() {
+    var t = e.call(this) || this;
+    return t.closed = !1, t.currentObservers = null, t.observers = [], t.isStopped = !1, t.hasError = !1, t.thrownError = null, t;
+  }
+  return r.prototype.lift = function(t) {
+    var n = new D(this, this);
+    return n.operator = t, n;
+  }, r.prototype._throwIfClosed = function() {
+    if (this.closed)
+      throw new st();
+  }, r.prototype.next = function(t) {
+    var n = this;
+    m(function() {
+      var o, i;
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.currentObservers || (n.currentObservers = Array.from(n.observers));
+        try {
+          for (var s = E(n.currentObservers), c = s.next(); !c.done; c = s.next()) {
+            var p = c.value;
+            p.next(t);
+          }
+        } catch (S) {
+          o = { error: S };
+        } finally {
+          try {
+            c && !c.done && (i = s.return) && i.call(s);
+          } finally {
+            if (o) throw o.error;
+          }
+        }
+      }
+    });
+  }, r.prototype.error = function(t) {
+    var n = this;
+    m(function() {
+      if (n._throwIfClosed(), !n.isStopped) {
+        n.hasError = n.isStopped = !0, n.thrownError = t;
+        for (var o = n.observers; o.length; )
+          o.shift().error(t);
+      }
+    });
+  }, r.prototype.complete = function() {
+    var t = this;
+    m(function() {
+      if (t._throwIfClosed(), !t.isStopped) {
+        t.isStopped = !0;
+        for (var n = t.observers; n.length; )
+          n.shift().complete();
+      }
+    });
+  }, r.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = !0, this.observers = this.currentObservers = null;
+  }, Object.defineProperty(r.prototype, "observed", {
+    get: function() {
+      var t;
+      return ((t = this.observers) === null || t === void 0 ? void 0 : t.length) > 0;
+    },
+    enumerable: !1,
+    configurable: !0
+  }), r.prototype._trySubscribe = function(t) {
+    return this._throwIfClosed(), e.prototype._trySubscribe.call(this, t);
+  }, r.prototype._subscribe = function(t) {
+    return this._throwIfClosed(), this._checkFinalizedStatuses(t), this._innerSubscribe(t);
+  }, r.prototype._innerSubscribe = function(t) {
+    var n = this, o = this, i = o.hasError, s = o.isStopped, c = o.observers;
+    return i || s ? V : (this.currentObservers = null, c.push(t), new _(function() {
+      n.currentObservers = null, x(c, t);
+    }));
+  }, r.prototype._checkFinalizedStatuses = function(t) {
+    var n = this, o = n.hasError, i = n.thrownError, s = n.isStopped;
+    o ? t.error(i) : s && t.complete();
+  }, r.prototype.asObservable = function() {
+    var t = new M();
+    return t.source = this, t;
+  }, r.create = function(t, n) {
+    return new D(t, n);
+  }, r;
+}(M), D = function(e) {
+  d(r, e);
+  function r(t, n) {
+    var o = e.call(this) || this;
+    return o.destination = t, o.source = n, o;
+  }
+  return r.prototype.next = function(t) {
+    var n, o;
+    (o = (n = this.destination) === null || n === void 0 ? void 0 : n.next) === null || o === void 0 || o.call(n, t);
+  }, r.prototype.error = function(t) {
+    var n, o;
+    (o = (n = this.destination) === null || n === void 0 ? void 0 : n.error) === null || o === void 0 || o.call(n, t);
+  }, r.prototype.complete = function() {
+    var t, n;
+    (n = (t = this.destination) === null || t === void 0 ? void 0 : t.complete) === null || n === void 0 || n.call(t);
+  }, r.prototype._subscribe = function(t) {
+    var n, o;
+    return (o = (n = this.source) === null || n === void 0 ? void 0 : n.subscribe(t)) !== null && o !== void 0 ? o : V;
+  }, r;
+}(Z), ut = function(e) {
+  d(r, e);
+  function r(t) {
+    var n = e.call(this) || this;
+    return n._value = t, n;
+  }
+  return Object.defineProperty(r.prototype, "value", {
+    get: function() {
+      return this.getValue();
+    },
+    enumerable: !1,
+    configurable: !0
+  }), r.prototype._subscribe = function(t) {
+    var n = e.prototype._subscribe.call(this, t);
+    return !n.closed && t.next(this._value), n;
+  }, r.prototype.getValue = function() {
+    var t = this, n = t.hasError, o = t.thrownError, i = t._value;
+    if (n)
+      throw o;
+    return this._throwIfClosed(), i;
+  }, r.prototype.next = function(t) {
+    e.prototype.next.call(this, this._value = t);
+  }, r;
+}(Z), at = Object.getOwnPropertyDescriptor, ct = (e, r, t, n) => {
+  for (var o = n > 1 ? void 0 : n ? at(r, t) : r, i = e.length - 1, s; i >= 0; i--)
+    (s = e[i]) && (o = s(o) || o);
+  return o;
+};
+let L = class {
+  constructor(e) {
+    this.ngZone = e, this.stateSubject = new ut(null), this.state$ = this.stateSubject.asObservable();
+  }
+  init(e) {
+    this.ngZone.runOutsideAngular(() => {
+      this.engine = new k({
+        ...e,
+        onStateChange: (r) => {
+          this.ngZone.run(() => this.stateSubject.next(r));
+        }
+      }), this.engine.loadModels();
+    });
+  }
+  attach(e) {
+    var r;
+    (r = this.engine) == null || r.attachVideo(e);
+  }
+  start() {
+    var e;
+    (e = this.engine) == null || e.start();
+  }
+  reset() {
+    var e;
+    (e = this.engine) == null || e.reset();
+  }
+  ngOnDestroy() {
+    var e;
+    (e = this.engine) == null || e.stop();
+  }
+};
+L = ct([
+  W({ providedIn: "root" })
+], L);
+var lt = Object.defineProperty, pt = Object.getOwnPropertyDescriptor, a = (e, r, t, n) => {
+  for (var o = n > 1 ? void 0 : n ? pt(r, t) : r, i = e.length - 1, s; i >= 0; i--)
+    (s = e[i]) && (o = (n ? s(r, t, o) : s(o)) || o);
+  return n && o && lt(r, t, o), o;
+};
+let u = class {
+  constructor(e) {
+    this.liveness = e, this.duration = 60, this.containerClass = "", this.videoWrapperClass = "", this.videoClass = "", this.timerClass = "", this.challengeTextClass = "", this.buttonClass = "", this.retryButtonClass = "", this.statusOverlayClass = "", this.successMessageClass = "", this.errorMessageClass = "", this.instructionBoxClass = "", this.onComplete = new A(), this.onError = new A();
+  }
+  ngOnInit() {
+    this.liveness.init({
+      apiUrl: this.apiUrl,
+      duration: this.duration,
+      smileThreshold: this.smileThreshold,
+      blinkThreshold: this.blinkThreshold,
+      minturnHeadThreshold: this.minturnHeadThreshold,
+      maxturnHeadThreshold: this.maxturnHeadThreshold,
+      onComplete: (e) => this.onComplete.emit(e),
+      onError: (e) => this.onError.emit(e)
+    });
+  }
+  async ngAfterViewInit() {
+    try {
+      const e = await navigator.mediaDevices.getUserMedia({
+        video: { width: 640, height: 480, facingMode: "user" }
+      }), r = this.webcamRef.nativeElement;
+      r.srcObject = e, r.onloadedmetadata = () => {
+        r.play(), this.liveness.attach(r);
+      };
+    } catch {
+      this.onError.emit({ success: !1, reason: "Camera access denied" });
+    }
+  }
+  ngOnDestroy() {
+    var r, t;
+    const e = (t = (r = this.webcamRef) == null ? void 0 : r.nativeElement) == null ? void 0 : t.srcObject;
+    e == null || e.getTracks().forEach((n) => n.stop());
+  }
+};
+a([
+  K("webcam")
+], u.prototype, "webcamRef", 2);
+a([
+  l()
+], u.prototype, "apiUrl", 2);
+a([
+  l()
+], u.prototype, "duration", 2);
+a([
+  l()
+], u.prototype, "smileThreshold", 2);
+a([
+  l()
+], u.prototype, "blinkThreshold", 2);
+a([
+  l()
+], u.prototype, "minturnHeadThreshold", 2);
+a([
+  l()
+], u.prototype, "maxturnHeadThreshold", 2);
+a([
+  l()
+], u.prototype, "containerClass", 2);
+a([
+  l()
+], u.prototype, "videoWrapperClass", 2);
+a([
+  l()
+], u.prototype, "videoClass", 2);
+a([
+  l()
+], u.prototype, "timerClass", 2);
+a([
+  l()
+], u.prototype, "challengeTextClass", 2);
+a([
+  l()
+], u.prototype, "buttonClass", 2);
+a([
+  l()
+], u.prototype, "retryButtonClass", 2);
+a([
+  l()
+], u.prototype, "statusOverlayClass", 2);
+a([
+  l()
+], u.prototype, "successMessageClass", 2);
+a([
+  l()
+], u.prototype, "errorMessageClass", 2);
+a([
+  l()
+], u.prototype, "instructionBoxClass", 2);
+a([
+  H()
+], u.prototype, "onComplete", 2);
+a([
+  H()
+], u.prototype, "onError", 2);
+u = a([
+  q({
+    selector: "LivenessCheck",
+    standalone: !0,
+    // Make it standalone
+    imports: [G],
+    // Add CommonModule here to fix NG8002
+    templateUrl: "./liveness.component.html",
+    styleUrls: ["./liveness.component.css"]
+  })
+], u);
+export {
+  u as LivenessComponent,
+  k as LivenessEngine,
+  _t as LivenessSDK,
+  L as LivenessService,
+  St as useLiveness,
+  bt as verifyLiveness
+};

package/dist/react/LivenessCheck.d.ts

@@ -0,0 +1,2 @@
+declare const LivenessCheck: any;
+export default LivenessCheck;

package/dist/react/useLiveness.d.ts

@@ -0,0 +1,10 @@
+import { default as Webcam } from 'react-webcam';
+import { LivenessEngineConfig, LivenessState } from '../core/LivenessEngine';
+
+export interface UseLivenessHook extends LivenessState {
+    webcamRef: React.RefObject<Webcam>;
+    start: () => void;
+    reset: () => void;
+}
+export declare const useLiveness: (config: LivenessEngineConfig) => UseLivenessHook;
+//# sourceMappingURL=useLiveness.d.ts.map

package/dist/react/useLiveness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLiveness.d.ts","sourceRoot":"","sources":["../../src/react/useLiveness.ts"],"names":[],"mappings":"AAEA,OAAO,MAAM,MAAM,cAAc,CAAC;AAClC,OAAO,EAAkB,oBAAoB,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAE7F,MAAM,WAAW,eAAgB,SAAQ,aAAa;IACpD,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;IACnC,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,eAAO,MAAM,WAAW,GAAI,QAAQ,oBAAoB,KAAG,eAkE1D,CAAC"}

package/dist/react.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./LivenessCheck-YOJ3vZ1M.cjs");require("react-webcam");exports.LivenessSDK=e.LivenessSDK;

package/dist/react.d.ts

@@ -0,0 +1 @@
+export * from './react/LivenessCheck.jsx'

package/dist/react.js

@@ -0,0 +1,5 @@
+import { a as s } from "./LivenessCheck-DxxnvHvi.js";
+import "react-webcam";
+export {
+  s as LivenessSDK
+};