@neofaceid/web-sdk 2.1.1 → 2.1.2

package/dist/neoface-id-sdk.es.js

@@ -4,7 +4,2447 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 import React, { useRef, useState, useCallback, useEffect, useReducer, forwardRef } from "react";
 import { createRoot } from "react-dom/client";
 import { jsxs, Fragment, jsx } from "react/jsx-runtime";
-import * as faceapi from "face-api.js";
+import "@tensorflow/tfjs-core/dist/public/chained_ops/register_all_chained_ops";
+import "@tensorflow/tfjs-backend-cpu";
+import * as tfjsCore from "@tensorflow/tfjs-core";
+import * as pn from "@tensorflow/tfjs-backend-webgl/dist/index.js";
+function _mergeNamespaces(n2, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k2 in e) {
+        if (k2 !== "default" && !(k2 in n2)) {
+          const d = Object.getOwnPropertyDescriptor(e, k2);
+          if (d) {
+            Object.defineProperty(n2, k2, d.get ? d : {
+              enumerable: true,
+              get: () => e[k2]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n2, Symbol.toStringTag, { value: "Module" }));
+}
+const mn = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null
+}, [tfjsCore]);
+const un = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null
+}, Symbol.toStringTag, { value: "Module" }));
+var ur = Object.defineProperty;
+var ho = Object.getOwnPropertyDescriptor;
+var bo = Object.getOwnPropertyNames;
+var go = Object.prototype.hasOwnProperty;
+var xo = ((o9) => typeof require != "undefined" ? require : typeof Proxy != "undefined" ? new Proxy(o9, { get: (t, e) => (typeof require != "undefined" ? require : t)[e] }) : o9)(function(o9) {
+  if (typeof require != "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + o9 + '" is not supported');
+});
+var Ye = (o9, t) => {
+  for (var e in t) ur(o9, e, { get: t[e], enumerable: true });
+}, pr = (o9, t, e, r) => {
+  if (t && typeof t == "object" || typeof t == "function") for (let a of bo(t)) !go.call(o9, a) && a !== e && ur(o9, a, { get: () => t[a], enumerable: !(r = ho(t, a)) || r.enumerable });
+  return o9;
+}, w = (o9, t, e) => (pr(o9, t, "default"), e);
+var n = {};
+Ye(n, { version: () => Po });
+w(n, mn);
+w(n, pn);
+w(n, un);
+var fr = "4.22.0", vo = "4.22.0", yo = "4.22.0", To = "4.22.0", _o = "4.22.0", Po = { tfjs: fr, "tfjs-core": fr, "tfjs-converter": vo, "tfjs-backend-cpu": yo, "tfjs-backend-webgl": To, "tfjs-backend-wasm": _o };
+var Sr = {};
+Ye(Sr, { AnchorPosition: () => Ke, DrawBox: () => ee, DrawBoxOptions: () => de, DrawFaceLandmarks: () => De, DrawFaceLandmarksOptions: () => Fe, DrawTextField: () => xt, DrawTextFieldOptions: () => Wt, drawContour: () => Z, drawDetections: () => Io, drawFaceExpressions: () => No, drawFaceLandmarks: () => So });
+function Z(o9, t, e = false) {
+  if (o9.beginPath(), t.slice(1).forEach(({ x: r, y: a }, i) => {
+    let s = t[i];
+    o9.moveTo(s.x, s.y), o9.lineTo(r, a);
+  }), e) {
+    let r = t[t.length - 1], a = t[0];
+    if (!r || !a) return;
+    o9.moveTo(r.x, r.y), o9.lineTo(a.x, a.y);
+  }
+  o9.stroke();
+}
+var lr = {};
+Ye(lr, { computeReshapedDimensions: () => je, getCenterPoint: () => bt, isDimensions: () => ue, isEven: () => pe, isFloat: () => Ge, isTensor: () => dt, isTensor1D: () => wo, isTensor2D: () => Ve, isTensor3D: () => K, isTensor4D: () => R, isValidNumber: () => G, isValidProbablitiy: () => Mt, range: () => X, round: () => ht });
+var A = class o {
+  constructor(t, e) {
+    if (!G(t) || !G(e)) throw new Error(`Dimensions.constructor - expected width and height to be valid numbers, instead have ${JSON.stringify({ width: t, height: e })}`);
+    this._width = t, this._height = e;
+  }
+  get width() {
+    return this._width;
+  }
+  get height() {
+    return this._height;
+  }
+  reverse() {
+    return new o(1 / this.width, 1 / this.height);
+  }
+};
+function dt(o9, t) {
+  return o9 instanceof n.Tensor && o9.shape.length === t;
+}
+function wo(o9) {
+  return dt(o9, 1);
+}
+function Ve(o9) {
+  return dt(o9, 2);
+}
+function K(o9) {
+  return dt(o9, 3);
+}
+function R(o9) {
+  return dt(o9, 4);
+}
+function Ge(o9) {
+  return o9 % 1 !== 0;
+}
+function pe(o9) {
+  return o9 % 2 === 0;
+}
+function ht(o9, t = 2) {
+  let e = 10 ** t;
+  return Math.floor(o9 * e) / e;
+}
+function ue(o9) {
+  return o9 && o9.width && o9.height;
+}
+function je({ width: o9, height: t }, e) {
+  let r = e / Math.max(t, o9);
+  return new A(Math.round(o9 * r), Math.round(t * r));
+}
+function bt(o9) {
+  return o9.reduce((t, e) => t.add(e), new v(0, 0)).div(new v(o9.length, o9.length));
+}
+function X(o9, t, e) {
+  return Array(o9).fill(0).map((r, a) => t + a * e);
+}
+function G(o9) {
+  return !!o9 && o9 !== 1 / 0 && o9 !== -1 / 0 && !Number.isNaN(o9) || o9 === 0;
+}
+function Mt(o9) {
+  return G(o9) && o9 >= 0 && o9 <= 1;
+}
+var v = class o2 {
+  constructor(t, e) {
+    this._x = t, this._y = e;
+  }
+  get x() {
+    return this._x;
+  }
+  get y() {
+    return this._y;
+  }
+  add(t) {
+    return new o2(this.x + t.x, this.y + t.y);
+  }
+  sub(t) {
+    return new o2(this.x - t.x, this.y - t.y);
+  }
+  mul(t) {
+    return new o2(this.x * t.x, this.y * t.y);
+  }
+  div(t) {
+    return new o2(this.x / t.x, this.y / t.y);
+  }
+  abs() {
+    return new o2(Math.abs(this.x), Math.abs(this.y));
+  }
+  magnitude() {
+    return Math.sqrt(this.x ** 2 + this.y ** 2);
+  }
+  floor() {
+    return new o2(Math.floor(this.x), Math.floor(this.y));
+  }
+};
+var C = class o3 {
+  static isRect(t) {
+    return !!t && [t.x, t.y, t.width, t.height].every(G);
+  }
+  static assertIsValidBox(t, e, r = false) {
+    if (!o3.isRect(t)) throw new Error(`${e} - invalid box: ${JSON.stringify(t)}, expected object with properties x, y, width, height`);
+    if (!r && (t.width < 0 || t.height < 0)) throw new Error(`${e} - width (${t.width}) and height (${t.height}) must be positive numbers`);
+  }
+  constructor(t, e = true) {
+    let r = t || {}, a = [r.left, r.top, r.right, r.bottom].every(G), i = [r.x, r.y, r.width, r.height].every(G);
+    if (!i && !a) throw new Error(`Box.constructor - expected box to be IBoundingBox | IRect, instead have ${JSON.stringify(r)}`);
+    let [s, c, m, p] = i ? [r.x, r.y, r.width, r.height] : [r.left, r.top, r.right - r.left, r.bottom - r.top];
+    o3.assertIsValidBox({ x: s, y: c, width: m, height: p }, "Box.constructor", e), this._x = s, this._y = c, this._width = m, this._height = p;
+  }
+  get x() {
+    return this._x;
+  }
+  get y() {
+    return this._y;
+  }
+  get width() {
+    return this._width;
+  }
+  get height() {
+    return this._height;
+  }
+  get left() {
+    return this.x;
+  }
+  get top() {
+    return this.y;
+  }
+  get right() {
+    return this.x + this.width;
+  }
+  get bottom() {
+    return this.y + this.height;
+  }
+  get area() {
+    return this.width * this.height;
+  }
+  get topLeft() {
+    return new v(this.left, this.top);
+  }
+  get topRight() {
+    return new v(this.right, this.top);
+  }
+  get bottomLeft() {
+    return new v(this.left, this.bottom);
+  }
+  get bottomRight() {
+    return new v(this.right, this.bottom);
+  }
+  round() {
+    let [t, e, r, a] = [this.x, this.y, this.width, this.height].map((i) => Math.round(i));
+    return new o3({ x: t, y: e, width: r, height: a });
+  }
+  floor() {
+    let [t, e, r, a] = [this.x, this.y, this.width, this.height].map((i) => Math.floor(i));
+    return new o3({ x: t, y: e, width: r, height: a });
+  }
+  toSquare() {
+    let { x: t, y: e, width: r, height: a } = this, i = Math.abs(r - a);
+    return r < a && (t -= i / 2, r += i), a < r && (e -= i / 2, a += i), new o3({ x: t, y: e, width: r, height: a });
+  }
+  rescale(t) {
+    let e = ue(t) ? t.width : t, r = ue(t) ? t.height : t;
+    return new o3({ x: this.x * e, y: this.y * r, width: this.width * e, height: this.height * r });
+  }
+  pad(t, e) {
+    let [r, a, i, s] = [this.x - t / 2, this.y - e / 2, this.width + t, this.height + e];
+    return new o3({ x: r, y: a, width: i, height: s });
+  }
+  clipAtImageBorders(t, e) {
+    let { x: r, y: a, right: i, bottom: s } = this, c = Math.max(r, 0), m = Math.max(a, 0), p = i - c, u = s - m, f = Math.min(p, t - c), l = Math.min(u, e - m);
+    return new o3({ x: c, y: m, width: f, height: l }).floor();
+  }
+  shift(t, e) {
+    let { width: r, height: a } = this, i = this.x + t, s = this.y + e;
+    return new o3({ x: i, y: s, width: r, height: a });
+  }
+  padAtBorders(t, e) {
+    let r = this.width + 1, a = this.height + 1, i = 1, s = 1, c = r, m = a, p = this.left, u = this.top, f = this.right, l = this.bottom;
+    return f > e && (c = -f + e + r, f = e), l > t && (m = -l + t + a, l = t), p < 1 && (m = 2 - p, p = 1), u < 1 && (m = 2 - u, u = 1), { dy: s, edy: m, dx: i, edx: c, y: u, ey: l, x: p, ex: f, w: r, h: a };
+  }
+  calibrate(t) {
+    return new o3({ left: this.left + t.left * this.width, top: this.top + t.top * this.height, right: this.right + t.right * this.width, bottom: this.bottom + t.bottom * this.height }).toSquare().round();
+  }
+};
+var Ct = class extends C {
+  constructor(t, e, r, a, i = false) {
+    super({ left: t, top: e, right: r, bottom: a }, i);
+  }
+};
+var It = class o4 {
+  constructor(t, e, r, a, i) {
+    this._imageDims = new A(i.width, i.height), this._score = t, this._classScore = e, this._className = r, this._box = new C(a).rescale(this._imageDims);
+  }
+  get score() {
+    return this._score;
+  }
+  get classScore() {
+    return this._classScore;
+  }
+  get className() {
+    return this._className;
+  }
+  get box() {
+    return this._box;
+  }
+  get imageDims() {
+    return this._imageDims;
+  }
+  get imageWidth() {
+    return this.imageDims.width;
+  }
+  get imageHeight() {
+    return this.imageDims.height;
+  }
+  get relativeBox() {
+    return new C(this._box).rescale(this.imageDims.reverse());
+  }
+  forSize(t, e) {
+    return new o4(this.score, this.classScore, this.className, this.relativeBox, { width: t, height: e });
+  }
+};
+var D = class o5 extends It {
+  constructor(t, e, r) {
+    super(t, t, "", e, r);
+  }
+  forSize(t, e) {
+    let { score: r, relativeBox: a, imageDims: i } = super.forSize(t, e);
+    return new o5(r, a, i);
+  }
+};
+function dr(o9, t, e = true) {
+  let r = Math.max(0, Math.min(o9.right, t.right) - Math.max(o9.left, t.left)), a = Math.max(0, Math.min(o9.bottom, t.bottom) - Math.max(o9.top, t.top)), i = r * a;
+  return e ? i / (o9.area + t.area - i) : i / Math.min(o9.area, t.area);
+}
+function hr(o9) {
+  let t = o9.map((c) => c.x), e = o9.map((c) => c.y), r = t.reduce((c, m) => m < c ? m : c, 1 / 0), a = e.reduce((c, m) => m < c ? m : c, 1 / 0), i = t.reduce((c, m) => c < m ? m : c, 0), s = e.reduce((c, m) => c < m ? m : c, 0);
+  return new Ct(r, a, i, s);
+}
+function br(o9, t, e, r = true) {
+  let a = t.map((s, c) => ({ score: s, boxIndex: c })).sort((s, c) => s.score - c.score).map((s) => s.boxIndex), i = [];
+  for (; a.length > 0; ) {
+    let s = a.pop();
+    i.push(s);
+    let c = a, m = [];
+    for (let p = 0; p < c.length; p++) {
+      let u = c[p], f = o9[s], l = o9[u];
+      m.push(dr(f, l, r));
+    }
+    a = a.filter((p, u) => m[u] <= e);
+  }
+  return i;
+}
+function J(o9, t) {
+  return n.tidy(() => {
+    let [e, r, a] = t, i = n.fill([...o9.shape.slice(0, 3), 1], e, "float32"), s = n.fill([...o9.shape.slice(0, 3), 1], r, "float32"), c = n.fill([...o9.shape.slice(0, 3), 1], a, "float32"), m = n.concat([i, s, c], 3);
+    return n.sub(o9, m);
+  });
+}
+function gr(o9, t = false) {
+  return n.tidy(() => {
+    let [e, r] = o9.shape.slice(1);
+    if (e === r) return o9;
+    let a = Math.abs(e - r), i = Math.round(a * (t ? 0.5 : 1)), s = e > r ? 2 : 1, c = (l) => {
+      let d = o9.shape.slice();
+      return d[s] = l, n.fill(d, 0, "float32");
+    }, m = c(i), p = a - m.shape[s], f = [t && p ? c(p) : null, o9, m].filter((l) => !!l).map((l) => n.cast(l, "float32"));
+    return n.concat(f, s);
+  });
+}
+function Rn(o9) {
+  let t = o9.slice();
+  for (let e = t.length - 1; e > 0; e--) {
+    let r = Math.floor(Math.random() * (e + 1)), a = t[e];
+    t[e] = t[r], t[r] = a;
+  }
+  return t;
+}
+function fe(o9) {
+  return 1 / (1 + Math.exp(-o9));
+}
+function On(o9) {
+  return Math.log(o9 / (1 - o9));
+}
+var Nt = class extends C {
+  constructor(t, e, r, a, i = false) {
+    super({ x: t, y: e, width: r, height: a }, i);
+  }
+};
+var Fo = 0.5, Do = 0.43, Eo = 0.45, $ = class {
+  constructor(t, e, r = new v(0, 0)) {
+    let { width: a, height: i } = e;
+    this._imgDims = new A(a, i), this._shift = r, this._positions = t.map((s) => s.mul(new v(a, i)).add(r));
+  }
+  get shift() {
+    return new v(this._shift.x, this._shift.y);
+  }
+  get imageWidth() {
+    return this._imgDims.width;
+  }
+  get imageHeight() {
+    return this._imgDims.height;
+  }
+  get positions() {
+    return this._positions;
+  }
+  get relativePositions() {
+    return this._positions.map((t) => t.sub(this._shift).div(new v(this.imageWidth, this.imageHeight)));
+  }
+  forSize(t, e) {
+    return new this.constructor(this.relativePositions, { width: t, height: e });
+  }
+  shiftBy(t, e) {
+    return new this.constructor(this.relativePositions, this._imgDims, new v(t, e));
+  }
+  shiftByPoint(t) {
+    return this.shiftBy(t.x, t.y);
+  }
+  align(t, e = {}) {
+    if (t) {
+      let i = t instanceof D ? t.box.floor() : new C(t);
+      return this.shiftBy(i.x, i.y).align(null, e);
+    }
+    let { useDlibAlignment: r, minBoxPadding: a } = { useDlibAlignment: false, minBoxPadding: 0.2, ...e };
+    return r ? this.alignDlib() : this.alignMinBbox(a);
+  }
+  alignDlib() {
+    let t = this.getRefPointsForAlignment(), [e, r, a] = t, i = (f) => a.sub(f).magnitude(), s = (i(e) + i(r)) / 2, c = Math.floor(s / Eo), m = bt(t), p = Math.floor(Math.max(0, m.x - Fo * c)), u = Math.floor(Math.max(0, m.y - Do * c));
+    return new Nt(p, u, Math.min(c, this.imageWidth + p), Math.min(c, this.imageHeight + u));
+  }
+  alignMinBbox(t) {
+    let e = hr(this.positions);
+    return e.pad(e.width * t, e.height * t);
+  }
+  getRefPointsForAlignment() {
+    throw new Error("getRefPointsForAlignment not implemented by base class");
+  }
+};
+var xr = class extends $ {
+  getRefPointsForAlignment() {
+    let t = this.positions;
+    return [t[0], t[1], bt([t[3], t[4]])];
+  }
+};
+var Lt = class extends $ {
+  getJawOutline() {
+    return this.positions.slice(0, 17);
+  }
+  getLeftEyeBrow() {
+    return this.positions.slice(17, 22);
+  }
+  getRightEyeBrow() {
+    return this.positions.slice(22, 27);
+  }
+  getNose() {
+    return this.positions.slice(27, 36);
+  }
+  getLeftEye() {
+    return this.positions.slice(36, 42);
+  }
+  getRightEye() {
+    return this.positions.slice(42, 48);
+  }
+  getMouth() {
+    return this.positions.slice(48, 68);
+  }
+  getRefPointsForAlignment() {
+    return [this.getLeftEye(), this.getRightEye(), this.getMouth()].map(bt);
+  }
+};
+var Kt = class {
+  constructor(t, e) {
+    this._label = t, this._distance = e;
+  }
+  get label() {
+    return this._label;
+  }
+  get distance() {
+    return this._distance;
+  }
+  toString(t = true) {
+    return `${this.label}${t ? ` (${ht(this.distance)})` : ""}`;
+  }
+};
+var Qt = class extends C {
+  static assertIsValidLabeledBox(t, e) {
+    if (C.assertIsValidBox(t, e), !G(t.label)) throw new Error(`${e} - expected property label (${t.label}) to be a number`);
+  }
+  constructor(t, e) {
+    super(t), this._label = e;
+  }
+  get label() {
+    return this._label;
+  }
+};
+var gt = class o6 {
+  constructor(t, e) {
+    if (typeof t != "string") throw new Error("LabeledFaceDescriptors - constructor expected label to be a string");
+    if (!Array.isArray(e) || e.some((r) => !(r instanceof Float32Array))) throw new Error("LabeledFaceDescriptors - constructor expected descriptors to be an array of Float32Array");
+    this._label = t, this._descriptors = e;
+  }
+  get label() {
+    return this._label;
+  }
+  get descriptors() {
+    return this._descriptors;
+  }
+  toJSON() {
+    return { label: this.label, descriptors: this.descriptors.map((t) => Array.from(t)) };
+  }
+  static fromJSON(t) {
+    let e = t.descriptors.map((r) => new Float32Array(r));
+    return new o6(t.label, e);
+  }
+};
+var vr = class extends Qt {
+  static assertIsValidPredictedBox(t, e) {
+    if (Qt.assertIsValidLabeledBox(t, e), !Mt(t.score) || !Mt(t.classScore)) throw new Error(`${e} - expected properties score (${t.score}) and (${t.classScore}) to be a number between [0, 1]`);
+  }
+  constructor(t, e, r, a) {
+    super(t, e), this._score = r, this._classScore = a;
+  }
+  get score() {
+    return this._score;
+  }
+  get classScore() {
+    return this._classScore;
+  }
+};
+function Q(o9) {
+  return o9.detection instanceof D;
+}
+function St(o9, t) {
+  return { ...o9, ...{ detection: t } };
+}
+function Ue() {
+  let o9 = window.fetch;
+  if (!o9) throw new Error("fetch - missing fetch implementation for browser environment");
+  return { Canvas: HTMLCanvasElement, CanvasRenderingContext2D, Image: HTMLImageElement, ImageData, Video: HTMLVideoElement, createCanvasElement: () => document.createElement("canvas"), createImageElement: () => document.createElement("img"), createVideoElement: () => document.createElement("video"), fetch: o9, readFile: () => {
+    throw new Error("readFile - filesystem not available for browser environment");
+  } };
+}
+function te() {
+  return typeof global == "object" && typeof process != "undefined" && process.versions != null && process.versions.node != null;
+}
+function le(o9) {
+  let t = "";
+  if (!o9 && te()) try {
+    o9 = xo("fs");
+  } catch (r) {
+    t = r.toString();
+  }
+  return { readFile: o9 ? (r) => new Promise((a, i) => {
+    o9.readFile(r, (s, c) => s ? i(s) : a(c));
+  }) : () => {
+    throw new Error(`readFile - failed to require fs in nodejs environment with error: ${t}`);
+  } };
+}
+function Xe() {
+  let o9 = global.Canvas || global.HTMLCanvasElement, t = global.Image || global.HTMLImageElement, e = global.Video || global.HTMLVideoElement, r = () => {
+    if (o9) return new o9();
+    throw new Error("createCanvasElement - missing Canvas implementation for nodejs environment");
+  }, a = () => {
+    if (t) return new t();
+    throw new Error("createImageElement - missing Image implementation for nodejs environment");
+  }, i = () => {
+    if (e) return new e();
+    throw new Error("createVideoElement - missing Video implementation for nodejs environment");
+  }, s = global.fetch, c = le();
+  return { Canvas: o9 || class {
+  }, CanvasRenderingContext2D: global.CanvasRenderingContext2D || class {
+  }, Image: t || class {
+  }, ImageData: global.ImageData || class {
+  }, Video: global.HTMLVideoElement || class {
+  }, createCanvasElement: r, createImageElement: a, createVideoElement: i, fetch: s, ...c };
+}
+function Je() {
+  return typeof window == "object" && typeof document != "undefined" && typeof HTMLImageElement != "undefined" && typeof HTMLCanvasElement != "undefined" && typeof HTMLVideoElement != "undefined" && typeof ImageData != "undefined" && typeof CanvasRenderingContext2D != "undefined";
+}
+var M;
+function Mo() {
+  if (!M) throw new Error("getEnv - environment is not defined, check isNodejs() and isBrowser()");
+  return M;
+}
+function qe(o9) {
+  M = o9;
+}
+function Ze() {
+  return Je() ? qe(Ue()) : te() ? qe(Xe()) : null;
+}
+function Co(o9) {
+  if (M || Ze(), !M) throw new Error("monkeyPatch - environment is not defined, check isNodejs() and isBrowser()");
+  let { Canvas: t = M.Canvas, Image: e = M.Image } = o9;
+  M.Canvas = t, M.Image = e, M.createCanvasElement = o9.createCanvasElement || (() => new t()), M.createImageElement = o9.createImageElement || (() => new e()), M.ImageData = o9.ImageData || M.ImageData, M.Video = o9.Video || M.Video, M.fetch = o9.fetch || M.fetch, M.readFile = o9.readFile || M.readFile;
+}
+var _ = { getEnv: Mo, setEnv: qe, initialize: Ze, createBrowserEnv: Ue, createFileSystem: le, createNodejsEnv: Xe, monkeyPatch: Co, isBrowser: Je, isNodejs: te };
+Ze();
+function At(o9) {
+  return !_.isNodejs() && typeof o9 == "string" ? document.getElementById(o9) : o9;
+}
+function W(o9) {
+  let { Canvas: t, CanvasRenderingContext2D: e } = _.getEnv();
+  if (o9 instanceof e) return o9;
+  let r = At(o9);
+  if (!(r instanceof t)) throw new Error("resolveContext2d - expected canvas to be of instance of Canvas");
+  let a = r.getContext("2d", { willReadFrequently: true });
+  if (!a) throw new Error("resolveContext2d - canvas 2d context is null");
+  return a;
+}
+var Ke = ((a) => (a.TOP_LEFT = "TOP_LEFT", a.TOP_RIGHT = "TOP_RIGHT", a.BOTTOM_LEFT = "BOTTOM_LEFT", a.BOTTOM_RIGHT = "BOTTOM_RIGHT", a))(Ke || {}), Wt = class {
+  constructor(t = {}) {
+    let { anchorPosition: e, backgroundColor: r, fontColor: a, fontSize: i, fontStyle: s, padding: c } = t;
+    this.anchorPosition = e || "TOP_LEFT", this.backgroundColor = r || "rgba(0, 0, 0, 0.5)", this.fontColor = a || "rgba(255, 255, 255, 1)", this.fontSize = i || 14, this.fontStyle = s || "Georgia", this.padding = c || 4;
+  }
+}, xt = class o7 {
+  constructor(t, e, r = {}) {
+    this.text = typeof t == "string" ? [t] : t instanceof o7 ? t.text : t, this.anchor = e, this.options = new Wt(r);
+  }
+  measureWidth(t) {
+    let { padding: e } = this.options;
+    return this.text.map((r) => t.measureText(r).width).reduce((r, a) => r < a ? a : r, 0) + 2 * e;
+  }
+  measureHeight() {
+    let { fontSize: t, padding: e } = this.options;
+    return this.text.length * t + 2 * e;
+  }
+  getUpperLeft(t, e) {
+    let { anchorPosition: r } = this.options, a = r === "BOTTOM_RIGHT" || r === "TOP_RIGHT", i = r === "BOTTOM_LEFT" || r === "BOTTOM_RIGHT", s = this.measureWidth(t), c = this.measureHeight(), m = a ? this.anchor.x - s : this.anchor.x, p = i ? this.anchor.y - c : this.anchor.y;
+    if (e) {
+      let { width: u, height: f } = e, l = Math.max(Math.min(m, u - s), 0), d = Math.max(Math.min(p, f - c), 0);
+      return { x: l, y: d };
+    }
+    return { x: m, y: p };
+  }
+  draw(t) {
+    let e = At(t), r = W(e), { backgroundColor: a, fontColor: i, fontSize: s, fontStyle: c, padding: m } = this.options;
+    r.font = `${s}px ${c}`;
+    let p = this.measureWidth(r), u = this.measureHeight();
+    r.fillStyle = a;
+    let f = this.getUpperLeft(r, e);
+    r.fillRect(f.x, f.y, p, u), r.fillStyle = i, this.text.forEach((l, d) => {
+      let b = m + f.x, y = m + f.y + (d + 1) * s;
+      r.fillText(l, b, y);
+    });
+  }
+};
+var de = class {
+  constructor(t = {}) {
+    let { boxColor: e, lineWidth: r, label: a, drawLabelOptions: i } = t;
+    this.boxColor = e || "rgba(0, 0, 255, 1)", this.lineWidth = r || 2, this.label = a;
+    let s = { anchorPosition: "BOTTOM_LEFT", backgroundColor: this.boxColor };
+    this.drawLabelOptions = new Wt({ ...s, ...i });
+  }
+}, ee = class {
+  constructor(t, e = {}) {
+    this.box = new C(t), this.options = new de(e);
+  }
+  draw(t) {
+    let e = W(t), { boxColor: r, lineWidth: a } = this.options, { x: i, y: s, width: c, height: m } = this.box;
+    e.strokeStyle = r, e.lineWidth = a, e.strokeRect(i, s, c, m);
+    let { label: p } = this.options;
+    p && new xt([p], { x: i - a / 2, y: s }, this.options.drawLabelOptions).draw(t);
+  }
+};
+function Io(o9, t) {
+  (Array.isArray(t) ? t : [t]).forEach((r) => {
+    let a = r instanceof D ? r.score : Q(r) ? r.detection.score : void 0, i = r instanceof D ? r.box : Q(r) ? r.detection.box : new C(r), s = a ? `${ht(a)}` : void 0;
+    new ee(i, { label: s }).draw(o9);
+  });
+}
+function he(o9) {
+  let { Image: t, Video: e } = _.getEnv();
+  return o9 instanceof t && o9.complete || o9 instanceof e && o9.readyState >= 3;
+}
+function yr(o9) {
+  return new Promise((t, e) => {
+    if (o9 instanceof _.getEnv().Canvas || he(o9)) {
+      t(null);
+      return;
+    }
+    function r(i) {
+      i.currentTarget && (i.currentTarget.removeEventListener("load", a), i.currentTarget.removeEventListener("error", r), e(i));
+    }
+    function a(i) {
+      i.currentTarget && (i.currentTarget.removeEventListener("load", a), i.currentTarget.removeEventListener("error", r), t(i));
+    }
+    o9.addEventListener("load", a), o9.addEventListener("error", r);
+  });
+}
+function Tr(o9) {
+  return new Promise((t, e) => {
+    o9 instanceof Blob || e(new Error("bufferToImage - expected buf to be of type: Blob"));
+    let r = new FileReader();
+    r.onload = () => {
+      typeof r.result != "string" && e(new Error("bufferToImage - expected reader.result to be a string, in onload"));
+      let a = _.getEnv().createImageElement();
+      a.onload = () => t(a), a.onerror = e, a.src = r.result;
+    }, r.onerror = e, r.readAsDataURL(o9);
+  });
+}
+function kt(o9) {
+  let { Image: t, Video: e } = _.getEnv();
+  return o9 instanceof t ? new A(o9.naturalWidth, o9.naturalHeight) : o9 instanceof e ? new A(o9.videoWidth, o9.videoHeight) : new A(o9.width, o9.height);
+}
+function Bt({ width: o9, height: t }) {
+  let { createCanvasElement: e } = _.getEnv(), r = e();
+  return r.width = o9, r.height = t, r;
+}
+function be(o9, t) {
+  let { ImageData: e } = _.getEnv();
+  if (!(o9 instanceof e) && !he(o9)) throw new Error("createCanvasFromMedia - media has not finished loading yet");
+  let { width: r, height: a } = t || kt(o9), i = Bt({ width: r, height: a });
+  return o9 instanceof e ? W(i).putImageData(o9, 0, 0) : W(i).drawImage(o9, 0, 0, r, a), i;
+}
+async function _r(o9, t) {
+  let e = t || _.getEnv().createCanvasElement(), [r, a, i] = o9.shape.slice(R(o9) ? 1 : 0), s = n.tidy(() => o9.as3D(r, a, i).toInt());
+  return await n.browser.toPixels(s, e), s.dispose(), e;
+}
+function Qe(o9) {
+  let { Image: t, Canvas: e, Video: r } = _.getEnv();
+  return o9 instanceof t || o9 instanceof e || o9 instanceof r;
+}
+function Pr(o9, t, e = false) {
+  let { Image: r, Canvas: a } = _.getEnv();
+  if (!(o9 instanceof r || o9 instanceof a)) throw new Error("imageToSquare - expected arg0 to be HTMLImageElement | HTMLCanvasElement");
+  if (t <= 0) return Bt({ width: 1, height: 1 });
+  let i = kt(o9), s = t / Math.max(i.height, i.width), c = s * i.width, m = s * i.height, p = Bt({ width: t, height: t }), u = o9 instanceof a ? o9 : be(o9), f = Math.abs(c - m) / 2, l = e && c < m ? f : 0, d = e && m < c ? f : 0;
+  return u.width > 0 && u.height > 0 && W(p).drawImage(u, l, d, c, m), p;
+}
+var tt = class {
+  constructor(t, e = false) {
+    this._imageTensors = [];
+    this._canvases = [];
+    this._treatAsBatchInput = false;
+    this._inputDimensions = [];
+    this._inputSize = 0;
+    if (!Array.isArray(t)) throw new Error(`NetInput.constructor - expected inputs to be an Array of TResolvedNetInput or to be instanceof tf.Tensor4D, instead have ${t}`);
+    this._treatAsBatchInput = e, this._batchSize = t.length, t.forEach((r, a) => {
+      if (K(r)) {
+        this._imageTensors[a] = r, this._inputDimensions[a] = r.shape;
+        return;
+      }
+      if (R(r)) {
+        let s = r.shape[0];
+        if (s !== 1) throw new Error(`NetInput - tf.Tensor4D with batchSize ${s} passed, but not supported in input array`);
+        this._imageTensors[a] = r, this._inputDimensions[a] = r.shape.slice(1);
+        return;
+      }
+      let i = r instanceof _.getEnv().Canvas ? r : be(r);
+      this._canvases[a] = i, this._inputDimensions[a] = [i.height, i.width, 3];
+    });
+  }
+  get imageTensors() {
+    return this._imageTensors;
+  }
+  get canvases() {
+    return this._canvases;
+  }
+  get isBatchInput() {
+    return this.batchSize > 1 || this._treatAsBatchInput;
+  }
+  get batchSize() {
+    return this._batchSize;
+  }
+  get inputDimensions() {
+    return this._inputDimensions;
+  }
+  get inputSize() {
+    return this._inputSize;
+  }
+  get reshapedInputDimensions() {
+    return X(this.batchSize, 0, 1).map((t, e) => this.getReshapedInputDimensions(e));
+  }
+  getInput(t) {
+    return this.canvases[t] || this.imageTensors[t];
+  }
+  getInputDimensions(t) {
+    return this._inputDimensions[t];
+  }
+  getInputHeight(t) {
+    return this._inputDimensions[t][0];
+  }
+  getInputWidth(t) {
+    return this._inputDimensions[t][1];
+  }
+  getReshapedInputDimensions(t) {
+    if (typeof this.inputSize != "number") throw new Error("getReshapedInputDimensions - inputSize not set, toBatchTensor has not been called yet");
+    let e = this.getInputWidth(t), r = this.getInputHeight(t);
+    return je({ width: e, height: r }, this.inputSize);
+  }
+  toBatchTensor(t, e = true) {
+    return this._inputSize = t, n.tidy(() => {
+      let r = X(this.batchSize, 0, 1).map((i) => {
+        let s = this.getInput(i);
+        if (s instanceof n.Tensor) {
+          let c = R(s) ? s : n.expandDims(s);
+          return c = gr(c, e), (c.shape[1] !== t || c.shape[2] !== t) && (c = n.image.resizeBilinear(c, [t, t], false, false)), c.as3D(t, t, 3);
+        }
+        if (s instanceof _.getEnv().Canvas) return n.browser.fromPixels(Pr(s, t, e));
+        throw new Error(`toBatchTensor - at batchIdx ${i}, expected input to be instanceof tf.Tensor or instanceof HTMLCanvasElement, instead have ${s}`);
+      });
+      return n.stack(r.map((i) => n.cast(i, "float32"))).as4D(this.batchSize, t, t, 3);
+    });
+  }
+};
+async function F(o9) {
+  if (o9 instanceof tt) return o9;
+  let t = Array.isArray(o9) ? o9 : [o9];
+  if (!t.length) throw new Error("toNetInput - empty array passed as input");
+  let e = (a) => Array.isArray(o9) ? ` at input index ${a}:` : "", r = t.map(At);
+  return r.forEach((a, i) => {
+    if (!Qe(a) && !K(a) && !R(a)) throw typeof t[i] == "string" ? new Error(`toNetInput -${e(i)} string passed, but could not resolve HTMLElement for element id ${t[i]}`) : new Error(`toNetInput -${e(i)} expected media to be of type HTMLImageElement | HTMLVideoElement | HTMLCanvasElement | tf.Tensor3D, or to be an element id`);
+    if (R(a)) {
+      let s = a.shape[0];
+      if (s !== 1) throw new Error(`toNetInput -${e(i)} tf.Tensor4D with batchSize ${s} passed, but not supported in input array`);
+    }
+  }), await Promise.all(r.map((a) => Qe(a) && yr(a))), new tt(r, Array.isArray(o9));
+}
+async function re(o9, t) {
+  let { Canvas: e } = _.getEnv(), r = o9;
+  if (!(o9 instanceof e)) {
+    let s = await F(o9);
+    if (s.batchSize > 1) throw new Error("extractFaces - batchSize > 1 not supported");
+    let c = s.getInput(0);
+    r = c instanceof e ? c : await _r(c);
+  }
+  let a = W(r);
+  return t.map((s) => s instanceof D ? s.forSize(r.width, r.height).box.floor() : s).map((s) => s.clipAtImageBorders(r.width, r.height)).map(({ x: s, y: c, width: m, height: p }) => {
+    let u = Bt({ width: m, height: p });
+    return m > 0 && p > 0 && W(u).putImageData(a.getImageData(s, c, m, p), 0, 0), u;
+  });
+}
+async function oe(o9, t) {
+  if (!K(o9) && !R(o9)) throw new Error("extractFaceTensors - expected image tensor to be 3D or 4D");
+  if (R(o9) && o9.shape[0] > 1) throw new Error("extractFaceTensors - batchSize > 1 not supported");
+  return n.tidy(() => {
+    let [e, r, a] = o9.shape.slice(R(o9) ? 1 : 0);
+    return t.map((c) => c instanceof D ? c.forSize(r, e).box : c).map((c) => c.clipAtImageBorders(r, e)).filter((c) => c.width > 0 && c.height > 0).map(({ x: c, y: m, width: p, height: u }) => n.slice3d(o9.as3D(e, r, a), [m, c, 0], [u, p, a]));
+  });
+}
+async function st(o9, t) {
+  let { fetch: e } = _.getEnv(), r = await e(o9, t);
+  if (!(r.status < 400)) throw new Error(`failed to fetch: (${r.status}) ${r.statusText}, from url: ${r.url}`);
+  return r;
+}
+async function Fi(o9) {
+  let t = await st(o9), e = await t.blob();
+  if (!e.type.startsWith("image/")) throw new Error(`fetchImage - expected blob type to be of type image/*, instead have: ${e.type}, for url: ${t.url}`);
+  return Tr(e);
+}
+async function wr(o9) {
+  return (await st(o9)).json();
+}
+async function Ii(o9) {
+  return new Float32Array(await (await st(o9)).arrayBuffer());
+}
+function Fr(o9) {
+  return new Promise((t, e) => {
+    o9 instanceof Blob || e(new Error("bufferToVideo - expected buf to be of type: Blob"));
+    let r = _.getEnv().createVideoElement();
+    r.oncanplay = () => t(r), r.onerror = e, r.playsInline = true, r.muted = true, r.src = URL.createObjectURL(o9), r.play();
+  });
+}
+async function ki(o9) {
+  let t = await st(o9), e = await t.blob();
+  if (!e.type.startsWith("video/")) throw new Error(`fetchVideo - expected blob type to be of type video/*, instead have: ${e.type}, for url: ${t.url}`);
+  return Fr(e);
+}
+function ge(o9, t) {
+  let e = `${t}-weights_manifest.json`;
+  if (!o9) return { modelBaseUri: "", manifestUri: e };
+  if (o9 === "/") return { modelBaseUri: "/", manifestUri: `/${e}` };
+  let r = o9.startsWith("http://") ? "http://" : o9.startsWith("https://") ? "https://" : "";
+  o9 = o9.replace(r, "");
+  let a = o9.split("/").filter((c) => c), i = o9.endsWith(".json") ? a[a.length - 1] : e, s = r + (o9.endsWith(".json") ? a.slice(0, a.length - 1) : a).join("/");
+  return s = o9.startsWith("/") ? `/${s}` : s, { modelBaseUri: s, manifestUri: s === "/" ? `/${i}` : `${s}/${i}` };
+}
+async function Dr(o9, t) {
+  let { manifestUri: e, modelBaseUri: r } = ge(o9, t), a = await wr(e);
+  return n.io.loadWeights(a, r);
+}
+function Yi(o9, t, e = false) {
+  let { width: r, height: a } = e ? kt(t) : t;
+  return o9.width = r, o9.height = a, { width: r, height: a };
+}
+var I = class {
+  constructor(t) {
+    this._params = void 0;
+    this._paramMappings = [];
+    this._name = t;
+  }
+  get params() {
+    return this._params;
+  }
+  get paramMappings() {
+    return this._paramMappings;
+  }
+  get isLoaded() {
+    return !!this.params;
+  }
+  getParamFromPath(t) {
+    let { obj: e, objProp: r } = this.traversePropertyPath(t);
+    return e[r];
+  }
+  reassignParamFromPath(t, e) {
+    let { obj: r, objProp: a } = this.traversePropertyPath(t);
+    r[a].dispose(), r[a] = e;
+  }
+  getParamList() {
+    return this._paramMappings.map(({ paramPath: t }) => ({ path: t, tensor: this.getParamFromPath(t) }));
+  }
+  getTrainableParams() {
+    return this.getParamList().filter((t) => t.tensor instanceof n.Variable);
+  }
+  getFrozenParams() {
+    return this.getParamList().filter((t) => !(t.tensor instanceof n.Variable));
+  }
+  variable() {
+    this.getFrozenParams().forEach(({ path: t, tensor: e }) => {
+      this.reassignParamFromPath(t, e.variable());
+    });
+  }
+  freeze() {
+    this.getTrainableParams().forEach(({ path: t, tensor: e }) => {
+      let r = n.tensor(e.dataSync());
+      e.dispose(), this.reassignParamFromPath(t, r);
+    });
+  }
+  dispose(t = true) {
+    this.getParamList().forEach((e) => {
+      if (t && e.tensor.isDisposed) throw new Error(`param tensor has already been disposed for path ${e.path}`);
+      e.tensor.dispose();
+    }), this._params = void 0;
+  }
+  serializeParams() {
+    return new Float32Array(this.getParamList().map(({ tensor: t }) => Array.from(t.dataSync())).reduce((t, e) => t.concat(e)));
+  }
+  async load(t) {
+    if (t instanceof Float32Array) {
+      this.extractWeights(t);
+      return;
+    }
+    await this.loadFromUri(t);
+  }
+  async loadFromUri(t) {
+    if (t && typeof t != "string") throw new Error(`${this._name}.loadFromUri - expected model uri`);
+    let e = await Dr(t, this.getDefaultModelName());
+    this.loadFromWeightMap(e);
+  }
+  async loadFromDisk(t) {
+    if (t && typeof t != "string") throw new Error(`${this._name}.loadFromDisk - expected model file path`);
+    let { readFile: e } = _.getEnv(), { manifestUri: r, modelBaseUri: a } = ge(t, this.getDefaultModelName()), i = (p) => Promise.all(p.map((u) => e(u).then((f) => typeof f == "string" ? Buffer.from(f) : f.buffer))), s = n.io.weightsLoaderFactory(i), c = JSON.parse((await e(r)).toString()), m = await s(c, a);
+    this.loadFromWeightMap(m);
+  }
+  loadFromWeightMap(t) {
+    let { paramMappings: e, params: r } = this.extractParamsFromWeightMap(t);
+    this._paramMappings = e, this._params = r;
+  }
+  extractWeights(t) {
+    let { paramMappings: e, params: r } = this.extractParams(t);
+    this._paramMappings = e, this._params = r;
+  }
+  traversePropertyPath(t) {
+    if (!this.params) throw new Error("traversePropertyPath - model has no loaded params");
+    let e = t.split("/").reduce((i, s) => {
+      if (!i.nextObj.hasOwnProperty(s)) throw new Error(`traversePropertyPath - object does not have property ${s}, for path ${t}`);
+      return { obj: i.nextObj, objProp: s, nextObj: i.nextObj[s] };
+    }, { nextObj: this.params }), { obj: r, objProp: a } = e;
+    if (!r || !a || !(r[a] instanceof n.Tensor)) throw new Error(`traversePropertyPath - parameter is not a tensor, for path ${t}`);
+    return { obj: r, objProp: a };
+  }
+};
+function S(o9, t, e) {
+  return n.tidy(() => {
+    let r = n.separableConv2d(o9, t.depthwise_filter, t.pointwise_filter, e, "same");
+    return r = n.add(r, t.bias), r;
+  });
+}
+function xe(o9, t, e = false) {
+  return n.tidy(() => {
+    let r = n.relu(e ? n.add(n.conv2d(o9, t.conv0.filters, [2, 2], "same"), t.conv0.bias) : S(o9, t.conv0, [2, 2])), a = S(r, t.conv1, [1, 1]), i = n.relu(n.add(r, a)), s = S(i, t.conv2, [1, 1]);
+    return n.relu(n.add(r, n.add(a, s)));
+  });
+}
+function ne(o9, t, e = false, r = true) {
+  return n.tidy(() => {
+    let a = n.relu(e ? n.add(n.conv2d(o9, t.conv0.filters, r ? [2, 2] : [1, 1], "same"), t.conv0.bias) : S(o9, t.conv0, r ? [2, 2] : [1, 1])), i = S(a, t.conv1, [1, 1]), s = n.relu(n.add(a, i)), c = S(s, t.conv2, [1, 1]), m = n.relu(n.add(a, n.add(i, c))), p = S(m, t.conv3, [1, 1]);
+    return n.relu(n.add(a, n.add(i, n.add(c, p))));
+  });
+}
+function vt(o9, t, e = "same", r = false) {
+  return n.tidy(() => {
+    let a = n.add(n.conv2d(o9, t.filters, [1, 1], e), t.bias);
+    return r ? n.relu(a) : a;
+  });
+}
+function N(o9, t) {
+  Object.keys(o9).forEach((e) => {
+    t.some((r) => r.originalPath === e) || o9[e].dispose();
+  });
+}
+function Rt(o9, t) {
+  return (e, r, a, i) => {
+    let s = n.tensor4d(o9(e * r * a * a), [a, a, e, r]), c = n.tensor1d(o9(r));
+    return t.push({ paramPath: `${i}/filters` }, { paramPath: `${i}/bias` }), { filters: s, bias: c };
+  };
+}
+function ve(o9, t) {
+  return (e, r, a) => {
+    let i = n.tensor2d(o9(e * r), [e, r]), s = n.tensor1d(o9(r));
+    return t.push({ paramPath: `${a}/weights` }, { paramPath: `${a}/bias` }), { weights: i, bias: s };
+  };
+}
+var ae = class {
+  constructor(t, e, r) {
+    this.depthwise_filter = t;
+    this.pointwise_filter = e;
+    this.bias = r;
+  }
+};
+function $t(o9, t) {
+  return (e, r, a) => {
+    let i = n.tensor4d(o9(9 * e), [3, 3, e, 1]), s = n.tensor4d(o9(e * r), [1, 1, e, r]), c = n.tensor1d(o9(r));
+    return t.push({ paramPath: `${a}/depthwise_filter` }, { paramPath: `${a}/pointwise_filter` }, { paramPath: `${a}/bias` }), new ae(i, s, c);
+  };
+}
+function Ot(o9) {
+  return (t) => {
+    let e = o9(`${t}/depthwise_filter`, 4), r = o9(`${t}/pointwise_filter`, 4), a = o9(`${t}/bias`, 1);
+    return new ae(e, r, a);
+  };
+}
+function k(o9, t) {
+  return (e, r, a) => {
+    let i = o9[e];
+    if (!dt(i, r)) throw new Error(`expected weightMap[${e}] to be a Tensor${r}D, instead have ${i}`);
+    return t.push({ originalPath: e, paramPath: a || e }), i;
+  };
+}
+function L(o9) {
+  let t = o9;
+  function e(a) {
+    let i = t.slice(0, a);
+    return t = t.slice(a), i;
+  }
+  function r() {
+    return t;
+  }
+  return { extractWeights: e, getRemainingWeights: r };
+}
+function ye(o9, t) {
+  let e = Rt(o9, t), r = $t(o9, t);
+  function a(s, c, m, p = false) {
+    let u = p ? e(s, c, 3, `${m}/conv0`) : r(s, c, `${m}/conv0`), f = r(c, c, `${m}/conv1`), l = r(c, c, `${m}/conv2`);
+    return { conv0: u, conv1: f, conv2: l };
+  }
+  function i(s, c, m, p = false) {
+    let { conv0: u, conv1: f, conv2: l } = a(s, c, m, p), d = r(c, c, `${m}/conv3`);
+    return { conv0: u, conv1: f, conv2: l, conv3: d };
+  }
+  return { extractDenseBlock3Params: a, extractDenseBlock4Params: i };
+}
+function Er(o9) {
+  let t = [], { extractWeights: e, getRemainingWeights: r } = L(o9), { extractDenseBlock4Params: a } = ye(e, t), i = a(3, 32, "dense0", true), s = a(32, 64, "dense1"), c = a(64, 128, "dense2"), m = a(128, 256, "dense3");
+  if (r().length !== 0) throw new Error(`weights remaing after extract: ${r().length}`);
+  return { paramMappings: t, params: { dense0: i, dense1: s, dense2: c, dense3: m } };
+}
+function Te(o9) {
+  return (t) => {
+    let e = o9(`${t}/filters`, 4), r = o9(`${t}/bias`, 1);
+    return { filters: e, bias: r };
+  };
+}
+function _e(o9, t) {
+  let e = k(o9, t), r = Te(e), a = Ot(e);
+  function i(c, m = false) {
+    let p = m ? r(`${c}/conv0`) : a(`${c}/conv0`), u = a(`${c}/conv1`), f = a(`${c}/conv2`);
+    return { conv0: p, conv1: u, conv2: f };
+  }
+  function s(c, m = false) {
+    let p = m ? r(`${c}/conv0`) : a(`${c}/conv0`), u = a(`${c}/conv1`), f = a(`${c}/conv2`), l = a(`${c}/conv3`);
+    return { conv0: p, conv1: u, conv2: f, conv3: l };
+  }
+  return { extractDenseBlock3Params: i, extractDenseBlock4Params: s };
+}
+function Mr(o9) {
+  let t = [], { extractDenseBlock4Params: e } = _e(o9, t), r = { dense0: e("dense0", true), dense1: e("dense1"), dense2: e("dense2"), dense3: e("dense3") };
+  return N(o9, t), { params: r, paramMappings: t };
+}
+var Ht = class extends I {
+  constructor() {
+    super("FaceFeatureExtractor");
+  }
+  forwardInput(t) {
+    let { params: e } = this;
+    if (!e) throw new Error("FaceFeatureExtractor - load model before inference");
+    return n.tidy(() => {
+      let r = n.cast(t.toBatchTensor(112, true), "float32"), i = J(r, [122.782, 117.001, 104.298]).div(255), s = ne(i, e.dense0, true);
+      return s = ne(s, e.dense1), s = ne(s, e.dense2), s = ne(s, e.dense3), s = n.avgPool(s, [7, 7], [2, 2], "valid"), s;
+    });
+  }
+  async forward(t) {
+    return this.forwardInput(await F(t));
+  }
+  getDefaultModelName() {
+    return "face_feature_extractor_model";
+  }
+  extractParamsFromWeightMap(t) {
+    return Mr(t);
+  }
+  extractParams(t) {
+    return Er(t);
+  }
+};
+function se(o9, t) {
+  return n.tidy(() => n.add(n.matMul(o9, t.weights), t.bias));
+}
+function Cr(o9, t, e) {
+  let r = [], { extractWeights: a, getRemainingWeights: i } = L(o9), c = ve(a, r)(t, e, "fc");
+  if (i().length !== 0) throw new Error(`weights remaing after extract: ${i().length}`);
+  return { paramMappings: r, params: { fc: c } };
+}
+function Ir(o9) {
+  let t = [], e = k(o9, t);
+  function r(i) {
+    let s = e(`${i}/weights`, 2), c = e(`${i}/bias`, 1);
+    return { weights: s, bias: c };
+  }
+  let a = { fc: r("fc") };
+  return N(o9, t), { params: a, paramMappings: t };
+}
+function Pe(o9) {
+  let t = {}, e = {};
+  return Object.keys(o9).forEach((r) => {
+    let a = r.startsWith("fc") ? e : t;
+    a[r] = o9[r];
+  }), { featureExtractorMap: t, classifierMap: e };
+}
+var zt = class extends I {
+  constructor(t, e) {
+    super(t), this._faceFeatureExtractor = e;
+  }
+  get faceFeatureExtractor() {
+    return this._faceFeatureExtractor;
+  }
+  runNet(t) {
+    let { params: e } = this;
+    if (!e) throw new Error(`${this._name} - load model before inference`);
+    return n.tidy(() => {
+      let r = t instanceof tt ? this.faceFeatureExtractor.forwardInput(t) : t;
+      return se(r.as2D(r.shape[0], -1), e.fc);
+    });
+  }
+  dispose(t = true) {
+    this.faceFeatureExtractor.dispose(t), super.dispose(t);
+  }
+  loadClassifierParams(t) {
+    let { params: e, paramMappings: r } = this.extractClassifierParams(t);
+    this._params = e, this._paramMappings = r;
+  }
+  extractClassifierParams(t) {
+    return Cr(t, this.getClassifierChannelsIn(), this.getClassifierChannelsOut());
+  }
+  extractParamsFromWeightMap(t) {
+    let { featureExtractorMap: e, classifierMap: r } = Pe(t);
+    return this.faceFeatureExtractor.loadFromWeightMap(e), Ir(r);
+  }
+  extractParams(t) {
+    let e = this.getClassifierChannelsIn(), r = this.getClassifierChannelsOut(), a = r * e + r, i = t.slice(0, t.length - a), s = t.slice(t.length - a);
+    return this.faceFeatureExtractor.extractWeights(i), this.extractClassifierParams(s);
+  }
+};
+var Nr = ["neutral", "happy", "sad", "angry", "fearful", "disgusted", "surprised"], it = class {
+  constructor(t) {
+    this.neutral = 0;
+    this.happy = 0;
+    this.sad = 0;
+    this.angry = 0;
+    this.fearful = 0;
+    this.disgusted = 0;
+    this.surprised = 0;
+    if (t.length !== 7) throw new Error(`FaceExpressions.constructor - expected probabilities.length to be 7, have: ${t.length}`);
+    Nr.forEach((e, r) => {
+      this[e] = t[r];
+    });
+  }
+  asSortedArray() {
+    return Nr.map((t) => ({ expression: t, probability: this[t] })).sort((t, e) => e.probability - t.probability);
+  }
+};
+var we = class extends zt {
+  constructor(t = new Ht()) {
+    super("FaceExpressionNet", t);
+  }
+  forwardInput(t) {
+    return n.tidy(() => n.softmax(this.runNet(t)));
+  }
+  async forward(t) {
+    return this.forwardInput(await F(t));
+  }
+  async predictExpressions(t) {
+    let e = await F(t), r = await this.forwardInput(e), a = await Promise.all(n.unstack(r).map(async (s) => {
+      let c = s.dataSync();
+      return s.dispose(), c;
+    }));
+    r.dispose();
+    let i = a.map((s) => new it(s));
+    return e.isBatchInput ? i : i[0];
+  }
+  getDefaultModelName() {
+    return "face_expression_model";
+  }
+  getClassifierChannelsIn() {
+    return 256;
+  }
+  getClassifierChannelsOut() {
+    return 7;
+  }
+};
+function Lr(o9) {
+  return o9.expressions instanceof it;
+}
+function tr(o9, t) {
+  return { ...o9, ...{ expressions: t } };
+}
+function No(o9, t, e = 0.1, r) {
+  (Array.isArray(t) ? t : [t]).forEach((i) => {
+    let s = i instanceof it ? i : Lr(i) ? i.expressions : void 0;
+    if (!s) throw new Error("drawFaceExpressions - expected faceExpressions to be FaceExpressions | WithFaceExpressions<{}> or array thereof");
+    let m = s.asSortedArray().filter((f) => f.probability > e), p = Q(i) ? i.detection.box.bottomLeft : r || new v(0, 0);
+    new xt(m.map((f) => `${f.expression} (${ht(f.probability)})`), p).draw(o9);
+  });
+}
+function Yt(o9) {
+  return Q(o9) && o9.landmarks instanceof $ && o9.unshiftedLandmarks instanceof $ && o9.alignedRect instanceof D;
+}
+function Lo(o9) {
+  let t = (m) => m * 180 / Math.PI, e = (m, p) => Math.sqrt((m.x - p.x) ** 2 + (m.y - p.y) ** 2), r = { roll: void 0, pitch: void 0, yaw: void 0 }, a = (m, p, u) => {
+    let f = Math.floor(m.x - p.x), l = Math.floor(p.x - u.x);
+    return f - l;
+  }, i = (m, p) => {
+    let u = Math.hypot(p.x - m.x, p.y - m.y), f = p.y - m.y, l = Math.asin(f / u), d = t(l), b = Math.floor(90 - d), y = p.x - m.x < 0 ? -1 : 1;
+    return b * y;
+  }, s = (m, p, u) => {
+    let f = e(m, u), l = new v((m.x + u.x) / 2, (m.y + u.y) / 2), d = e(p, l), b = Math.atan(d / f), y = Math.floor(t(b)), h = l.y - p.y < 0 ? -1 : 1;
+    return y * h;
+  };
+  if (!o9 || !o9.positions || o9.positions.length !== 68) return r;
+  let c = o9.positions;
+  return r.roll = i(c[27], c[66]), r.pitch = s(c[14], c[30], c[2]), r.yaw = a(c[14], c[33], c[2]), r;
+}
+function ie(o9, t) {
+  let { box: e } = o9.detection, r = t.shiftBy(e.x, e.y), a = r.align(), { imageDims: i } = o9.detection, s = new D(o9.detection.score, a.rescale(i.reverse()), i), c = Lo(t);
+  return { ...o9, ...{ landmarks: r, unshiftedLandmarks: t, alignedRect: s, angle: c } };
+}
+var Fe = class {
+  constructor(t = {}) {
+    let { drawLines: e = true, drawPoints: r = true, lineWidth: a, lineColor: i, pointSize: s, pointColor: c } = t;
+    this.drawLines = e, this.drawPoints = r, this.lineWidth = a || 1, this.pointSize = s || 2, this.lineColor = i || "rgba(0, 255, 255, 1)", this.pointColor = c || "rgba(255, 0, 255, 1)";
+  }
+}, De = class {
+  constructor(t, e = {}) {
+    this.faceLandmarks = t, this.options = new Fe(e);
+  }
+  draw(t) {
+    let e = W(t), { drawLines: r, drawPoints: a, lineWidth: i, lineColor: s, pointSize: c, pointColor: m } = this.options;
+    if (r && this.faceLandmarks instanceof Lt && (e.strokeStyle = s, e.lineWidth = i, Z(e, this.faceLandmarks.getJawOutline()), Z(e, this.faceLandmarks.getLeftEyeBrow()), Z(e, this.faceLandmarks.getRightEyeBrow()), Z(e, this.faceLandmarks.getNose()), Z(e, this.faceLandmarks.getLeftEye(), true), Z(e, this.faceLandmarks.getRightEye(), true), Z(e, this.faceLandmarks.getMouth(), true)), a) {
+      e.strokeStyle = m, e.fillStyle = m;
+      let p = (u) => {
+        e.beginPath(), e.arc(u.x, u.y, c, 0, 2 * Math.PI), e.fill();
+      };
+      this.faceLandmarks.positions.forEach(p);
+    }
+  }
+};
+function So(o9, t) {
+  (Array.isArray(t) ? t : [t]).forEach((r) => {
+    let a = r instanceof $ ? r : Yt(r) ? r.landmarks : void 0;
+    if (!a) throw new Error("drawFaceLandmarks - expected faceExpressions to be FaceLandmarks | WithFaceLandmarks<WithFaceDetection<{}>> or array thereof");
+    new De(a).draw(o9);
+  });
+}
+var Ar = "1.7.15";
+function ko(o9, t) {
+  let e = Rt(o9, t), r = $t(o9, t);
+  function a(s, c, m) {
+    let p = r(s, c, `${m}/separable_conv0`), u = r(c, c, `${m}/separable_conv1`), f = e(s, c, 1, `${m}/expansion_conv`);
+    return { separable_conv0: p, separable_conv1: u, expansion_conv: f };
+  }
+  function i(s, c) {
+    let m = r(s, s, `${c}/separable_conv0`), p = r(s, s, `${c}/separable_conv1`), u = r(s, s, `${c}/separable_conv2`);
+    return { separable_conv0: m, separable_conv1: p, separable_conv2: u };
+  }
+  return { extractConvParams: e, extractSeparableConvParams: r, extractReductionBlockParams: a, extractMainBlockParams: i };
+}
+function Wr(o9, t) {
+  let e = [], { extractWeights: r, getRemainingWeights: a } = L(o9), { extractConvParams: i, extractSeparableConvParams: s, extractReductionBlockParams: c, extractMainBlockParams: m } = ko(r, e), p = i(3, 32, 3, "entry_flow/conv_in"), u = c(32, 64, "entry_flow/reduction_block_0"), f = c(64, 128, "entry_flow/reduction_block_1"), l = { conv_in: p, reduction_block_0: u, reduction_block_1: f }, d = {};
+  X(t, 0, 1).forEach((g) => {
+    d[`main_block_${g}`] = m(128, `middle_flow/main_block_${g}`);
+  });
+  let b = c(128, 256, "exit_flow/reduction_block"), y = s(256, 512, "exit_flow/separable_conv"), h = { reduction_block: b, separable_conv: y };
+  if (a().length !== 0) throw new Error(`weights remaing after extract: ${a().length}`);
+  return { paramMappings: e, params: { entry_flow: l, middle_flow: d, exit_flow: h } };
+}
+function Bo(o9, t) {
+  let e = k(o9, t), r = Te(e), a = Ot(e);
+  function i(c) {
+    let m = a(`${c}/separable_conv0`), p = a(`${c}/separable_conv1`), u = r(`${c}/expansion_conv`);
+    return { separable_conv0: m, separable_conv1: p, expansion_conv: u };
+  }
+  function s(c) {
+    let m = a(`${c}/separable_conv0`), p = a(`${c}/separable_conv1`), u = a(`${c}/separable_conv2`);
+    return { separable_conv0: m, separable_conv1: p, separable_conv2: u };
+  }
+  return { extractConvParams: r, extractSeparableConvParams: a, extractReductionBlockParams: i, extractMainBlockParams: s };
+}
+function kr(o9, t) {
+  let e = [], { extractConvParams: r, extractSeparableConvParams: a, extractReductionBlockParams: i, extractMainBlockParams: s } = Bo(o9, e), c = r("entry_flow/conv_in"), m = i("entry_flow/reduction_block_0"), p = i("entry_flow/reduction_block_1"), u = { conv_in: c, reduction_block_0: m, reduction_block_1: p }, f = {};
+  X(t, 0, 1).forEach((y) => {
+    f[`main_block_${y}`] = s(`middle_flow/main_block_${y}`);
+  });
+  let l = i("exit_flow/reduction_block"), d = a("exit_flow/separable_conv"), b = { reduction_block: l, separable_conv: d };
+  return N(o9, e), { params: { entry_flow: u, middle_flow: f, exit_flow: b }, paramMappings: e };
+}
+function Br(o9, t, e) {
+  return n.add(n.conv2d(o9, t.filters, e, "same"), t.bias);
+}
+function er(o9, t, e = true) {
+  let r = e ? n.relu(o9) : o9;
+  return r = S(r, t.separable_conv0, [1, 1]), r = S(n.relu(r), t.separable_conv1, [1, 1]), r = n.maxPool(r, [3, 3], [2, 2], "same"), r = n.add(r, Br(o9, t.expansion_conv, [2, 2])), r;
+}
+function Ro(o9, t) {
+  let e = S(n.relu(o9), t.separable_conv0, [1, 1]);
+  return e = S(n.relu(e), t.separable_conv1, [1, 1]), e = S(n.relu(e), t.separable_conv2, [1, 1]), e = n.add(e, o9), e;
+}
+var Ee = class extends I {
+  constructor(t) {
+    super("TinyXception"), this._numMainBlocks = t;
+  }
+  forwardInput(t) {
+    let { params: e } = this;
+    if (!e) throw new Error("TinyXception - load model before inference");
+    return n.tidy(() => {
+      let r = n.cast(t.toBatchTensor(112, true), "float32"), i = J(r, [122.782, 117.001, 104.298]).div(255), s = n.relu(Br(i, e.entry_flow.conv_in, [2, 2]));
+      return s = er(s, e.entry_flow.reduction_block_0, false), s = er(s, e.entry_flow.reduction_block_1), X(this._numMainBlocks, 0, 1).forEach((c) => {
+        s = Ro(s, e.middle_flow[`main_block_${c}`]);
+      }), s = er(s, e.exit_flow.reduction_block), s = n.relu(S(s, e.exit_flow.separable_conv, [1, 1])), s;
+    });
+  }
+  async forward(t) {
+    return this.forwardInput(await F(t));
+  }
+  getDefaultModelName() {
+    return "tiny_xception_model";
+  }
+  extractParamsFromWeightMap(t) {
+    return kr(t, this._numMainBlocks);
+  }
+  extractParams(t) {
+    return Wr(t, this._numMainBlocks);
+  }
+};
+function Rr(o9) {
+  let t = [], { extractWeights: e, getRemainingWeights: r } = L(o9), a = ve(e, t), i = a(512, 1, "fc/age"), s = a(512, 2, "fc/gender");
+  if (r().length !== 0) throw new Error(`weights remaing after extract: ${r().length}`);
+  return { paramMappings: t, params: { fc: { age: i, gender: s } } };
+}
+function $r(o9) {
+  let t = [], e = k(o9, t);
+  function r(i) {
+    let s = e(`${i}/weights`, 2), c = e(`${i}/bias`, 1);
+    return { weights: s, bias: c };
+  }
+  let a = { fc: { age: r("fc/age"), gender: r("fc/gender") } };
+  return N(o9, t), { params: a, paramMappings: t };
+}
+var rr = ((e) => (e.FEMALE = "female", e.MALE = "male", e))(rr || {});
+var Me = class extends I {
+  constructor(t = new Ee(2)) {
+    super("AgeGenderNet"), this._faceFeatureExtractor = t;
+  }
+  get faceFeatureExtractor() {
+    return this._faceFeatureExtractor;
+  }
+  runNet(t) {
+    let { params: e } = this;
+    if (!e) throw new Error(`${this._name} - load model before inference`);
+    return n.tidy(() => {
+      let r = t instanceof tt ? this.faceFeatureExtractor.forwardInput(t) : t, a = n.avgPool(r, [7, 7], [2, 2], "valid").as2D(r.shape[0], -1), i = se(a, e.fc.age).as1D(), s = se(a, e.fc.gender);
+      return { age: i, gender: s };
+    });
+  }
+  forwardInput(t) {
+    return n.tidy(() => {
+      let { age: e, gender: r } = this.runNet(t);
+      return { age: e, gender: n.softmax(r) };
+    });
+  }
+  async forward(t) {
+    return this.forwardInput(await F(t));
+  }
+  async predictAgeAndGender(t) {
+    let e = await F(t), r = await this.forwardInput(e), a = n.unstack(r.age), i = n.unstack(r.gender), s = a.map((m, p) => ({ ageTensor: m, genderTensor: i[p] })), c = await Promise.all(s.map(async ({ ageTensor: m, genderTensor: p }) => {
+      let u = m.dataSync()[0], f = p.dataSync()[0], l = f > 0.5, d = l ? "male" : "female", b = l ? f : 1 - f;
+      return m.dispose(), p.dispose(), { age: u, gender: d, genderProbability: b };
+    }));
+    return r.age.dispose(), r.gender.dispose(), e.isBatchInput ? c : c[0];
+  }
+  getDefaultModelName() {
+    return "age_gender_model";
+  }
+  dispose(t = true) {
+    this.faceFeatureExtractor.dispose(t), super.dispose(t);
+  }
+  loadClassifierParams(t) {
+    let { params: e, paramMappings: r } = this.extractClassifierParams(t);
+    this._params = e, this._paramMappings = r;
+  }
+  extractClassifierParams(t) {
+    return Rr(t);
+  }
+  extractParamsFromWeightMap(t) {
+    let { featureExtractorMap: e, classifierMap: r } = Pe(t);
+    return this.faceFeatureExtractor.loadFromWeightMap(e), $r(r);
+  }
+  extractParams(t) {
+    let r = t.slice(0, t.length - 1539), a = t.slice(t.length - 1539);
+    return this.faceFeatureExtractor.extractWeights(r), this.extractClassifierParams(a);
+  }
+};
+var Vt = class extends zt {
+  postProcess(t, e, r) {
+    let a = r.map(({ width: s, height: c }) => {
+      let m = e / Math.max(c, s);
+      return { width: s * m, height: c * m };
+    }), i = a.length;
+    return n.tidy(() => {
+      let s = (f, l) => n.stack([n.fill([68], f, "float32"), n.fill([68], l, "float32")], 1).as2D(1, 136).as1D(), c = (f, l) => {
+        let { width: d, height: b } = a[f];
+        return l(d, b) ? Math.abs(d - b) / 2 : 0;
+      }, m = (f) => c(f, (l, d) => l < d), p = (f) => c(f, (l, d) => d < l);
+      return t.mul(n.fill([i, 136], e, "float32")).sub(n.stack(Array.from(Array(i), (f, l) => s(m(l), p(l))))).div(n.stack(Array.from(Array(i), (f, l) => s(a[l].width, a[l].height))));
+    });
+  }
+  forwardInput(t) {
+    return n.tidy(() => {
+      let e = this.runNet(t);
+      return this.postProcess(e, t.inputSize, t.inputDimensions.map(([r, a]) => ({ height: r, width: a })));
+    });
+  }
+  async forward(t) {
+    return this.forwardInput(await F(t));
+  }
+  async detectLandmarks(t) {
+    let e = await F(t), r = n.tidy(() => n.unstack(this.forwardInput(e))), a = await Promise.all(r.map(async (i, s) => {
+      let c = Array.from(i.dataSync()), m = c.filter((u, f) => pe(f)), p = c.filter((u, f) => !pe(f));
+      return new Lt(Array(68).fill(0).map((u, f) => new v(m[f], p[f])), { height: e.getInputHeight(s), width: e.getInputWidth(s) });
+    }));
+    return r.forEach((i) => i.dispose()), e.isBatchInput ? a : a[0];
+  }
+  getClassifierChannelsOut() {
+    return 136;
+  }
+};
+var Gt = class extends Vt {
+  constructor(t = new Ht()) {
+    super("FaceLandmark68Net", t);
+  }
+  getDefaultModelName() {
+    return "face_landmark_68_model";
+  }
+  getClassifierChannelsIn() {
+    return 256;
+  }
+};
+function Or(o9) {
+  let t = [], { extractDenseBlock3Params: e } = _e(o9, t), r = { dense0: e("dense0", true), dense1: e("dense1"), dense2: e("dense2") };
+  return N(o9, t), { params: r, paramMappings: t };
+}
+function Hr(o9) {
+  let t = [], { extractWeights: e, getRemainingWeights: r } = L(o9), { extractDenseBlock3Params: a } = ye(e, t), i = a(3, 32, "dense0", true), s = a(32, 64, "dense1"), c = a(64, 128, "dense2");
+  if (r().length !== 0) throw new Error(`weights remaing after extract: ${r().length}`);
+  return { paramMappings: t, params: { dense0: i, dense1: s, dense2: c } };
+}
+var Ce = class extends I {
+  constructor() {
+    super("TinyFaceFeatureExtractor");
+  }
+  forwardInput(t) {
+    let { params: e } = this;
+    if (!e) throw new Error("TinyFaceFeatureExtractor - load model before inference");
+    return n.tidy(() => {
+      let r = n.cast(t.toBatchTensor(112, true), "float32"), i = J(r, [122.782, 117.001, 104.298]).div(255), s = xe(i, e.dense0, true);
+      return s = xe(s, e.dense1), s = xe(s, e.dense2), s = n.avgPool(s, [14, 14], [2, 2], "valid"), s;
+    });
+  }
+  async forward(t) {
+    return this.forwardInput(await F(t));
+  }
+  getDefaultModelName() {
+    return "face_feature_extractor_tiny_model";
+  }
+  extractParamsFromWeightMap(t) {
+    return Or(t);
+  }
+  extractParams(t) {
+    return Hr(t);
+  }
+};
+var Ie = class extends Vt {
+  constructor(t = new Ce()) {
+    super("FaceLandmark68TinyNet", t);
+  }
+  getDefaultModelName() {
+    return "face_landmark_68_tiny_model";
+  }
+  getClassifierChannelsIn() {
+    return 128;
+  }
+};
+var zr = class extends Gt {
+};
+function Yr(o9, t) {
+  return n.add(n.mul(o9, t.weights), t.biases);
+}
+function or(o9, t, e, r, a = "same") {
+  let { filters: i, bias: s } = t.conv, c = n.conv2d(o9, i, e, a);
+  return c = n.add(c, s), c = Yr(c, t.scale), r ? n.relu(c) : c;
+}
+function Vr(o9, t) {
+  return or(o9, t, [1, 1], true);
+}
+function nr(o9, t) {
+  return or(o9, t, [1, 1], false);
+}
+function Ne(o9, t) {
+  return or(o9, t, [2, 2], true, "valid");
+}
+function $o(o9, t) {
+  function e(c, m, p) {
+    let u = o9(c), f = u.length / (m * p * p);
+    if (Ge(f)) throw new Error(`depth has to be an integer: ${f}, weights.length: ${u.length}, numFilters: ${m}, filterSize: ${p}`);
+    return n.tidy(() => n.transpose(n.tensor4d(u, [m, f, p, p]), [2, 3, 1, 0]));
+  }
+  function r(c, m, p, u) {
+    let f = e(c, m, p), l = n.tensor1d(o9(m));
+    return t.push({ paramPath: `${u}/filters` }, { paramPath: `${u}/bias` }), { filters: f, bias: l };
+  }
+  function a(c, m) {
+    let p = n.tensor1d(o9(c)), u = n.tensor1d(o9(c));
+    return t.push({ paramPath: `${m}/weights` }, { paramPath: `${m}/biases` }), { weights: p, biases: u };
+  }
+  function i(c, m, p, u) {
+    let f = r(c, m, p, `${u}/conv`), l = a(m, `${u}/scale`);
+    return { conv: f, scale: l };
+  }
+  function s(c, m, p, u, f = false) {
+    let l = i((f ? 0.5 : 1) * c, m, p, `${u}/conv1`), d = i(c, m, p, `${u}/conv2`);
+    return { conv1: l, conv2: d };
+  }
+  return { extractConvLayerParams: i, extractResidualLayerParams: s };
+}
+function Gr(o9) {
+  let { extractWeights: t, getRemainingWeights: e } = L(o9), r = [], { extractConvLayerParams: a, extractResidualLayerParams: i } = $o(t, r), s = a(4704, 32, 7, "conv32_down"), c = i(9216, 32, 3, "conv32_1"), m = i(9216, 32, 3, "conv32_2"), p = i(9216, 32, 3, "conv32_3"), u = i(36864, 64, 3, "conv64_down", true), f = i(36864, 64, 3, "conv64_1"), l = i(36864, 64, 3, "conv64_2"), d = i(36864, 64, 3, "conv64_3"), b = i(147456, 128, 3, "conv128_down", true), y = i(147456, 128, 3, "conv128_1"), h = i(147456, 128, 3, "conv128_2"), g = i(589824, 256, 3, "conv256_down", true), T = i(589824, 256, 3, "conv256_1"), x = i(589824, 256, 3, "conv256_2"), E = i(589824, 256, 3, "conv256_down_out"), B = n.tidy(() => n.transpose(n.tensor2d(t(256 * 128), [128, 256]), [1, 0]));
+  if (r.push({ paramPath: "fc" }), e().length !== 0) throw new Error(`weights remaing after extract: ${e().length}`);
+  return { params: { conv32_down: s, conv32_1: c, conv32_2: m, conv32_3: p, conv64_down: u, conv64_1: f, conv64_2: l, conv64_3: d, conv128_down: b, conv128_1: y, conv128_2: h, conv256_down: g, conv256_1: T, conv256_2: x, conv256_down_out: E, fc: B }, paramMappings: r };
+}
+function Oo(o9, t) {
+  let e = k(o9, t);
+  function r(s) {
+    let c = e(`${s}/scale/weights`, 1), m = e(`${s}/scale/biases`, 1);
+    return { weights: c, biases: m };
+  }
+  function a(s) {
+    let c = e(`${s}/conv/filters`, 4), m = e(`${s}/conv/bias`, 1), p = r(s);
+    return { conv: { filters: c, bias: m }, scale: p };
+  }
+  function i(s) {
+    return { conv1: a(`${s}/conv1`), conv2: a(`${s}/conv2`) };
+  }
+  return { extractConvLayerParams: a, extractResidualLayerParams: i };
+}
+function jr(o9) {
+  let t = [], { extractConvLayerParams: e, extractResidualLayerParams: r } = Oo(o9, t), a = e("conv32_down"), i = r("conv32_1"), s = r("conv32_2"), c = r("conv32_3"), m = r("conv64_down"), p = r("conv64_1"), u = r("conv64_2"), f = r("conv64_3"), l = r("conv128_down"), d = r("conv128_1"), b = r("conv128_2"), y = r("conv256_down"), h = r("conv256_1"), g = r("conv256_2"), T = r("conv256_down_out"), { fc: x } = o9;
+  if (t.push({ originalPath: "fc", paramPath: "fc" }), !Ve(x)) throw new Error(`expected weightMap[fc] to be a Tensor2D, instead have ${x}`);
+  let E = { conv32_down: a, conv32_1: i, conv32_2: s, conv32_3: c, conv64_down: m, conv64_1: p, conv64_2: u, conv64_3: f, conv128_down: l, conv128_1: d, conv128_2: b, conv256_down: y, conv256_1: h, conv256_2: g, conv256_down_out: T, fc: x };
+  return N(o9, t), { params: E, paramMappings: t };
+}
+function j(o9, t) {
+  let e = Vr(o9, t.conv1);
+  return e = nr(e, t.conv2), e = n.add(e, o9), e = n.relu(e), e;
+}
+function ce(o9, t) {
+  let e = Ne(o9, t.conv1);
+  e = nr(e, t.conv2);
+  let r = n.avgPool(o9, 2, 2, "valid"), a = n.zeros(r.shape), i = r.shape[3] !== e.shape[3];
+  if (r.shape[1] !== e.shape[1] || r.shape[2] !== e.shape[2]) {
+    let c = [...e.shape];
+    c[1] = 1;
+    let m = n.zeros(c);
+    e = n.concat([e, m], 1);
+    let p = [...e.shape];
+    p[2] = 1;
+    let u = n.zeros(p);
+    e = n.concat([e, u], 2);
+  }
+  return r = i ? n.concat([r, a], 3) : r, e = n.add(r, e), e = n.relu(e), e;
+}
+var jt = class extends I {
+  constructor() {
+    super("FaceRecognitionNet");
+  }
+  forwardInput(t) {
+    let { params: e } = this;
+    if (!e) throw new Error("FaceRecognitionNet - load model before inference");
+    return n.tidy(() => {
+      let r = n.cast(t.toBatchTensor(150, true), "float32"), i = J(r, [122.782, 117.001, 104.298]).div(255), s = Ne(i, e.conv32_down);
+      s = n.maxPool(s, 3, 2, "valid"), s = j(s, e.conv32_1), s = j(s, e.conv32_2), s = j(s, e.conv32_3), s = ce(s, e.conv64_down), s = j(s, e.conv64_1), s = j(s, e.conv64_2), s = j(s, e.conv64_3), s = ce(s, e.conv128_down), s = j(s, e.conv128_1), s = j(s, e.conv128_2), s = ce(s, e.conv256_down), s = j(s, e.conv256_1), s = j(s, e.conv256_2), s = ce(s, e.conv256_down_out);
+      let c = s.mean([1, 2]);
+      return n.matMul(c, e.fc);
+    });
+  }
+  async forward(t) {
+    return this.forwardInput(await F(t));
+  }
+  async computeFaceDescriptor(t) {
+    var i;
+    if ((i = t == null ? void 0 : t.shape) != null && i.some((s) => s <= 0)) return new Float32Array(128);
+    let e = await F(t), r = n.tidy(() => n.unstack(this.forwardInput(e))), a = await Promise.all(r.map((s) => s.data()));
+    return r.forEach((s) => s.dispose()), e.isBatchInput ? a : a[0];
+  }
+  getDefaultModelName() {
+    return "face_recognition_model";
+  }
+  extractParamsFromWeightMap(t) {
+    return jr(t);
+  }
+  extractParams(t) {
+    return Gr(t);
+  }
+};
+function gf(o9) {
+  let t = new jt();
+  return t.extractWeights(o9), t;
+}
+function ar(o9, t) {
+  return { ...o9, ...{ descriptor: t } };
+}
+function Tf(o9) {
+  return typeof o9.age == "number";
+}
+function sr(o9, t) {
+  return { ...o9, ...{ age: t } };
+}
+function Ff(o9) {
+  return (o9.gender === "male" || o9.gender === "female") && Mt(o9.genderProbability);
+}
+function ir(o9, t, e) {
+  return { ...o9, ...{ gender: t, genderProbability: e } };
+}
+function Ho(o9, t) {
+  function e(m, p) {
+    let u = n.tensor4d(o9(9 * m), [3, 3, m, 1]), f = n.tensor1d(o9(m)), l = n.tensor1d(o9(m)), d = n.tensor1d(o9(m)), b = n.tensor1d(o9(m));
+    return t.push({ paramPath: `${p}/filters` }, { paramPath: `${p}/batch_norm_scale` }, { paramPath: `${p}/batch_norm_offset` }, { paramPath: `${p}/batch_norm_mean` }, { paramPath: `${p}/batch_norm_variance` }), { filters: u, batch_norm_scale: f, batch_norm_offset: l, batch_norm_mean: d, batch_norm_variance: b };
+  }
+  function r(m, p, u, f, l) {
+    let d = n.tensor4d(o9(m * p * u * u), [u, u, m, p]), b = n.tensor1d(o9(p));
+    return t.push({ paramPath: `${f}/filters` }, { paramPath: `${f}/${l ? "batch_norm_offset" : "bias"}` }), { filters: d, bias: b };
+  }
+  function a(m, p, u, f) {
+    let { filters: l, bias: d } = r(m, p, u, f, true);
+    return { filters: l, batch_norm_offset: d };
+  }
+  function i(m, p, u) {
+    let f = e(m, `${u}/depthwise_conv`), l = a(m, p, 1, `${u}/pointwise_conv`);
+    return { depthwise_conv: f, pointwise_conv: l };
+  }
+  function s() {
+    let m = a(3, 32, 3, "mobilenetv1/conv_0"), p = i(32, 64, "mobilenetv1/conv_1"), u = i(64, 128, "mobilenetv1/conv_2"), f = i(128, 128, "mobilenetv1/conv_3"), l = i(128, 256, "mobilenetv1/conv_4"), d = i(256, 256, "mobilenetv1/conv_5"), b = i(256, 512, "mobilenetv1/conv_6"), y = i(512, 512, "mobilenetv1/conv_7"), h = i(512, 512, "mobilenetv1/conv_8"), g = i(512, 512, "mobilenetv1/conv_9"), T = i(512, 512, "mobilenetv1/conv_10"), x = i(512, 512, "mobilenetv1/conv_11"), E = i(512, 1024, "mobilenetv1/conv_12"), B = i(1024, 1024, "mobilenetv1/conv_13");
+    return { conv_0: m, conv_1: p, conv_2: u, conv_3: f, conv_4: l, conv_5: d, conv_6: b, conv_7: y, conv_8: h, conv_9: g, conv_10: T, conv_11: x, conv_12: E, conv_13: B };
+  }
+  function c() {
+    let m = a(1024, 256, 1, "prediction_layer/conv_0"), p = a(256, 512, 3, "prediction_layer/conv_1"), u = a(512, 128, 1, "prediction_layer/conv_2"), f = a(128, 256, 3, "prediction_layer/conv_3"), l = a(256, 128, 1, "prediction_layer/conv_4"), d = a(128, 256, 3, "prediction_layer/conv_5"), b = a(256, 64, 1, "prediction_layer/conv_6"), y = a(64, 128, 3, "prediction_layer/conv_7"), h = r(512, 12, 1, "prediction_layer/box_predictor_0/box_encoding_predictor"), g = r(512, 9, 1, "prediction_layer/box_predictor_0/class_predictor"), T = r(1024, 24, 1, "prediction_layer/box_predictor_1/box_encoding_predictor"), x = r(1024, 18, 1, "prediction_layer/box_predictor_1/class_predictor"), E = r(512, 24, 1, "prediction_layer/box_predictor_2/box_encoding_predictor"), B = r(512, 18, 1, "prediction_layer/box_predictor_2/class_predictor"), V = r(256, 24, 1, "prediction_layer/box_predictor_3/box_encoding_predictor"), U = r(256, 18, 1, "prediction_layer/box_predictor_3/class_predictor"), O = r(256, 24, 1, "prediction_layer/box_predictor_4/box_encoding_predictor"), ot = r(256, 18, 1, "prediction_layer/box_predictor_4/class_predictor"), nt = r(128, 24, 1, "prediction_layer/box_predictor_5/box_encoding_predictor"), at = r(128, 18, 1, "prediction_layer/box_predictor_5/class_predictor");
+    return { conv_0: m, conv_1: p, conv_2: u, conv_3: f, conv_4: l, conv_5: d, conv_6: b, conv_7: y, box_predictor_0: { box_encoding_predictor: h, class_predictor: g }, box_predictor_1: { box_encoding_predictor: T, class_predictor: x }, box_predictor_2: { box_encoding_predictor: E, class_predictor: B }, box_predictor_3: { box_encoding_predictor: V, class_predictor: U }, box_predictor_4: { box_encoding_predictor: O, class_predictor: ot }, box_predictor_5: { box_encoding_predictor: nt, class_predictor: at } };
+  }
+  return { extractMobilenetV1Params: s, extractPredictionLayerParams: c };
+}
+function Ur(o9) {
+  let t = [], { extractWeights: e, getRemainingWeights: r } = L(o9), { extractMobilenetV1Params: a, extractPredictionLayerParams: i } = Ho(e, t), s = a(), c = i(), p = { extra_dim: n.tensor3d(e(5118 * 4), [1, 5118, 4]) };
+  if (t.push({ paramPath: "output_layer/extra_dim" }), r().length !== 0) throw new Error(`weights remaing after extract: ${r().length}`);
+  return { params: { mobilenetv1: s, prediction_layer: c, output_layer: p }, paramMappings: t };
+}
+function zo(o9, t) {
+  let e = k(o9, t);
+  function r(p, u, f) {
+    let l = e(`${p}/Conv2d_${u}_pointwise/weights`, 4, `${f}/filters`), d = e(`${p}/Conv2d_${u}_pointwise/convolution_bn_offset`, 1, `${f}/batch_norm_offset`);
+    return { filters: l, batch_norm_offset: d };
+  }
+  function a(p) {
+    let u = `mobilenetv1/conv_${p}`, f = `MobilenetV1/Conv2d_${p}_depthwise`, l = `${u}/depthwise_conv`, d = `${u}/pointwise_conv`, b = e(`${f}/depthwise_weights`, 4, `${l}/filters`), y = e(`${f}/BatchNorm/gamma`, 1, `${l}/batch_norm_scale`), h = e(`${f}/BatchNorm/beta`, 1, `${l}/batch_norm_offset`), g = e(`${f}/BatchNorm/moving_mean`, 1, `${l}/batch_norm_mean`), T = e(`${f}/BatchNorm/moving_variance`, 1, `${l}/batch_norm_variance`);
+    return { depthwise_conv: { filters: b, batch_norm_scale: y, batch_norm_offset: h, batch_norm_mean: g, batch_norm_variance: T }, pointwise_conv: r("MobilenetV1", p, d) };
+  }
+  function i() {
+    return { conv_0: r("MobilenetV1", 0, "mobilenetv1/conv_0"), conv_1: a(1), conv_2: a(2), conv_3: a(3), conv_4: a(4), conv_5: a(5), conv_6: a(6), conv_7: a(7), conv_8: a(8), conv_9: a(9), conv_10: a(10), conv_11: a(11), conv_12: a(12), conv_13: a(13) };
+  }
+  function s(p, u) {
+    let f = e(`${p}/weights`, 4, `${u}/filters`), l = e(`${p}/biases`, 1, `${u}/bias`);
+    return { filters: f, bias: l };
+  }
+  function c(p) {
+    let u = s(`Prediction/BoxPredictor_${p}/BoxEncodingPredictor`, `prediction_layer/box_predictor_${p}/box_encoding_predictor`), f = s(`Prediction/BoxPredictor_${p}/ClassPredictor`, `prediction_layer/box_predictor_${p}/class_predictor`);
+    return { box_encoding_predictor: u, class_predictor: f };
+  }
+  function m() {
+    return { conv_0: r("Prediction", 0, "prediction_layer/conv_0"), conv_1: r("Prediction", 1, "prediction_layer/conv_1"), conv_2: r("Prediction", 2, "prediction_layer/conv_2"), conv_3: r("Prediction", 3, "prediction_layer/conv_3"), conv_4: r("Prediction", 4, "prediction_layer/conv_4"), conv_5: r("Prediction", 5, "prediction_layer/conv_5"), conv_6: r("Prediction", 6, "prediction_layer/conv_6"), conv_7: r("Prediction", 7, "prediction_layer/conv_7"), box_predictor_0: c(0), box_predictor_1: c(1), box_predictor_2: c(2), box_predictor_3: c(3), box_predictor_4: c(4), box_predictor_5: c(5) };
+  }
+  return { extractMobilenetV1Params: i, extractPredictionLayerParams: m };
+}
+function Xr(o9) {
+  let t = [], { extractMobilenetV1Params: e, extractPredictionLayerParams: r } = zo(o9, t), a = o9["Output/extra_dim"];
+  if (t.push({ originalPath: "Output/extra_dim", paramPath: "output_layer/extra_dim" }), !K(a)) throw new Error(`expected weightMap['Output/extra_dim'] to be a Tensor3D, instead have ${a}`);
+  let i = { mobilenetv1: e(), prediction_layer: r(), output_layer: { extra_dim: a } };
+  return N(o9, t), { params: i, paramMappings: t };
+}
+function H(o9, t, e) {
+  return n.tidy(() => {
+    let r = n.conv2d(o9, t.filters, e, "same");
+    return r = n.add(r, t.batch_norm_offset), n.clipByValue(r, 0, 6);
+  });
+}
+var Yo = 0.0010000000474974513;
+function Vo(o9, t, e) {
+  return n.tidy(() => {
+    let r = n.depthwiseConv2d(o9, t.filters, e, "same");
+    return r = n.batchNorm(r, t.batch_norm_mean, t.batch_norm_variance, t.batch_norm_offset, t.batch_norm_scale, Yo), n.clipByValue(r, 0, 6);
+  });
+}
+function Go(o9) {
+  return [2, 4, 6, 12].some((t) => t === o9) ? [2, 2] : [1, 1];
+}
+function Jr(o9, t) {
+  return n.tidy(() => {
+    let e, r = H(o9, t.conv_0, [2, 2]);
+    if ([t.conv_1, t.conv_2, t.conv_3, t.conv_4, t.conv_5, t.conv_6, t.conv_7, t.conv_8, t.conv_9, t.conv_10, t.conv_11, t.conv_12, t.conv_13].forEach((i, s) => {
+      let c = s + 1, m = Go(c);
+      r = Vo(r, i.depthwise_conv, m), r = H(r, i.pointwise_conv, [1, 1]), c === 11 && (e = r);
+    }), e === null) throw new Error("mobileNetV1 - output of conv layer 11 is null");
+    return { out: r, conv11: e };
+  });
+}
+function jo(o9, t, e) {
+  let r = o9.arraySync(), a = Math.min(r[t][0], r[t][2]), i = Math.min(r[t][1], r[t][3]), s = Math.max(r[t][0], r[t][2]), c = Math.max(r[t][1], r[t][3]), m = Math.min(r[e][0], r[e][2]), p = Math.min(r[e][1], r[e][3]), u = Math.max(r[e][0], r[e][2]), f = Math.max(r[e][1], r[e][3]), l = (s - a) * (c - i), d = (u - m) * (f - p);
+  if (l <= 0 || d <= 0) return 0;
+  let b = Math.max(a, m), y = Math.max(i, p), h = Math.min(s, u), g = Math.min(c, f), T = Math.max(h - b, 0) * Math.max(g - y, 0);
+  return T / (l + d - T);
+}
+function qr(o9, t, e, r, a) {
+  let i = o9.shape[0], s = Math.min(e, i), c = t.map((u, f) => ({ score: u, boxIndex: f })).filter((u) => u.score > a).sort((u, f) => f.score - u.score), m = (u) => u <= r ? 1 : 0, p = [];
+  return c.forEach((u) => {
+    if (p.length >= s) return;
+    let f = u.score;
+    for (let l = p.length - 1; l >= 0; --l) {
+      let d = jo(o9, u.boxIndex, p[l]);
+      if (d !== 0 && (u.score *= m(d), u.score <= a)) break;
+    }
+    f === u.score && p.push(u.boxIndex);
+  }), p;
+}
+function Uo(o9) {
+  let t = n.unstack(n.transpose(o9, [1, 0])), e = [n.sub(t[2], t[0]), n.sub(t[3], t[1])], r = [n.add(t[0], n.div(e[0], 2)), n.add(t[1], n.div(e[1], 2))];
+  return { sizes: e, centers: r };
+}
+function Xo(o9, t) {
+  let { sizes: e, centers: r } = Uo(o9), a = n.unstack(n.transpose(t, [1, 0])), i = n.div(n.mul(n.exp(n.div(a[2], 5)), e[0]), 2), s = n.add(n.mul(n.div(a[0], 10), e[0]), r[0]), c = n.div(n.mul(n.exp(n.div(a[3], 5)), e[1]), 2), m = n.add(n.mul(n.div(a[1], 10), e[1]), r[1]);
+  return n.transpose(n.stack([n.sub(s, i), n.sub(m, c), n.add(s, i), n.add(m, c)]), [1, 0]);
+}
+function Zr(o9, t, e) {
+  return n.tidy(() => {
+    let r = o9.shape[0], a = Xo(n.reshape(n.tile(e.extra_dim, [r, 1, 1]), [-1, 4]), n.reshape(o9, [-1, 4]));
+    a = n.reshape(a, [r, a.shape[0] / r, 4]);
+    let i = n.sigmoid(n.slice(t, [0, 0, 1], [-1, -1, -1])), s = n.slice(i, [0, 0, 0], [-1, -1, 1]);
+    s = n.reshape(s, [r, s.shape[1]]);
+    let c = n.unstack(a), m = n.unstack(s);
+    return { boxes: c, scores: m };
+  });
+}
+function yt(o9, t) {
+  return n.tidy(() => {
+    let e = o9.shape[0], r = n.reshape(vt(o9, t.box_encoding_predictor), [e, -1, 1, 4]), a = n.reshape(vt(o9, t.class_predictor), [e, -1, 3]);
+    return { boxPredictionEncoding: r, classPrediction: a };
+  });
+}
+function Kr(o9, t, e) {
+  return n.tidy(() => {
+    let r = H(o9, e.conv_0, [1, 1]), a = H(r, e.conv_1, [2, 2]), i = H(a, e.conv_2, [1, 1]), s = H(i, e.conv_3, [2, 2]), c = H(s, e.conv_4, [1, 1]), m = H(c, e.conv_5, [2, 2]), p = H(m, e.conv_6, [1, 1]), u = H(p, e.conv_7, [2, 2]), f = yt(t, e.box_predictor_0), l = yt(o9, e.box_predictor_1), d = yt(a, e.box_predictor_2), b = yt(s, e.box_predictor_3), y = yt(m, e.box_predictor_4), h = yt(u, e.box_predictor_5), g = n.concat([f.boxPredictionEncoding, l.boxPredictionEncoding, d.boxPredictionEncoding, b.boxPredictionEncoding, y.boxPredictionEncoding, h.boxPredictionEncoding], 1), T = n.concat([f.classPrediction, l.classPrediction, d.classPrediction, b.classPrediction, y.classPrediction, h.classPrediction], 1);
+    return { boxPredictions: g, classPredictions: T };
+  });
+}
+var z = class {
+  constructor({ minConfidence: t, maxResults: e } = {}) {
+    this._name = "SsdMobilenetv1Options";
+    if (this._minConfidence = t || 0.5, this._maxResults = e || 100, typeof this._minConfidence != "number" || this._minConfidence <= 0 || this._minConfidence >= 1) throw new Error(`${this._name} - expected minConfidence to be a number between 0 and 1`);
+    if (typeof this._maxResults != "number") throw new Error(`${this._name} - expected maxResults to be a number`);
+  }
+  get minConfidence() {
+    return this._minConfidence;
+  }
+  get maxResults() {
+    return this._maxResults;
+  }
+};
+var Tt = class extends I {
+  constructor() {
+    super("SsdMobilenetv1");
+  }
+  forwardInput(t) {
+    let { params: e } = this;
+    if (!e) throw new Error("SsdMobilenetv1 - load model before inference");
+    return n.tidy(() => {
+      let r = n.cast(t.toBatchTensor(512, false), "float32"), a = n.sub(n.div(r, 127.5), 1), i = Jr(a, e.mobilenetv1), { boxPredictions: s, classPredictions: c } = Kr(i.out, i.conv11, e.prediction_layer);
+      return Zr(s, c, e.output_layer);
+    });
+  }
+  async forward(t) {
+    return this.forwardInput(await F(t));
+  }
+  async locateFaces(t, e = {}) {
+    let { maxResults: r, minConfidence: a } = new z(e), i = await F(t), { boxes: s, scores: c } = this.forwardInput(i), m = s[0], p = c[0];
+    for (let x = 1; x < s.length; x++) s[x].dispose(), c[x].dispose();
+    let u = Array.from(p.dataSync()), l = qr(m, u, r, 0.5, a), d = i.getReshapedInputDimensions(0), b = i.inputSize, y = b / d.width, h = b / d.height, g = m.arraySync(), T = l.map((x) => {
+      let [E, B] = [Math.max(0, g[x][0]), Math.min(1, g[x][2])].map((O) => O * h), [V, U] = [Math.max(0, g[x][1]), Math.min(1, g[x][3])].map((O) => O * y);
+      return new D(u[x], new Nt(V, E, U - V, B - E), { height: i.getInputHeight(0), width: i.getInputWidth(0) });
+    });
+    return m.dispose(), p.dispose(), T;
+  }
+  getDefaultModelName() {
+    return "ssd_mobilenetv1_model";
+  }
+  extractParamsFromWeightMap(t) {
+    return Xr(t);
+  }
+  extractParams(t) {
+    return Ur(t);
+  }
+};
+function Jo(o9) {
+  let t = new Tt();
+  return t.extractWeights(o9), t;
+}
+function gl(o9) {
+  return Jo(o9);
+}
+var Qr = class extends Tt {
+};
+var to = 0.4, eo = [new v(0.738768, 0.874946), new v(2.42204, 2.65704), new v(4.30971, 7.04493), new v(10.246, 4.59428), new v(12.6868, 11.8741)], ro = [new v(1.603231, 2.094468), new v(6.041143, 7.080126), new v(2.882459, 3.518061), new v(4.266906, 5.178857), new v(9.041765, 10.66308)], oo = [117.001, 114.697, 97.404], no = "tiny_yolov2_model", ao = "tiny_yolov2_separable_conv_model";
+var Le = (o9) => typeof o9 == "number";
+function so(o9) {
+  if (!o9) throw new Error(`invalid config: ${o9}`);
+  if (typeof o9.withSeparableConvs != "boolean") throw new Error(`config.withSeparableConvs has to be a boolean, have: ${o9.withSeparableConvs}`);
+  if (!Le(o9.iouThreshold) || o9.iouThreshold < 0 || o9.iouThreshold > 1) throw new Error(`config.iouThreshold has to be a number between [0, 1], have: ${o9.iouThreshold}`);
+  if (!Array.isArray(o9.classes) || !o9.classes.length || !o9.classes.every((t) => typeof t == "string")) throw new Error(`config.classes has to be an array class names: string[], have: ${JSON.stringify(o9.classes)}`);
+  if (!Array.isArray(o9.anchors) || !o9.anchors.length || !o9.anchors.map((t) => t || {}).every((t) => Le(t.x) && Le(t.y))) throw new Error(`config.anchors has to be an array of { x: number, y: number }, have: ${JSON.stringify(o9.anchors)}`);
+  if (o9.meanRgb && (!Array.isArray(o9.meanRgb) || o9.meanRgb.length !== 3 || !o9.meanRgb.every(Le))) throw new Error(`config.meanRgb has to be an array of shape [number, number, number], have: ${JSON.stringify(o9.meanRgb)}`);
+}
+function Ut(o9) {
+  return n.tidy(() => {
+    let t = n.mul(o9, n.scalar(0.10000000149011612));
+    return n.add(n.relu(n.sub(o9, t)), t);
+  });
+}
+function et(o9, t) {
+  return n.tidy(() => {
+    let e = n.pad(o9, [[0, 0], [1, 1], [1, 1], [0, 0]]);
+    return e = n.conv2d(e, t.conv.filters, [1, 1], "valid"), e = n.sub(e, t.bn.sub), e = n.mul(e, t.bn.truediv), e = n.add(e, t.conv.bias), Ut(e);
+  });
+}
+function rt(o9, t) {
+  return n.tidy(() => {
+    let e = n.pad(o9, [[0, 0], [1, 1], [1, 1], [0, 0]]);
+    return e = n.separableConv2d(e, t.depthwise_filter, t.pointwise_filter, [1, 1], "valid"), e = n.add(e, t.bias), Ut(e);
+  });
+}
+function qo(o9, t) {
+  let e = Rt(o9, t);
+  function r(s, c) {
+    let m = n.tensor1d(o9(s)), p = n.tensor1d(o9(s));
+    return t.push({ paramPath: `${c}/sub` }, { paramPath: `${c}/truediv` }), { sub: m, truediv: p };
+  }
+  function a(s, c, m) {
+    let p = e(s, c, 3, `${m}/conv`), u = r(c, `${m}/bn`);
+    return { conv: p, bn: u };
+  }
+  let i = $t(o9, t);
+  return { extractConvParams: e, extractConvWithBatchNormParams: a, extractSeparableConvParams: i };
+}
+function io(o9, t, e, r) {
+  let { extractWeights: a, getRemainingWeights: i } = L(o9), s = [], { extractConvParams: c, extractConvWithBatchNormParams: m, extractSeparableConvParams: p } = qo(a, s), u;
+  if (t.withSeparableConvs) {
+    let [f, l, d, b, y, h, g, T, x] = r, E = t.isFirstLayerConv2d ? c(f, l, 3, "conv0") : p(f, l, "conv0"), B = p(l, d, "conv1"), V = p(d, b, "conv2"), U = p(b, y, "conv3"), O = p(y, h, "conv4"), ot = p(h, g, "conv5"), nt = T ? p(g, T, "conv6") : void 0, at = x ? p(T, x, "conv7") : void 0, Et = c(x || T || g, 5 * e, 1, "conv8");
+    u = { conv0: E, conv1: B, conv2: V, conv3: U, conv4: O, conv5: ot, conv6: nt, conv7: at, conv8: Et };
+  } else {
+    let [f, l, d, b, y, h, g, T, x] = r, E = m(f, l, "conv0"), B = m(l, d, "conv1"), V = m(d, b, "conv2"), U = m(b, y, "conv3"), O = m(y, h, "conv4"), ot = m(h, g, "conv5"), nt = m(g, T, "conv6"), at = m(T, x, "conv7"), Et = c(x, 5 * e, 1, "conv8");
+    u = { conv0: E, conv1: B, conv2: V, conv3: U, conv4: O, conv5: ot, conv6: nt, conv7: at, conv8: Et };
+  }
+  if (i().length !== 0) throw new Error(`weights remaing after extract: ${i().length}`);
+  return { params: u, paramMappings: s };
+}
+function Zo(o9, t) {
+  let e = k(o9, t);
+  function r(c) {
+    let m = e(`${c}/sub`, 1), p = e(`${c}/truediv`, 1);
+    return { sub: m, truediv: p };
+  }
+  function a(c) {
+    let m = e(`${c}/filters`, 4), p = e(`${c}/bias`, 1);
+    return { filters: m, bias: p };
+  }
+  function i(c) {
+    let m = a(`${c}/conv`), p = r(`${c}/bn`);
+    return { conv: m, bn: p };
+  }
+  let s = Ot(e);
+  return { extractConvParams: a, extractConvWithBatchNormParams: i, extractSeparableConvParams: s };
+}
+function co(o9, t) {
+  let e = [], { extractConvParams: r, extractConvWithBatchNormParams: a, extractSeparableConvParams: i } = Zo(o9, e), s;
+  if (t.withSeparableConvs) {
+    let c = t.filterSizes && t.filterSizes.length || 9;
+    s = { conv0: t.isFirstLayerConv2d ? r("conv0") : i("conv0"), conv1: i("conv1"), conv2: i("conv2"), conv3: i("conv3"), conv4: i("conv4"), conv5: i("conv5"), conv6: c > 7 ? i("conv6") : void 0, conv7: c > 8 ? i("conv7") : void 0, conv8: r("conv8") };
+  } else s = { conv0: a("conv0"), conv1: a("conv1"), conv2: a("conv2"), conv3: a("conv3"), conv4: a("conv4"), conv5: a("conv5"), conv6: a("conv6"), conv7: a("conv7"), conv8: r("conv8") };
+  return N(o9, e), { params: s, paramMappings: e };
+}
+var q = class {
+  constructor({ inputSize: t, scoreThreshold: e } = {}) {
+    this._name = "TinyYolov2Options";
+    if (this._inputSize = t || 416, this._scoreThreshold = e || 0.5, typeof this._inputSize != "number" || this._inputSize % 32 !== 0) throw new Error(`${this._name} - expected inputSize to be a number divisible by 32`);
+    if (typeof this._scoreThreshold != "number" || this._scoreThreshold <= 0 || this._scoreThreshold >= 1) throw new Error(`${this._name} - expected scoreThreshold to be a number between 0 and 1`);
+  }
+  get inputSize() {
+    return this._inputSize;
+  }
+  get scoreThreshold() {
+    return this._scoreThreshold;
+  }
+};
+var Se = class Se2 extends I {
+  constructor(t) {
+    super("TinyYolov2"), so(t), this._config = t;
+  }
+  get config() {
+    return this._config;
+  }
+  get withClassScores() {
+    return this.config.withClassScores || this.config.classes.length > 1;
+  }
+  get boxEncodingSize() {
+    return 5 + (this.withClassScores ? this.config.classes.length : 0);
+  }
+  runTinyYolov2(t, e) {
+    let r = et(t, e.conv0);
+    return r = n.maxPool(r, [2, 2], [2, 2], "same"), r = et(r, e.conv1), r = n.maxPool(r, [2, 2], [2, 2], "same"), r = et(r, e.conv2), r = n.maxPool(r, [2, 2], [2, 2], "same"), r = et(r, e.conv3), r = n.maxPool(r, [2, 2], [2, 2], "same"), r = et(r, e.conv4), r = n.maxPool(r, [2, 2], [2, 2], "same"), r = et(r, e.conv5), r = n.maxPool(r, [2, 2], [1, 1], "same"), r = et(r, e.conv6), r = et(r, e.conv7), vt(r, e.conv8, "valid", false);
+  }
+  runMobilenet(t, e) {
+    let r = this.config.isFirstLayerConv2d ? Ut(vt(t, e.conv0, "valid", false)) : rt(t, e.conv0);
+    return r = n.maxPool(r, [2, 2], [2, 2], "same"), r = rt(r, e.conv1), r = n.maxPool(r, [2, 2], [2, 2], "same"), r = rt(r, e.conv2), r = n.maxPool(r, [2, 2], [2, 2], "same"), r = rt(r, e.conv3), r = n.maxPool(r, [2, 2], [2, 2], "same"), r = rt(r, e.conv4), r = n.maxPool(r, [2, 2], [2, 2], "same"), r = rt(r, e.conv5), r = n.maxPool(r, [2, 2], [1, 1], "same"), r = e.conv6 ? rt(r, e.conv6) : r, r = e.conv7 ? rt(r, e.conv7) : r, vt(r, e.conv8, "valid", false);
+  }
+  forwardInput(t, e) {
+    let { params: r } = this;
+    if (!r) throw new Error("TinyYolov2 - load model before inference");
+    return n.tidy(() => {
+      let a = n.cast(t.toBatchTensor(e, false), "float32");
+      return a = this.config.meanRgb ? J(a, this.config.meanRgb) : a, a = a.div(255), this.config.withSeparableConvs ? this.runMobilenet(a, r) : this.runTinyYolov2(a, r);
+    });
+  }
+  async forward(t, e) {
+    return this.forwardInput(await F(t), e);
+  }
+  async detect(t, e = {}) {
+    let { inputSize: r, scoreThreshold: a } = new q(e), i = await F(t), s = await this.forwardInput(i, r), c = n.tidy(() => n.unstack(s)[0].expandDims()), m = { width: i.getInputWidth(0), height: i.getInputHeight(0) }, p = await this.extractBoxes(c, i.getReshapedInputDimensions(0), a);
+    s.dispose(), c.dispose();
+    let u = p.map((h) => h.box), f = p.map((h) => h.score), l = p.map((h) => h.classScore), d = p.map((h) => this.config.classes[h.label]);
+    return br(u.map((h) => h.rescale(r)), f, this.config.iouThreshold, true).map((h) => new It(f[h], l[h], d[h], u[h], m));
+  }
+  getDefaultModelName() {
+    return "";
+  }
+  extractParamsFromWeightMap(t) {
+    return co(t, this.config);
+  }
+  extractParams(t) {
+    let e = this.config.filterSizes || Se2.DEFAULT_FILTER_SIZES, r = e ? e.length : void 0;
+    if (r !== 7 && r !== 8 && r !== 9) throw new Error(`TinyYolov2 - expected 7 | 8 | 9 convolutional filters, but found ${r} filterSizes in config`);
+    return io(t, this.config, this.boxEncodingSize, e);
+  }
+  async extractBoxes(t, e, r) {
+    let { width: a, height: i } = e, s = Math.max(a, i), c = s / a, m = s / i, p = t.shape[1], u = this.config.anchors.length, [f, l, d] = n.tidy(() => {
+      let g = t.reshape([p, p, u, this.boxEncodingSize]), T = g.slice([0, 0, 0, 0], [p, p, u, 4]), x = g.slice([0, 0, 0, 4], [p, p, u, 1]), E = this.withClassScores ? n.softmax(g.slice([0, 0, 0, 5], [p, p, u, this.config.classes.length]), 3) : n.scalar(0);
+      return [T, x, E];
+    }), b = [], y = await l.array(), h = await f.array();
+    for (let g = 0; g < p; g++) for (let T = 0; T < p; T++) for (let x = 0; x < u; x++) {
+      let E = fe(y[g][T][x][0]);
+      if (!r || E > r) {
+        let B = (T + fe(h[g][T][x][0])) / p * c, V = (g + fe(h[g][T][x][1])) / p * m, U = Math.exp(h[g][T][x][2]) * this.config.anchors[x].x / p * c, O = Math.exp(h[g][T][x][3]) * this.config.anchors[x].y / p * m, ot = B - U / 2, nt = V - O / 2, at = { row: g, col: T, anchor: x }, { classScore: Et, label: mr } = this.withClassScores ? await this.extractPredictedClass(d, at) : { classScore: 1, label: 0 };
+        b.push({ box: new Ct(ot, nt, ot + U, nt + O), score: E, classScore: E * Et, label: mr, ...at });
+      }
+    }
+    return f.dispose(), l.dispose(), d.dispose(), b;
+  }
+  async extractPredictedClass(t, e) {
+    let { row: r, col: a, anchor: i } = e, s = await t.array();
+    return Array(this.config.classes.length).fill(0).map((c, m) => s[r][a][i][m]).map((c, m) => ({ classScore: c, label: m })).reduce((c, m) => c.classScore > m.classScore ? c : m);
+  }
+};
+Se.DEFAULT_FILTER_SIZES = [3, 16, 32, 64, 128, 256, 512, 1024, 1024];
+var Xt = Se;
+var Jt = class extends Xt {
+  constructor(t = true) {
+    let e = { withSeparableConvs: t, iouThreshold: to, classes: ["face"], ...t ? { anchors: ro, meanRgb: oo } : { anchors: eo, withClassScores: true } };
+    super(e);
+  }
+  get withSeparableConvs() {
+    return this.config.withSeparableConvs;
+  }
+  get anchors() {
+    return this.config.anchors;
+  }
+  async locateFaces(t, e) {
+    return (await this.detect(t, e)).map((a) => new D(a.score, a.relativeBox, { width: a.imageWidth, height: a.imageHeight }));
+  }
+  getDefaultModelName() {
+    return this.withSeparableConvs ? ao : no;
+  }
+  extractParamsFromWeightMap(t) {
+    return super.extractParamsFromWeightMap(t);
+  }
+};
+function cd(o9, t = true) {
+  let e = new Jt(t);
+  return e.extractWeights(o9), e;
+}
+var Ae = class extends q {
+  constructor() {
+    super(...arguments);
+    this._name = "TinyFaceDetectorOptions";
+  }
+};
+var Y = class {
+  async then(t) {
+    return t(await this.run());
+  }
+  async run() {
+    throw new Error("ComposableTask - run is not implemented");
+  }
+};
+async function _t(o9, t, e, r, a = ({ alignedRect: i }) => i) {
+  let i = o9.map((m) => Yt(m) ? a(m) : m.detection), s = r || (t instanceof n.Tensor ? await oe(t, i) : await re(t, i)), c = await e(s);
+  return s.forEach((m) => m instanceof n.Tensor && m.dispose()), c;
+}
+async function qt(o9, t, e, r, a) {
+  return _t([o9], t, async (i) => e(i[0]), r, a);
+}
+var mo = 0.4, po = [new v(1.603231, 2.094468), new v(6.041143, 7.080126), new v(2.882459, 3.518061), new v(4.266906, 5.178857), new v(9.041765, 10.66308)], uo = [117.001, 114.697, 97.404];
+var Zt = class extends Xt {
+  constructor() {
+    let t = { withSeparableConvs: true, iouThreshold: mo, classes: ["face"], anchors: po, meanRgb: uo, isFirstLayerConv2d: true, filterSizes: [3, 16, 32, 64, 128, 256, 512] };
+    super(t);
+  }
+  get anchors() {
+    return this.config.anchors;
+  }
+  async locateFaces(t, e) {
+    return (await this.detect(t, e)).map((a) => new D(a.score, a.relativeBox, { width: a.imageWidth, height: a.imageHeight }));
+  }
+  getDefaultModelName() {
+    return "tiny_face_detector_model";
+  }
+  extractParamsFromWeightMap(t) {
+    return super.extractParamsFromWeightMap(t);
+  }
+};
+var P = { ssdMobilenetv1: new Tt(), tinyFaceDetector: new Zt(), tinyYolov2: new Jt(), faceLandmark68Net: new Gt(), faceLandmark68TinyNet: new Ie(), faceRecognitionNet: new jt(), faceExpressionNet: new we(), ageGenderNet: new Me() }, Ko = (o9, t) => P.ssdMobilenetv1.locateFaces(o9, t), Rd = (o9, t) => P.tinyFaceDetector.locateFaces(o9, t), $d = (o9, t) => P.tinyYolov2.locateFaces(o9, t), Qo = (o9) => P.faceLandmark68Net.detectLandmarks(o9), Od = (o9) => P.faceLandmark68TinyNet.detectLandmarks(o9), Hd = (o9) => P.faceRecognitionNet.computeFaceDescriptor(o9), zd = (o9) => P.faceExpressionNet.predictExpressions(o9), Yd = (o9) => P.ageGenderNet.predictAgeAndGender(o9), tn = (o9) => P.ssdMobilenetv1.load(o9), Vd = (o9) => P.tinyFaceDetector.load(o9), Gd = (o9) => P.tinyYolov2.load(o9), jd = (o9) => P.faceLandmark68Net.load(o9), Ud = (o9) => P.faceLandmark68TinyNet.load(o9), Xd = (o9) => P.faceRecognitionNet.load(o9), Jd = (o9) => P.faceExpressionNet.load(o9), qd = (o9) => P.ageGenderNet.load(o9), Zd = tn, Kd = Ko, Qd = Qo;
+var We = class extends Y {
+  constructor(e, r, a) {
+    super();
+    this.parentTask = e;
+    this.input = r;
+    this.extractedFaces = a;
+  }
+}, Pt = class extends We {
+  async run() {
+    let t = await this.parentTask, e = await _t(t, this.input, async (r) => Promise.all(r.map((a) => P.faceExpressionNet.predictExpressions(a))), this.extractedFaces);
+    return t.map((r, a) => tr(r, e[a]));
+  }
+  withAgeAndGender() {
+    return new Ft(this, this.input);
+  }
+}, wt = class extends We {
+  async run() {
+    let t = await this.parentTask;
+    if (!t) return;
+    let e = await qt(t, this.input, (r) => P.faceExpressionNet.predictExpressions(r), this.extractedFaces);
+    return tr(t, e);
+  }
+  withAgeAndGender() {
+    return new Dt(this, this.input);
+  }
+}, ct = class extends Pt {
+  withAgeAndGender() {
+    return new pt(this, this.input);
+  }
+  withFaceDescriptors() {
+    return new ft(this, this.input);
+  }
+}, mt = class extends wt {
+  withAgeAndGender() {
+    return new ut(this, this.input);
+  }
+  withFaceDescriptor() {
+    return new lt(this, this.input);
+  }
+};
+var ke = class extends Y {
+  constructor(e, r, a) {
+    super();
+    this.parentTask = e;
+    this.input = r;
+    this.extractedFaces = a;
+  }
+}, Ft = class extends ke {
+  async run() {
+    let t = await this.parentTask, e = await _t(t, this.input, async (r) => Promise.all(r.map((a) => P.ageGenderNet.predictAgeAndGender(a))), this.extractedFaces);
+    return t.map((r, a) => {
+      let { age: i, gender: s, genderProbability: c } = e[a];
+      return sr(ir(r, s, c), i);
+    });
+  }
+  withFaceExpressions() {
+    return new Pt(this, this.input);
+  }
+}, Dt = class extends ke {
+  async run() {
+    let t = await this.parentTask;
+    if (!t) return;
+    let { age: e, gender: r, genderProbability: a } = await qt(t, this.input, (i) => P.ageGenderNet.predictAgeAndGender(i), this.extractedFaces);
+    return sr(ir(t, r, a), e);
+  }
+  withFaceExpressions() {
+    return new wt(this, this.input);
+  }
+}, pt = class extends Ft {
+  withFaceExpressions() {
+    return new ct(this, this.input);
+  }
+  withFaceDescriptors() {
+    return new ft(this, this.input);
+  }
+}, ut = class extends Dt {
+  withFaceExpressions() {
+    return new mt(this, this.input);
+  }
+  withFaceDescriptor() {
+    return new lt(this, this.input);
+  }
+};
+var Be = class extends Y {
+  constructor(e, r) {
+    super();
+    this.parentTask = e;
+    this.input = r;
+  }
+}, ft = class extends Be {
+  async run() {
+    let t = await this.parentTask;
+    return (await _t(t, this.input, (r) => Promise.all(r.map((a) => P.faceRecognitionNet.computeFaceDescriptor(a))), null, (r) => r.landmarks.align(null, { useDlibAlignment: true }))).map((r, a) => ar(t[a], r));
+  }
+  withFaceExpressions() {
+    return new ct(this, this.input);
+  }
+  withAgeAndGender() {
+    return new pt(this, this.input);
+  }
+}, lt = class extends Be {
+  async run() {
+    let t = await this.parentTask;
+    if (!t) return;
+    let e = await qt(t, this.input, (r) => P.faceRecognitionNet.computeFaceDescriptor(r), null, (r) => r.landmarks.align(null, { useDlibAlignment: true }));
+    return ar(t, e);
+  }
+  withFaceExpressions() {
+    return new mt(this, this.input);
+  }
+  withAgeAndGender() {
+    return new ut(this, this.input);
+  }
+};
+var Re = class extends Y {
+  constructor(e, r, a) {
+    super();
+    this.parentTask = e;
+    this.input = r;
+    this.useTinyLandmarkNet = a;
+  }
+  get landmarkNet() {
+    return this.useTinyLandmarkNet ? P.faceLandmark68TinyNet : P.faceLandmark68Net;
+  }
+}, $e = class extends Re {
+  async run() {
+    let t = await this.parentTask, e = t.map((s) => s.detection), r = this.input instanceof n.Tensor ? await oe(this.input, e) : await re(this.input, e), a = await Promise.all(r.map((s) => this.landmarkNet.detectLandmarks(s)));
+    return r.forEach((s) => s instanceof n.Tensor && s.dispose()), t.filter((s, c) => a[c]).map((s, c) => ie(s, a[c]));
+  }
+  withFaceExpressions() {
+    return new ct(this, this.input);
+  }
+  withAgeAndGender() {
+    return new pt(this, this.input);
+  }
+  withFaceDescriptors() {
+    return new ft(this, this.input);
+  }
+}, Oe = class extends Re {
+  async run() {
+    let t = await this.parentTask;
+    if (!t) return;
+    let { detection: e } = t, r = this.input instanceof n.Tensor ? await oe(this.input, [e]) : await re(this.input, [e]), a = await this.landmarkNet.detectLandmarks(r[0]);
+    return r.forEach((i) => i instanceof n.Tensor && i.dispose()), ie(t, a);
+  }
+  withFaceExpressions() {
+    return new mt(this, this.input);
+  }
+  withAgeAndGender() {
+    return new ut(this, this.input);
+  }
+  withFaceDescriptor() {
+    return new lt(this, this.input);
+  }
+};
+var He = class extends Y {
+  constructor(e, r = new z()) {
+    super();
+    this.input = e;
+    this.options = r;
+  }
+}, me = class extends He {
+  async run() {
+    let { input: t, options: e } = this, r;
+    if (e instanceof Ae) r = P.tinyFaceDetector.locateFaces(t, e);
+    else if (e instanceof z) r = P.ssdMobilenetv1.locateFaces(t, e);
+    else if (e instanceof q) r = P.tinyYolov2.locateFaces(t, e);
+    else throw new Error("detectFaces - expected options to be instance of TinyFaceDetectorOptions | SsdMobilenetv1Options | TinyYolov2Options");
+    return r;
+  }
+  runAndExtendWithFaceDetections() {
+    return new Promise((t, e) => {
+      this.run().then((r) => t(r.map((a) => St({}, a)))).catch((r) => e(r));
+    });
+  }
+  withFaceLandmarks(t = false) {
+    return new $e(this.runAndExtendWithFaceDetections(), this.input, t);
+  }
+  withFaceExpressions() {
+    return new Pt(this.runAndExtendWithFaceDetections(), this.input);
+  }
+  withAgeAndGender() {
+    return new Ft(this.runAndExtendWithFaceDetections(), this.input);
+  }
+}, ze = class extends He {
+  async run() {
+    let t = await new me(this.input, this.options), e = t[0];
+    return t.forEach((r) => {
+      r.score > e.score && (e = r);
+    }), e;
+  }
+  runAndExtendWithFaceDetection() {
+    return new Promise(async (t) => {
+      let e = await this.run();
+      t(e ? St({}, e) : void 0);
+    });
+  }
+  withFaceLandmarks(t = false) {
+    return new Oe(this.runAndExtendWithFaceDetection(), this.input, t);
+  }
+  withFaceExpressions() {
+    return new wt(this.runAndExtendWithFaceDetection(), this.input);
+  }
+  withAgeAndGender() {
+    return new Dt(this.runAndExtendWithFaceDetection(), this.input);
+  }
+};
+function qh(o9, t = new z()) {
+  return new ze(o9, t);
+}
+function cr(o9, t = new z()) {
+  return new me(o9, t);
+}
+async function en(o9, t) {
+  return cr(o9, new z(t ? { minConfidence: t } : {})).withFaceLandmarks().withFaceDescriptors();
+}
+async function rb(o9, t = {}) {
+  return cr(o9, new q(t)).withFaceLandmarks().withFaceDescriptors();
+}
+var ob = en;
+function fo(o9, t) {
+  if (o9.length !== t.length) throw new Error("euclideanDistance: arr1.length !== arr2.length");
+  let e = Array.from(o9), r = Array.from(t);
+  return Math.sqrt(e.map((a, i) => a - r[i]).reduce((a, i) => a + i * i, 0));
+}
+var lo = class o8 {
+  constructor(t, e = 0.6) {
+    this._distanceThreshold = e;
+    let r = Array.isArray(t) ? t : [t];
+    if (!r.length) throw new Error("FaceRecognizer.constructor - expected atleast one input");
+    let a = 1, i = () => `person ${a++}`;
+    this._labeledDescriptors = r.map((s) => {
+      if (s instanceof gt) return s;
+      if (s instanceof Float32Array) return new gt(i(), [s]);
+      if (s.descriptor && s.descriptor instanceof Float32Array) return new gt(i(), [s.descriptor]);
+      throw new Error("FaceRecognizer.constructor - expected inputs to be of type LabeledFaceDescriptors | WithFaceDescriptor<any> | Float32Array | Array<LabeledFaceDescriptors | WithFaceDescriptor<any> | Float32Array>");
+    });
+  }
+  get labeledDescriptors() {
+    return this._labeledDescriptors;
+  }
+  get distanceThreshold() {
+    return this._distanceThreshold;
+  }
+  computeMeanDistance(t, e) {
+    return e.map((r) => fo(r, t)).reduce((r, a) => r + a, 0) / (e.length || 1);
+  }
+  matchDescriptor(t) {
+    return this.labeledDescriptors.map(({ descriptors: e, label: r }) => new Kt(r, this.computeMeanDistance(t, e))).reduce((e, r) => e.distance < r.distance ? e : r);
+  }
+  findBestMatch(t) {
+    let e = this.matchDescriptor(t);
+    return e.distance < this._distanceThreshold ? e : new Kt("unknown", e.distance);
+  }
+  toJSON() {
+    return { distanceThreshold: this._distanceThreshold, labeledDescriptors: this._labeledDescriptors.map((t) => t.toJSON()) };
+  }
+  static fromJSON(t) {
+    let e = t.labeledDescriptors.map((r) => gt.fromJSON(r));
+    return new o8(e, t.distanceThreshold);
+  }
+};
+function Tb(o9) {
+  let t = new Zt();
+  return t.extractWeights(o9), t;
+}
+function rn(o9, t) {
+  let { width: e, height: r } = new A(t.width, t.height);
+  if (e <= 0 || r <= 0) throw new Error(`resizeResults - invalid dimensions: ${JSON.stringify({ width: e, height: r })}`);
+  if (Array.isArray(o9)) return o9.map((a) => rn(a, { width: e, height: r }));
+  if (Yt(o9)) {
+    let a = o9.detection.forSize(e, r), i = o9.unshiftedLandmarks.forSize(a.box.width, a.box.height);
+    return ie(St(o9, a), i);
+  }
+  return Q(o9) ? St(o9, o9.detection.forSize(e, r)) : o9 instanceof $ || o9 instanceof D ? o9.forSize(e, r) : o9;
+}
+var Lb = Ar;
+const faceapi = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AgeGenderNet: Me,
+  BoundingBox: Ct,
+  Box: C,
+  ComposableTask: Y,
+  ComputeAllFaceDescriptorsTask: ft,
+  ComputeFaceDescriptorsTaskBase: Be,
+  ComputeSingleFaceDescriptorTask: lt,
+  DetectAllFaceLandmarksTask: $e,
+  DetectAllFacesTask: me,
+  DetectFaceLandmarksTaskBase: Re,
+  DetectFacesTaskBase: He,
+  DetectSingleFaceLandmarksTask: Oe,
+  DetectSingleFaceTask: ze,
+  Dimensions: A,
+  FACE_EXPRESSION_LABELS: Nr,
+  FaceDetection: D,
+  FaceDetectionNet: Qr,
+  FaceExpressionNet: we,
+  FaceExpressions: it,
+  FaceLandmark68Net: Gt,
+  FaceLandmark68TinyNet: Ie,
+  FaceLandmarkNet: zr,
+  FaceLandmarks: $,
+  FaceLandmarks5: xr,
+  FaceLandmarks68: Lt,
+  FaceMatch: Kt,
+  FaceMatcher: lo,
+  FaceRecognitionNet: jt,
+  Gender: rr,
+  LabeledBox: Qt,
+  LabeledFaceDescriptors: gt,
+  NetInput: tt,
+  NeuralNetwork: I,
+  ObjectDetection: It,
+  Point: v,
+  PredictedBox: vr,
+  Rect: Nt,
+  SsdMobilenetv1: Tt,
+  SsdMobilenetv1Options: z,
+  TinyFaceDetector: Zt,
+  TinyFaceDetectorOptions: Ae,
+  TinyYolov2: Jt,
+  TinyYolov2Options: q,
+  allFaces: ob,
+  allFacesSsdMobilenetv1: en,
+  allFacesTinyYolov2: rb,
+  awaitMediaLoaded: yr,
+  bufferToImage: Tr,
+  computeFaceDescriptor: Hd,
+  createCanvas: Bt,
+  createCanvasFromMedia: be,
+  createFaceDetectionNet: gl,
+  createFaceRecognitionNet: gf,
+  createSsdMobilenetv1: Jo,
+  createTinyFaceDetector: Tb,
+  createTinyYolov2: cd,
+  detectAllFaces: cr,
+  detectFaceLandmarks: Qo,
+  detectFaceLandmarksTiny: Od,
+  detectLandmarks: Qd,
+  detectSingleFace: qh,
+  draw: Sr,
+  env: _,
+  euclideanDistance: fo,
+  extendWithAge: sr,
+  extendWithFaceDescriptor: ar,
+  extendWithFaceDetection: St,
+  extendWithFaceExpressions: tr,
+  extendWithFaceLandmarks: ie,
+  extendWithGender: ir,
+  extractFaceTensors: oe,
+  extractFaces: re,
+  fetchImage: Fi,
+  fetchJson: wr,
+  fetchNetWeights: Ii,
+  fetchOrThrow: st,
+  fetchVideo: ki,
+  getContext2dOrThrow: W,
+  getMediaDimensions: kt,
+  imageTensorToCanvas: _r,
+  imageToSquare: Pr,
+  inverseSigmoid: On,
+  iou: dr,
+  isMediaElement: Qe,
+  isMediaLoaded: he,
+  isWithAge: Tf,
+  isWithFaceDetection: Q,
+  isWithFaceExpressions: Lr,
+  isWithFaceLandmarks: Yt,
+  isWithGender: Ff,
+  loadAgeGenderModel: qd,
+  loadFaceDetectionModel: Zd,
+  loadFaceExpressionModel: Jd,
+  loadFaceLandmarkModel: jd,
+  loadFaceLandmarkTinyModel: Ud,
+  loadFaceRecognitionModel: Xd,
+  loadSsdMobilenetv1Model: tn,
+  loadTinyFaceDetectorModel: Vd,
+  loadTinyYolov2Model: Gd,
+  loadWeightMap: Dr,
+  locateFaces: Kd,
+  matchDimensions: Yi,
+  minBbox: hr,
+  nets: P,
+  nonMaxSuppression: br,
+  normalize: J,
+  padToSquare: gr,
+  predictAgeAndGender: Yd,
+  recognizeFaceExpressions: zd,
+  resizeResults: rn,
+  resolveInput: At,
+  shuffleArray: Rn,
+  sigmoid: fe,
+  ssdMobilenetv1: Ko,
+  tf: n,
+  tinyFaceDetector: Rd,
+  tinyYolov2: $d,
+  toNetInput: F,
+  utils: lr,
+  validateConfig: so,
+  version: Lb
+}, Symbol.toStringTag, { value: "Module" }));
 class CameraPermissionDenied extends Error {
   constructor(message) {
     super(message);
@@ -220,7 +2660,7 @@ function $constructor(name, initializer2, params) {
       Object.defineProperty(inst, "_zod", {
         value: {
           def,
-          constr: _,
+          constr: _2,
           traits: /* @__PURE__ */ new Set()
         },
         enumerable: false
@@ -231,12 +2671,12 @@ function $constructor(name, initializer2, params) {
     }
     inst._zod.traits.add(name);
     initializer2(inst, def);
-    const proto = _.prototype;
+    const proto = _2.prototype;
     const keys = Object.keys(proto);
     for (let i = 0; i < keys.length; i++) {
-      const k = keys[i];
-      if (!(k in inst)) {
-        inst[k] = proto[k].bind(inst);
+      const k2 = keys[i];
+      if (!(k2 in inst)) {
+        inst[k2] = proto[k2].bind(inst);
       }
     }
   }
@@ -244,7 +2684,7 @@ function $constructor(name, initializer2, params) {
   class Definition extends Parent {
   }
   Object.defineProperty(Definition, "name", { value: name });
-  function _(def) {
+  function _2(def) {
     var _a2;
     const inst = (params == null ? void 0 : params.Parent) ? new Definition() : this;
     init2(inst, def);
@@ -254,8 +2694,8 @@ function $constructor(name, initializer2, params) {
     }
     return inst;
   }
-  Object.defineProperty(_, "init", { value: init2 });
-  Object.defineProperty(_, Symbol.hasInstance, {
+  Object.defineProperty(_2, "init", { value: init2 });
+  Object.defineProperty(_2, Symbol.hasInstance, {
     value: (inst) => {
       var _a2, _b;
       if ((params == null ? void 0 : params.Parent) && inst instanceof params.Parent)
@@ -263,8 +2703,8 @@ function $constructor(name, initializer2, params) {
       return (_b = (_a2 = inst == null ? void 0 : inst._zod) == null ? void 0 : _a2.traits) == null ? void 0 : _b.has(name);
     }
   });
-  Object.defineProperty(_, "name", { value: name });
-  return _;
+  Object.defineProperty(_2, "name", { value: name });
+  return _2;
 }
 class $ZodAsyncError extends Error {
   constructor() {
@@ -282,11 +2722,11 @@ function config(newConfig) {
   return globalConfig$1;
 }
 function getEnumValues(entries) {
-  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
-  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+  const numericValues = Object.values(entries).filter((v2) => typeof v2 === "number");
+  const values = Object.entries(entries).filter(([k2, _2]) => numericValues.indexOf(+k2) === -1).map(([_2, v2]) => v2);
   return values;
 }
-function jsonStringifyReplacer(_, value) {
+function jsonStringifyReplacer(_2, value) {
   if (typeof value === "bigint")
     return value.toString();
   return value;
@@ -339,9 +2779,9 @@ function defineLazy(object2, key, getter) {
       }
       return value;
     },
-    set(v) {
+    set(v2) {
       Object.defineProperty(object2, key, {
-        value: v
+        value: v2
         // configurable: true,
       });
     },
@@ -381,17 +2821,17 @@ const allowsEval = cached(() => {
     return false;
   }
   try {
-    const F = Function;
-    new F("");
+    const F2 = Function;
+    new F2("");
     return true;
-  } catch (_) {
+  } catch (_2) {
     return false;
   }
 });
-function isPlainObject(o) {
-  if (isObject(o) === false)
+function isPlainObject(o9) {
+  if (isObject(o9) === false)
     return false;
-  const ctor = o.constructor;
+  const ctor = o9.constructor;
   if (ctor === void 0)
     return true;
   if (typeof ctor !== "function")
@@ -404,12 +2844,12 @@ function isPlainObject(o) {
   }
   return true;
 }
-function shallowClone(o) {
-  if (isPlainObject(o))
-    return { ...o };
-  if (Array.isArray(o))
-    return [...o];
-  return o;
+function shallowClone(o9) {
+  if (isPlainObject(o9))
+    return { ...o9 };
+  if (Array.isArray(o9))
+    return [...o9];
+  return o9;
 }
 const propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
 function escapeRegex(str) {
@@ -438,8 +2878,8 @@ function normalizeParams(_params) {
   return params;
 }
 function optionalKeys(shape) {
-  return Object.keys(shape).filter((k) => {
-    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+  return Object.keys(shape).filter((k2) => {
+    return shape[k2]._zod.optin === "optional" && shape[k2]._zod.optout === "optional";
   });
 }
 const NUMBER_FORMAT_RANGES = {
@@ -642,10 +3082,10 @@ function unwrapMessage(message) {
   return typeof message === "string" ? message : message == null ? void 0 : message.message;
 }
 function finalizeIssue(iss, ctx, config2) {
-  var _a2, _b, _c, _d, _e, _f;
+  var _a2, _b, _c, _d, _e2, _f;
   const full = { ...iss, path: iss.path ?? [] };
   if (!iss.message) {
-    const message = unwrapMessage((_c = (_b = (_a2 = iss.inst) == null ? void 0 : _a2._zod.def) == null ? void 0 : _b.error) == null ? void 0 : _c.call(_b, iss)) ?? unwrapMessage((_d = ctx == null ? void 0 : ctx.error) == null ? void 0 : _d.call(ctx, iss)) ?? unwrapMessage((_e = config2.customError) == null ? void 0 : _e.call(config2, iss)) ?? unwrapMessage((_f = config2.localeError) == null ? void 0 : _f.call(config2, iss)) ?? "Invalid input";
+    const message = unwrapMessage((_c = (_b = (_a2 = iss.inst) == null ? void 0 : _a2._zod.def) == null ? void 0 : _b.error) == null ? void 0 : _c.call(_b, iss)) ?? unwrapMessage((_d = ctx == null ? void 0 : ctx.error) == null ? void 0 : _d.call(ctx, iss)) ?? unwrapMessage((_e2 = config2.customError) == null ? void 0 : _e2.call(config2, iss)) ?? unwrapMessage((_f = config2.localeError) == null ? void 0 : _f.call(config2, iss)) ?? "Invalid input";
     full.message = message;
   }
   delete full.inst;
@@ -1284,11 +3724,11 @@ class Doc {
     }
   }
   compile() {
-    const F = Function;
+    const F2 = Function;
     const args = this == null ? void 0 : this.args;
     const content = (this == null ? void 0 : this.content) ?? [``];
     const lines = [...content.map((x) => `  ${x}`)];
-    return new F(...args, lines.join("\n"));
+    return new F2(...args, lines.join("\n"));
   }
 }
 const version = {
@@ -1330,13 +3770,13 @@ const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
           continue;
         }
         const currLen = payload.issues.length;
-        const _ = ch._zod.check(payload);
-        if (_ instanceof Promise && (ctx == null ? void 0 : ctx.async) === false) {
+        const _2 = ch._zod.check(payload);
+        if (_2 instanceof Promise && (ctx == null ? void 0 : ctx.async) === false) {
           throw new $ZodAsyncError();
         }
-        if (asyncResult || _ instanceof Promise) {
+        if (asyncResult || _2 instanceof Promise) {
           asyncResult = (asyncResult ?? Promise.resolve()).then(async () => {
-            await _;
+            await _2;
             const nextLen = payload.issues.length;
             if (nextLen === currLen)
               return;
@@ -1399,7 +3839,7 @@ const $ZodType = /* @__PURE__ */ $constructor("$ZodType", (inst, def) => {
       try {
         const r = safeParse$1(inst, value);
         return r.success ? { value: r.data } : { issues: (_a4 = r.error) == null ? void 0 : _a4.issues };
-      } catch (_) {
+      } catch (_2) {
         return safeParseAsync$1(inst, value).then((r) => {
           var _a5;
           return r.success ? { value: r.data } : { issues: (_a5 = r.error) == null ? void 0 : _a5.issues };
@@ -1414,11 +3854,11 @@ const $ZodString = /* @__PURE__ */ $constructor("$ZodString", (inst, def) => {
   var _a2;
   $ZodType.init(inst, def);
   inst._zod.pattern = [...((_a2 = inst == null ? void 0 : inst._zod.bag) == null ? void 0 : _a2.patterns) ?? []].pop() ?? string$1(inst._zod.bag);
-  inst._zod.parse = (payload, _) => {
+  inst._zod.parse = (payload, _2) => {
     if (def.coerce)
       try {
         payload.value = String(payload.value);
-      } catch (_2) {
+      } catch (_3) {
       }
     if (typeof payload.value === "string")
       return payload;
@@ -1451,10 +3891,10 @@ const $ZodUUID = /* @__PURE__ */ $constructor("$ZodUUID", (inst, def) => {
       v7: 7,
       v8: 8
     };
-    const v = versionMap[def.version];
-    if (v === void 0)
+    const v2 = versionMap[def.version];
+    if (v2 === void 0)
       throw new Error(`Invalid UUID version: "${def.version}"`);
-    def.pattern ?? (def.pattern = uuid(v));
+    def.pattern ?? (def.pattern = uuid(v2));
   } else
     def.pattern ?? (def.pattern = uuid());
   $ZodStringFormat.init(inst, def);
@@ -1503,7 +3943,7 @@ const $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
         payload.value = trimmed;
       }
       return;
-    } catch (_) {
+    } catch (_2) {
       payload.issues.push({
         code: "invalid_format",
         format: "url",
@@ -1709,7 +4149,7 @@ const $ZodNumber = /* @__PURE__ */ $constructor("$ZodNumber", (inst, def) => {
     if (def.coerce)
       try {
         payload.value = Number(payload.value);
-      } catch (_) {
+      } catch (_2) {
       }
     const input = payload.value;
     if (typeof input === "number" && !Number.isNaN(input) && Number.isFinite(input)) {
@@ -1737,7 +4177,7 @@ const $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
     if (def.coerce)
       try {
         payload.value = Boolean(payload.value);
-      } catch (_) {
+      } catch (_2) {
       }
     const input = payload.value;
     if (typeof input === "boolean")
@@ -1828,9 +4268,9 @@ function handlePropertyResult(result, final, key, input, isOptionalOut) {
 function normalizeDef(def) {
   var _a2, _b, _c, _d;
   const keys = Object.keys(def.shape);
-  for (const k of keys) {
-    if (!((_d = (_c = (_b = (_a2 = def.shape) == null ? void 0 : _a2[k]) == null ? void 0 : _b._zod) == null ? void 0 : _c.traits) == null ? void 0 : _d.has("$ZodType"))) {
-      throw new Error(`Invalid element at key "${k}": expected a Zod schema`);
+  for (const k2 of keys) {
+    if (!((_d = (_c = (_b = (_a2 = def.shape) == null ? void 0 : _a2[k2]) == null ? void 0 : _b._zod) == null ? void 0 : _c.traits) == null ? void 0 : _d.has("$ZodType"))) {
+      throw new Error(`Invalid element at key "${k2}": expected a Zod schema`);
     }
   }
   const okeys = optionalKeys(def.shape);
@@ -1899,8 +4339,8 @@ const $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
       const field = shape[key]._zod;
       if (field.values) {
         propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
-        for (const v of field.values)
-          propValues[key].add(v);
+        for (const v2 of field.values)
+          propValues[key].add(v2);
       }
     }
     return propValues;
@@ -1948,8 +4388,8 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
     const doc = new Doc(["shape", "payload", "ctx"]);
     const normalized = _normalized.value;
     const parseStr = (key) => {
-      const k = esc(key);
-      return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
+      const k2 = esc(key);
+      return `shape[${k2}]._zod.run({ value: input[${k2}], issues: [] }, ctx)`;
     };
     doc.write(`const input = payload.value;`);
     const ids = /* @__PURE__ */ Object.create(null);
@@ -1960,27 +4400,27 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
     doc.write(`const newResult = {};`);
     for (const key of normalized.keys) {
       const id = ids[key];
-      const k = esc(key);
+      const k2 = esc(key);
       const schema = shape[key];
       const isOptionalOut = ((_a2 = schema == null ? void 0 : schema._zod) == null ? void 0 : _a2.optout) === "optional";
       doc.write(`const ${id} = ${parseStr(key)};`);
       if (isOptionalOut) {
         doc.write(`
         if (${id}.issues.length) {
-          if (${k} in input) {
+          if (${k2} in input) {
             payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
               ...iss,
-              path: iss.path ? [${k}, ...iss.path] : [${k}]
+              path: iss.path ? [${k2}, ...iss.path] : [${k2}]
             })));
           }
         }
         
         if (${id}.value === undefined) {
-          if (${k} in input) {
-            newResult[${k}] = undefined;
+          if (${k2} in input) {
+            newResult[${k2}] = undefined;
           }
         } else {
-          newResult[${k}] = ${id}.value;
+          newResult[${k2}] = ${id}.value;
         }
         
       `);
@@ -1989,16 +4429,16 @@ const $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def)
         if (${id}.issues.length) {
           payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
             ...iss,
-            path: iss.path ? [${k}, ...iss.path] : [${k}]
+            path: iss.path ? [${k2}, ...iss.path] : [${k2}]
           })));
         }
         
         if (${id}.value === undefined) {
-          if (${k} in input) {
-            newResult[${k}] = undefined;
+          if (${k2} in input) {
+            newResult[${k2}] = undefined;
           }
         } else {
-          newResult[${k}] = ${id}.value;
+          newResult[${k2}] = ${id}.value;
         }
         
       `);
@@ -2061,17 +4501,17 @@ function handleUnionResults(results, final, inst, ctx) {
 }
 const $ZodUnion = /* @__PURE__ */ $constructor("$ZodUnion", (inst, def) => {
   $ZodType.init(inst, def);
-  defineLazy(inst._zod, "optin", () => def.options.some((o) => o._zod.optin === "optional") ? "optional" : void 0);
-  defineLazy(inst._zod, "optout", () => def.options.some((o) => o._zod.optout === "optional") ? "optional" : void 0);
+  defineLazy(inst._zod, "optin", () => def.options.some((o9) => o9._zod.optin === "optional") ? "optional" : void 0);
+  defineLazy(inst._zod, "optout", () => def.options.some((o9) => o9._zod.optout === "optional") ? "optional" : void 0);
   defineLazy(inst._zod, "values", () => {
-    if (def.options.every((o) => o._zod.values)) {
+    if (def.options.every((o9) => o9._zod.values)) {
       return new Set(def.options.flatMap((option) => Array.from(option._zod.values)));
     }
     return void 0;
   });
   defineLazy(inst._zod, "pattern", () => {
-    if (def.options.every((o) => o._zod.pattern)) {
-      const patterns = def.options.map((o) => o._zod.pattern);
+    if (def.options.every((o9) => o9._zod.pattern)) {
+      const patterns = def.options.map((o9) => o9._zod.pattern);
       return new RegExp(`^(${patterns.map((p) => cleanRegex(p.source)).join("|")})$`);
     }
     return void 0;
@@ -2170,10 +4610,10 @@ function handleIntersectionResults(result, left, right) {
   for (const iss of left.issues) {
     if (iss.code === "unrecognized_keys") {
       unrecIssue ?? (unrecIssue = iss);
-      for (const k of iss.keys) {
-        if (!unrecKeys.has(k))
-          unrecKeys.set(k, {});
-        unrecKeys.get(k).l = true;
+      for (const k2 of iss.keys) {
+        if (!unrecKeys.has(k2))
+          unrecKeys.set(k2, {});
+        unrecKeys.get(k2).l = true;
       }
     } else {
       result.issues.push(iss);
@@ -2181,16 +4621,16 @@ function handleIntersectionResults(result, left, right) {
   }
   for (const iss of right.issues) {
     if (iss.code === "unrecognized_keys") {
-      for (const k of iss.keys) {
-        if (!unrecKeys.has(k))
-          unrecKeys.set(k, {});
-        unrecKeys.get(k).r = true;
+      for (const k2 of iss.keys) {
+        if (!unrecKeys.has(k2))
+          unrecKeys.set(k2, {});
+        unrecKeys.get(k2).r = true;
       }
     } else {
       result.issues.push(iss);
     }
   }
-  const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
+  const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k2]) => k2);
   if (bothKeys.length && unrecIssue) {
     result.issues.push({ ...unrecIssue, keys: bothKeys });
   }
@@ -2208,7 +4648,7 @@ const $ZodEnum = /* @__PURE__ */ $constructor("$ZodEnum", (inst, def) => {
   const values = getEnumValues(def.entries);
   const valuesSet = new Set(values);
   inst._zod.values = valuesSet;
-  inst._zod.pattern = new RegExp(`^(${values.filter((k) => propertyKeyTypes.has(typeof k)).map((o) => typeof o === "string" ? escapeRegex(o) : o.toString()).join("|")})$`);
+  inst._zod.pattern = new RegExp(`^(${values.filter((k2) => propertyKeyTypes.has(typeof k2)).map((o9) => typeof o9 === "string" ? escapeRegex(o9) : o9.toString()).join("|")})$`);
   inst._zod.parse = (payload, _ctx) => {
     const input = payload.value;
     if (valuesSet.has(input)) {
@@ -2341,8 +4781,8 @@ const $ZodPrefault = /* @__PURE__ */ $constructor("$ZodPrefault", (inst, def) =>
 const $ZodNonOptional = /* @__PURE__ */ $constructor("$ZodNonOptional", (inst, def) => {
   $ZodType.init(inst, def);
   defineLazy(inst._zod, "values", () => {
-    const v = def.innerType._zod.values;
-    return v ? new Set([...v].filter((x) => x !== void 0)) : void 0;
+    const v2 = def.innerType._zod.values;
+    return v2 ? new Set([...v2].filter((x) => x !== void 0)) : void 0;
   });
   inst._zod.parse = (payload, ctx) => {
     const result = def.innerType._zod.run(payload, ctx);
@@ -2461,7 +4901,7 @@ function handleReadonlyResult(payload) {
 const $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
   $ZodCheck.init(inst, def);
   $ZodType.init(inst, def);
-  inst._zod.parse = (payload, _) => {
+  inst._zod.parse = (payload, _2) => {
     return payload;
   };
   inst._zod.check = (payload) => {
@@ -3071,7 +5511,7 @@ function initializeContext(params) {
     external: (params == null ? void 0 : params.external) ?? void 0
   };
 }
-function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process$1(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a3, _b;
   var _a2;
   const def = schema._zod.def;
@@ -3109,7 +5549,7 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process(parent, ctx, params);
+      process$1(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -3392,14 +5832,14 @@ function isTransforming(_schema, _ctx) {
 }
 const createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process(schema, ctx);
+  process$1(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
-const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
+const createStandardJSONSchemaMethod = (schema, io2, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
-  const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process(schema, ctx);
+  const ctx = initializeContext({ ...libraryOptions ?? {}, target, io: io2, processors });
+  process$1(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
@@ -3500,9 +5940,9 @@ const unknownProcessor = (_schema, _ctx, _json, _params) => {
 const enumProcessor = (schema, _ctx, json, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
-  if (values.every((v) => typeof v === "number"))
+  if (values.every((v2) => typeof v2 === "number"))
     json.type = "number";
-  if (values.every((v) => typeof v === "string"))
+  if (values.every((v2) => typeof v2 === "string"))
     json.type = "string";
   json.enum = values;
 };
@@ -3525,7 +5965,7 @@ const arrayProcessor = (schema, ctx, _json, params) => {
   if (typeof maximum === "number")
     json.maxItems = maximum;
   json.type = "array";
-  json.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
+  json.items = process$1(def.element, ctx, { ...params, path: [...params.path, "items"] });
 };
 const objectProcessor = (schema, ctx, _json, params) => {
   var _a2;
@@ -3535,18 +5975,18 @@ const objectProcessor = (schema, ctx, _json, params) => {
   json.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json.properties[key] = process(shape[key], ctx, {
+    json.properties[key] = process$1(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
   }
   const allKeys = new Set(Object.keys(shape));
   const requiredKeys = new Set([...allKeys].filter((key) => {
-    const v = def.shape[key]._zod;
+    const v2 = def.shape[key]._zod;
     if (ctx.io === "input") {
-      return v.optin === void 0;
+      return v2.optin === void 0;
     } else {
-      return v.optout === void 0;
+      return v2.optout === void 0;
     }
   }));
   if (requiredKeys.size > 0) {
@@ -3558,7 +5998,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
     if (ctx.io === "output")
       json.additionalProperties = false;
   } else if (def.catchall) {
-    json.additionalProperties = process(def.catchall, ctx, {
+    json.additionalProperties = process$1(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -3567,7 +6007,7 @@ const objectProcessor = (schema, ctx, _json, params) => {
 const unionProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
-  const options = def.options.map((x, i) => process(x, ctx, {
+  const options = def.options.map((x, i) => process$1(x, ctx, {
     ...params,
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
@@ -3579,11 +6019,11 @@ const unionProcessor = (schema, ctx, json, params) => {
 };
 const intersectionProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  const a = process(def.left, ctx, {
+  const a = process$1(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
   });
-  const b = process(def.right, ctx, {
+  const b = process$1(def.right, ctx, {
     ...params,
     path: [...params.path, "allOf", 1]
   });
@@ -3596,7 +6036,7 @@ const intersectionProcessor = (schema, ctx, json, params) => {
 };
 const nullableProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  const inner = process(def.innerType, ctx, params);
+  const inner = process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -3607,20 +6047,20 @@ const nullableProcessor = (schema, ctx, json, params) => {
 };
 const nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 const defaultProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 const prefaultProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
@@ -3628,7 +6068,7 @@ const prefaultProcessor = (schema, ctx, json, params) => {
 };
 const catchProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   let catchValue;
@@ -3642,20 +6082,20 @@ const catchProcessor = (schema, ctx, json, params) => {
 const pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-  process(innerType, ctx, params);
+  process$1(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
 const readonlyProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json.readOnly = true;
 };
 const optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process$1(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
@@ -4137,7 +6577,7 @@ const ZodEnum = /* @__PURE__ */ $constructor("ZodEnum", (inst, def) => {
   };
 });
 function _enum(values, params) {
-  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
+  const entries = Array.isArray(values) ? Object.fromEntries(values.map((v2) => [v2, v2])) : values;
   return new ZodEnum({
     type: "enum",
     entries,
@@ -4315,7 +6755,7 @@ function superRefine(fn) {
   return /* @__PURE__ */ _superRefine(fn);
 }
 const AuthMethodSchema = _enum(["face", "password"]);
-object({
+const BiometricLoginResultSchema = object({
   success: boolean(),
   accessToken: string().optional(),
   /**
@@ -4343,7 +6783,7 @@ object({
   status: string().optional(),
   message: string().optional()
 });
-object({
+const RegistrationResultSchema = object({
   success: boolean(),
   message: string(),
   person_id: string().optional(),
@@ -4411,12 +6851,12 @@ const DARK_TOKENS = {
 function contrastRatio(hexA, hexB) {
   const lumA = luminance(hexA);
   const lumB = luminance(hexB);
-  const [hi, lo] = lumA > lumB ? [lumA, lumB] : [lumB, lumA];
-  return (hi + 0.05) / (lo + 0.05);
+  const [hi, lo2] = lumA > lumB ? [lumA, lumB] : [lumB, lumA];
+  return (hi + 0.05) / (lo2 + 0.05);
 }
 function luminance(hex) {
-  const [r, g, b] = parseHex(hex).map((v) => {
-    const s = v / 255;
+  const [r, g, b] = parseHex(hex).map((v2) => {
+    const s = v2 / 255;
     return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
   });
   return 0.2126 * r + 0.7152 * g + 0.0722 * b;
@@ -5130,7 +7570,7 @@ const recognize = async (image, applicationToken) => {
   }
 };
 const loginWithBiometric = async (image, applicationToken) => {
-  var _a2, _b, _c, _d, _e;
+  var _a2, _b, _c, _d, _e2;
   ensureSecureContext();
   const controller = createTimeoutController();
   const compressedImage = await compressImage(image);
@@ -5176,7 +7616,7 @@ const loginWithBiometric = async (image, applicationToken) => {
         email: ((_b = data.user) == null ? void 0 : _b.email) || "",
         role: ((_c = data.user) == null ? void 0 : _c.role) || "",
         validated: ((_d = data.user) == null ? void 0 : _d.validated) || false,
-        active: ((_e = data.user) == null ? void 0 : _e.active) || false
+        active: ((_e2 = data.user) == null ? void 0 : _e2.active) || false
       },
       person: data.person ? {
         id: data.person.id || "",
@@ -5199,6 +7639,127 @@ const loginWithBiometric = async (image, applicationToken) => {
     throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK);
   }
 };
+const loginWithBiometricSSE = async (image, applicationToken) => {
+  var _a2, _b;
+  ensureSecureContext();
+  const compressedImage = await compressImage(image);
+  const arrayBuffer = await compressedImage.arrayBuffer();
+  const base64Image = btoa(
+    new Uint8Array(arrayBuffer).reduce((data, byte) => data + String.fromCharCode(byte), "")
+  );
+  const controller = createTimeoutController();
+  let response;
+  try {
+    response = await fetch(`${getApiBaseUrl()}/api/v1/auth/recognition/face/`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Token": applicationToken
+      },
+      body: JSON.stringify({ image: base64Image, purpose: "LOGIN" }),
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new NeoFaceError("Request timed out", ErrorType.NETWORK);
+      }
+      if (error instanceof NeoFaceError) throw error;
+      throw new NeoFaceError(error.message, ErrorType.NETWORK);
+    }
+    throw new NeoFaceError("Unknown error occurred", ErrorType.NETWORK);
+  }
+  if (!response.ok) {
+    if (response.status === 401 || response.status === 403) {
+      throw new NeoFaceError("Invalid application token", ErrorType.INVALID_TOKEN);
+    }
+    throw new NeoFaceError(`API Error ${response.status}`, ErrorType.API_ERROR);
+  }
+  const initData = await response.json();
+  if (!initData.success || !((_a2 = initData.data) == null ? void 0 : _a2.task_id)) {
+    throw new NeoFaceError(initData.message || "Failed to start login", ErrorType.LOGIN_FAILED);
+  }
+  const taskId = initData.data.task_id;
+  const ticketUrl = `${getApiBaseUrl()}/api/v1/auth/recognition/face/login/events/${taskId}/ticket/`;
+  const ticketRes = await fetch(ticketUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "X-App-Token": applicationToken }
+  });
+  if (!ticketRes.ok) {
+    throw new NeoFaceError(`SSE ticket request failed: ${ticketRes.status}`, ErrorType.NETWORK);
+  }
+  const ticketData = await ticketRes.json();
+  const ticket = ((_b = ticketData == null ? void 0 : ticketData.data) == null ? void 0 : _b.ticket) ?? (ticketData == null ? void 0 : ticketData.ticket);
+  if (!ticket) {
+    throw new NeoFaceError("SSE ticket ausente na resposta", ErrorType.API_ERROR);
+  }
+  return new Promise((resolve, reject) => {
+    const sseUrl = `${getApiBaseUrl()}/api/v1/auth/recognition/face/login/events/${taskId}/?ticket=${encodeURIComponent(ticket)}`;
+    const eventSource = new EventSource(sseUrl);
+    const timeoutId = setTimeout(() => {
+      eventSource.close();
+      reject(new NeoFaceError("Login timeout", ErrorType.NETWORK));
+    }, 31e4);
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      eventSource.close();
+    };
+    eventSource.addEventListener("success", (event) => {
+      var _a3, _b2, _c, _d, _e2, _f;
+      cleanup();
+      try {
+        const data = JSON.parse(event.data);
+        resolve({
+          success: true,
+          accessToken: data.token || data.access_token || "",
+          alias: ((_a3 = data.user) == null ? void 0 : _a3.alias) || data.alias || "",
+          user: {
+            id: ((_b2 = data.user) == null ? void 0 : _b2.id) || "",
+            email: ((_c = data.user) == null ? void 0 : _c.email) || "",
+            role: ((_d = data.user) == null ? void 0 : _d.role) || "",
+            validated: ((_e2 = data.user) == null ? void 0 : _e2.validated) ?? false,
+            active: ((_f = data.user) == null ? void 0 : _f.active) ?? false
+          },
+          person: data.person ? {
+            id: data.person.id || "",
+            name: data.person.name || "",
+            birth_date: data.person.birth_date || ""
+          } : void 0,
+          confidence_score: data.confidence_score,
+          recognition_id: data.recognition_id ?? data.history_id
+        });
+      } catch {
+        reject(new NeoFaceError("Erro ao processar resposta de login", ErrorType.API_ERROR));
+      }
+    });
+    eventSource.addEventListener("failed", (event) => {
+      cleanup();
+      try {
+        const data = JSON.parse(event.data);
+        reject(new NeoFaceError(data.message || "Login failed", ErrorType.LOGIN_FAILED));
+      } catch {
+        reject(new NeoFaceError("Login failed", ErrorType.LOGIN_FAILED));
+      }
+    });
+    eventSource.addEventListener("error", (event) => {
+      cleanup();
+      try {
+        const data = JSON.parse(event.data || "{}");
+        reject(new NeoFaceError(data.message || "Processing error", ErrorType.API_ERROR));
+      } catch {
+        reject(new NeoFaceError("Processing error", ErrorType.API_ERROR));
+      }
+    });
+    eventSource.addEventListener("timeout", () => {
+      cleanup();
+      reject(new NeoFaceError("Login timeout", ErrorType.NETWORK));
+    });
+    eventSource.onerror = () => {
+      cleanup();
+      reject(new NeoFaceError("SSE connection error", ErrorType.NETWORK));
+    };
+  });
+};
 const recognizeBiometric = async (image, applicationToken, livenessCheck = true, confidenceThreshold = 0.8) => {
   ensureSecureContext();
   const controller = createTimeoutController();
@@ -5480,7 +8041,7 @@ const checkUserExistence = async (params) => {
   }
 };
 const registerPersonWithBiometric = async (personData, facePhotos, applicationToken, options) => {
-  var _a2, _b, _c, _d, _e, _f, _g, _h;
+  var _a2, _b, _c, _d, _e2, _f, _g, _h;
   ensureSecureContext();
   if (!facePhotos || facePhotos.length === 0) {
     throw new NeoFaceError(
@@ -5615,7 +8176,7 @@ const registerPersonWithBiometric = async (personData, facePhotos, applicationTo
       person_id: ((_b = data.data) == null ? void 0 : _b.person_id) || data.person_id,
       user_id: ((_c = data.data) == null ? void 0 : _c.user_id) || data.user_id,
       person_validated: ((_d = data.data) == null ? void 0 : _d.person_validated) || data.person_validated,
-      face_processing: ((_e = data.data) == null ? void 0 : _e.face_processing) || data.face_processing,
+      face_processing: ((_e2 = data.data) == null ? void 0 : _e2.face_processing) || data.face_processing,
       onboarding_link: ((_f = data.data) == null ? void 0 : _f.onboarding_link) || data.onboarding_link,
       task_id: (_g = data.data) == null ? void 0 : _g.task_id,
       status: (_h = data.data) == null ? void 0 : _h.status
@@ -6096,7 +8657,7 @@ const recordFaceVideo = async (options = {}) => {
   });
 };
 const pollTaskStatus = async (taskId, applicationToken, options = {}) => {
-  var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  var _a2, _b, _c, _d, _e2, _f, _g, _h, _i, _j;
   const { maxAttempts = 60, intervalMs = 1e3, onStatusChange } = options;
   const wait2 = (ms = intervalMs) => new Promise((resolve) => {
     setTimeout(resolve, ms);
@@ -6158,7 +8719,7 @@ const pollTaskStatus = async (taskId, applicationToken, options = {}) => {
         return data.data.result;
       }
       if (status === "failure") {
-        const errorMessage = ((_e = (_d = data.data) == null ? void 0 : _d.result) == null ? void 0 : _e.message) || ((_f = data.data) == null ? void 0 : _f.error) || "Task failed";
+        const errorMessage = ((_e2 = (_d = data.data) == null ? void 0 : _d.result) == null ? void 0 : _e2.message) || ((_f = data.data) == null ? void 0 : _f.error) || "Task failed";
         throw new NeoFaceError(errorMessage, ErrorType.RECOGNITION_FAILED);
       }
       if (status === "revoked") {
@@ -6309,7 +8870,7 @@ const registerDocumentByImage$1 = async (personId, jwtToken, images) => {
 };
 const getTaskStatus = async (taskId, applicationToken) => {
   const controller = createTimeoutController();
-  {
+  if (!applicationToken) {
     console.warn(
       "[NeoFaceID SDK] getTaskStatus sem applicationToken — /tasks/status/ vai responder 401."
     );
@@ -6412,6 +8973,8 @@ async function confirmPasswordReset(token, new_password) {
 }
 const api = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  BiometricLoginResultSchema,
+  RegistrationResultSchema,
   checkUserExistence,
   completeOnboarding,
   completeOnboardingWithData,
@@ -6421,6 +8984,7 @@ const api = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty(
   identifyPerson,
   identifyPersonAsync,
   loginWithBiometric,
+  loginWithBiometricSSE,
   loginWithEmail,
   pollTaskStatus,
   recognize,
@@ -6471,12 +9035,12 @@ function measureFrameBrightness(video, options = {}) {
   }
 }
 function centerRoi(vw, vh, fraction) {
-  const w = Math.round(vw * fraction);
+  const w2 = Math.round(vw * fraction);
   const h = Math.round(vh * fraction);
   return {
-    x: Math.round((vw - w) / 2),
+    x: Math.round((vw - w2) / 2),
     y: Math.round((vh - h) / 2),
-    width: w,
+    width: w2,
     height: h
   };
 }
@@ -6484,16 +9048,16 @@ function computeLumaMean(rgba) {
   const len = rgba.length;
   if (len === 0) return 0;
   let sum = 0;
-  let n = 0;
+  let n2 = 0;
   for (let i = 0; i < len; i += 4) {
     const r = rgba[i];
     const g = rgba[i + 1];
     const b = rgba[i + 2];
     sum += 0.2126 * r + 0.7152 * g + 0.0722 * b;
-    n += 1;
+    n2 += 1;
   }
-  if (n === 0) return 0;
-  return sum / (n * 255);
+  if (n2 === 0) return 0;
+  return sum / (n2 * 255);
 }
 const DARK_THRESHOLD$1 = 0.235;
 const IMPROVEMENT_TARGET$1 = 0.12;
@@ -6859,9 +9423,9 @@ function FaceCaptureModal({
     const detectFaces = async () => {
       if (!videoRef.current || state.status !== "ready") return;
       try {
-        const detections = await faceapi.detectAllFaces(
+        const detections = await cr(
           videoRef.current,
-          new faceapi.TinyFaceDetectorOptions()
+          new Ae()
         );
         const isOneFace = detections.length === 1;
         const isCentered = isOneFace && isFaceCentered(detections[0]);
@@ -6889,8 +9453,8 @@ function FaceCaptureModal({
     const loadModels = async () => {
       try {
         await Promise.all([
-          faceapi.nets.tinyFaceDetector.loadFromUri("/models"),
-          faceapi.nets.faceLandmark68Net.loadFromUri("/models")
+          P.tinyFaceDetector.loadFromUri("/models"),
+          P.faceLandmark68Net.loadFromUri("/models")
         ]);
       } catch (error) {
         console.error("Failed to load face-api.js models:", error);
@@ -7486,8 +10050,8 @@ const livenessInstructions = {
 const generateRandomStepSequence = () => {
   const middleSteps = ["up", "down", "left", "right"];
   for (let i = middleSteps.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [middleSteps[i], middleSteps[j]] = [middleSteps[j], middleSteps[i]];
+    const j2 = Math.floor(Math.random() * (i + 1));
+    [middleSteps[i], middleSteps[j2]] = [middleSteps[j2], middleSteps[i]];
   }
   return ["center", ...middleSteps, "complete"];
 };
@@ -7698,12 +10262,12 @@ function BiometricRegistrationModal({
       try {
         const MODEL_URL = "/models";
         const timeout = new Promise(
-          (_, reject) => setTimeout(() => reject(new Error("Timeout ao carregar modelos")), 1e4)
+          (_2, reject) => setTimeout(() => reject(new Error("Timeout ao carregar modelos")), 1e4)
         );
         await Promise.race([
           Promise.all([
-            faceapi.nets.tinyFaceDetector.loadFromUri(MODEL_URL),
-            faceapi.nets.faceLandmark68Net.loadFromUri(MODEL_URL)
+            P.tinyFaceDetector.loadFromUri(MODEL_URL),
+            P.faceLandmark68Net.loadFromUri(MODEL_URL)
           ]),
           timeout
         ]);
@@ -7851,9 +10415,9 @@ function BiometricRegistrationModal({
       }
       lastDetectionTime = now;
       try {
-        const detection = await faceapi.detectSingleFace(
+        const detection = await qh(
           videoRef.current,
-          new faceapi.TinyFaceDetectorOptions({
+          new Ae({
             inputSize: 224,
             // Aumentado para detectar rostos menores/mais distantes
             scoreThreshold: 0.35
@@ -8919,7 +11483,7 @@ function BiometricRegistrationModal({
     /* @__PURE__ */ jsx("canvas", { ref: canvasRef })
   ] });
 }
-const VERSION = "2.1.1";
+const VERSION = "2.1.2";
 const RELEASE_DATE = "2026-09-23";
 const CONSENT_TRAIL_STORAGE_KEY = "neoface_consent_trail_v1";
 const CONSENT_TRAIL_MAX_LIMIT = 100;
@@ -9009,7 +11573,7 @@ const COPY = {
     primary: "Começar cadastro"
   }
 };
-const plural = (n) => n === 1 ? "dia" : "dias";
+const plural = (n2) => n2 === 1 ? "dia" : "dias";
 function terceiroMarcador(flow, retentionDays) {
   const prazoDeclarado = Number.isFinite(retentionDays) && retentionDays > 0;
   if (flow === "registration") {
@@ -10082,17 +12646,17 @@ function QrCode({ value }) {
   const [path, setPath] = useState(null);
   useEffect(() => {
     let cancelled = false;
-    import("./qrcode-DYfGiWu6.js").then((mod) => {
+    import("./qrcode-DZJ8v41k.js").then((mod) => {
       if (cancelled) return;
       const qrcode = mod.default ?? mod;
-      const qr = qrcode(0, "M");
-      qr.addData(value);
-      qr.make();
-      const count = qr.getModuleCount();
+      const qr2 = qrcode(0, "M");
+      qr2.addData(value);
+      qr2.make();
+      const count = qr2.getModuleCount();
       const parts = [];
       for (let r = 0; r < count; r += 1) {
         for (let c = 0; c < count; c += 1) {
-          if (qr.isDark(r, c)) parts.push(`M${c} ${r}h1v1h-1z`);
+          if (qr2.isDark(r, c)) parts.push(`M${c} ${r}h1v1h-1z`);
         }
       }
       setPath({ d: parts.join(""), count });
@@ -11552,7 +14116,7 @@ async function preloadFaceDetectionModels() {
   modelsLoading = (async () => {
     try {
       const MODEL_URL = "/models";
-      await faceapi.nets.tinyFaceDetector.loadFromUri(MODEL_URL);
+      await P.tinyFaceDetector.loadFromUri(MODEL_URL);
       modelsLoaded = true;
       console.log("✅ Face detection models preloaded");
     } catch (error) {
@@ -11630,9 +14194,9 @@ async function captureFaceSilently() {
         const detectFace = async () => {
           if (!modelsLoaded) return true;
           try {
-            const detection = await faceapi.detectSingleFace(
+            const detection = await qh(
               video,
-              new faceapi.TinyFaceDetectorOptions({ inputSize: 160, scoreThreshold: 0.3 })
+              new Ae({ inputSize: 160, scoreThreshold: 0.3 })
             );
             return !!detection;
           } catch {
@@ -11726,9 +14290,9 @@ async function detectFaceWithPosition(video, stream, guideModal, maxTime = FACE_
         return;
       }
       try {
-        const detection = await faceapi.detectSingleFace(
+        const detection = await qh(
           video,
-          new faceapi.TinyFaceDetectorOptions({ inputSize: 160, scoreThreshold: 0.3 })
+          new Ae({ inputSize: 160, scoreThreshold: 0.3 })
         );
         const { faceState, instruction } = evaluateFacePosition(
           detection ? detection.box : null,
@@ -12264,7 +14828,7 @@ class BiometricCaptureModal {
    */
   async detectBiometricType(imageData) {
     try {
-      const { detectBiometricType } = await import("./biometricDetection-8utmtR25.js");
+      const { detectBiometricType } = await import("./biometricDetection-CR31mETT.js");
       const result = await detectBiometricType(imageData);
       if (result.type !== "unknown" && result.confidence > 0.6) {
         return result.type;