@authme/engine 2.2.0 → 2.2.1-rc.3

package/index.js

@@ -0,0 +1,609 @@
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.object.from-entries.js';
+import 'core-js/modules/es.array-buffer.slice.js';
+import 'core-js/modules/es.typed-array.uint8-array.js';
+import 'core-js/modules/es.typed-array.fill.js';
+import 'core-js/modules/es.typed-array.set.js';
+import 'core-js/modules/es.typed-array.sort.js';
+import 'core-js/modules/es.typed-array.to-locale-string.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/web.url.js';
+import 'core-js/modules/web.url-search-params.js';
+import 'core-js/modules/es.promise.js';
+import 'core-js/modules/es.parse-int.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.array.sort.js';
+import { AuthmeError, ErrorCode, sendRequest } from '@authme/core';
+import { isMobile, Storage } from '@authme/util';
+import { firstValueFrom, filter, map, fromEvent, shareReplay, from, mergeAll, concatMap, of, reduce, defer, concatAll, mergeMap } from 'rxjs';
+import 'core-js/modules/es.symbol.description.js';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+var EngineModule;
+(function (EngineModule) {
+  EngineModule["Fas"] = "Fas";
+  EngineModule["IdCardAntiFraud"] = "IdCardAntiFraud";
+  EngineModule["CardOCR"] = "CardOCR";
+  EngineModule["PassportService"] = "PassportService";
+  EngineModule["DEBUG"] = "DEBUG";
+  EngineModule["Core"] = "Core";
+})(EngineModule || (EngineModule = {}));
+
+var EAuthMeEngineReturnCode;
+(function (EAuthMeEngineReturnCode) {
+  EAuthMeEngineReturnCode["Pass"] = "EAuthMeEngineReturnCode_eAuthMe_Engine_Authorization_Pass";
+})(EAuthMeEngineReturnCode || (EAuthMeEngineReturnCode = {}));
+
+var authEnumModule = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get EAuthMeEngineReturnCode () { return EAuthMeEngineReturnCode; }
+});
+
+var EAuthMeCardClass;
+(function (EAuthMeCardClass) {
+  EAuthMeCardClass["Invalid"] = "EAuthMeCardClass_Invalid";
+  EAuthMeCardClass["Unknown"] = "EAuthMeCardClass_UnknownCard";
+  EAuthMeCardClass["Passport"] = "EAuthMeCardClass_Passport";
+  EAuthMeCardClass["TWN_IDCard_Front"] = "EAuthMeCardClass_TWN_IDCard_Front";
+  EAuthMeCardClass["TWN_IDCard_Back"] = "EAuthMeCardClass_TWN_IDCard_Back";
+  EAuthMeCardClass["TWN_DriverLicense_Front"] = "EAuthMeCardClass_TWN_DriverLicense_Front";
+  EAuthMeCardClass["TWN_DriverLicense_Back"] = "EAuthMeCardClass_TWN_DriverLicense_Back";
+  EAuthMeCardClass["TWN_ResidentCard_Front"] = "EAuthMeCardClass_TWN_ResidentCard_Front";
+  EAuthMeCardClass["TWN_ResidentCard_Back"] = "EAuthMeCardClass_TWN_ResidentCard_Back";
+  EAuthMeCardClass["TWN_HealthCard_Front"] = "EAuthMeCardClass_TWN_HealthCard_Front";
+  EAuthMeCardClass["TWN_VehiclesLicense_Front"] = "EAuthMeCardClass_TWN_VehiclesLicense_Front";
+})(EAuthMeCardClass || (EAuthMeCardClass = {}));
+var EAuthMeIDCardMetalTagStatus;
+(function (EAuthMeIDCardMetalTagStatus) {
+  EAuthMeIDCardMetalTagStatus["NotFound"] = "EAuthMeIDCardMetalTagStatus_NotFound";
+  EAuthMeIDCardMetalTagStatus["Bright"] = "EAuthMeIDCardMetalTagStatus_Bright";
+  EAuthMeIDCardMetalTagStatus["Dark"] = "EAuthMeIDCardMetalTagStatus_Dark";
+})(EAuthMeIDCardMetalTagStatus || (EAuthMeIDCardMetalTagStatus = {}));
+var EAuthMeCardMatchStatus;
+(function (EAuthMeCardMatchStatus) {
+  EAuthMeCardMatchStatus["None"] = "EAuthMeCardMatchStatus_None";
+  EAuthMeCardMatchStatus["Mismatch"] = "EAuthMeCardMatchStatus_Mismatch";
+  EAuthMeCardMatchStatus["NeedMoreFrame"] = "EAuthMeCardMatchStatus_NeedMoreFrame";
+  EAuthMeCardMatchStatus["Match"] = "EAuthMeCardMatchStatus_Match";
+})(EAuthMeCardMatchStatus || (EAuthMeCardMatchStatus = {}));
+var EAuthMeCardOCRStatus;
+(function (EAuthMeCardOCRStatus) {
+  EAuthMeCardOCRStatus["NoCard"] = "EAuthMeCardOCRStatus_NoCard";
+  EAuthMeCardOCRStatus["WrongCardType"] = "EAuthMeCardOCRStatus_WrongCardType";
+  EAuthMeCardOCRStatus["PositionNotMatch"] = "EAuthMeCardOCRStatus_PositionNotMatch";
+  EAuthMeCardOCRStatus["Reflective"] = "EAuthMeCardOCRStatus_Reflective";
+  EAuthMeCardOCRStatus["Blur"] = "EAuthMeCardOCRStatus_Blur";
+  EAuthMeCardOCRStatus["Pass"] = "EAuthMeCardOCRStatus_Pass";
+  EAuthMeCardOCRStatus["Error"] = "EAuthMeCardOCRStatus_Error";
+})(EAuthMeCardOCRStatus || (EAuthMeCardOCRStatus = {}));
+var EAuthMeIDCardAntiFraudStatus;
+(function (EAuthMeIDCardAntiFraudStatus) {
+  EAuthMeIDCardAntiFraudStatus["Failed"] = "EAuthMeIDCardAntiFraudStatus_Failed";
+  EAuthMeIDCardAntiFraudStatus["NoCard"] = "EAuthMeIDCardAntiFraudStatus_NoCard";
+  EAuthMeIDCardAntiFraudStatus["WrongCardType"] = "EAuthMeIDCardAntiFraudStatus_WrongCardType";
+  EAuthMeIDCardAntiFraudStatus["Reflective"] = "EAuthMeIDCardAntiFraudStatus_Reflective";
+  EAuthMeIDCardAntiFraudStatus["Blur"] = "EAuthMeIDCardAntiFraudStatus_Blur";
+  EAuthMeIDCardAntiFraudStatus["Gray"] = "EAuthMeIDCardAntiFraudStatus_Gray";
+  EAuthMeIDCardAntiFraudStatus["PositionNotMatch"] = "EAuthMeIDCardAntiFraudStatus_PositionNotMatch";
+  EAuthMeIDCardAntiFraudStatus["NeedMoreFrame"] = "EAuthMeIDCardAntiFraudStatus_NeedMoreFrame";
+  EAuthMeIDCardAntiFraudStatus["Pass"] = "EAuthMeIDCardAntiFraudStatus_Pass";
+  EAuthMeIDCardAntiFraudStatus["Error"] = "EAuthMeIDCardAntiFraudStatus_Error";
+})(EAuthMeIDCardAntiFraudStatus || (EAuthMeIDCardAntiFraudStatus = {}));
+var EAuthMeMRZRecogStatus;
+(function (EAuthMeMRZRecogStatus) {
+  EAuthMeMRZRecogStatus["Success"] = "EAuthMeMRZRecogStatus_Success";
+  EAuthMeMRZRecogStatus["WrongFormat"] = "EAuthMeMRZRecogStatus_WrongFormat";
+})(EAuthMeMRZRecogStatus || (EAuthMeMRZRecogStatus = {}));
+var EAuthMePassportServiceStatus;
+(function (EAuthMePassportServiceStatus) {
+  EAuthMePassportServiceStatus["Success"] = "EAuthMePassportServiceStatus_Success";
+  EAuthMePassportServiceStatus["NotFound"] = "EAuthMePassportServiceStatus_NotFound";
+  EAuthMePassportServiceStatus["RecogFailed"] = "EAuthMePassportServiceStatus_RecogFailed";
+  EAuthMePassportServiceStatus["Error"] = "EAuthMePassportServiceStatus_Error";
+})(EAuthMePassportServiceStatus || (EAuthMePassportServiceStatus = {}));
+var EAuthMeIDCardAntiFraudStage;
+(function (EAuthMeIDCardAntiFraudStage) {
+  EAuthMeIDCardAntiFraudStage["Frontal"] = "EAuthMeIDCardAntiFraudStage_Frontal";
+  EAuthMeIDCardAntiFraudStage["Up"] = "EAuthMeIDCardAntiFraudStage_Up";
+  EAuthMeIDCardAntiFraudStage["Down"] = "EAuthMeIDCardAntiFraudStage_Down";
+  EAuthMeIDCardAntiFraudStage["Left"] = "EAuthMeIDCardAntiFraudStage_Left";
+  EAuthMeIDCardAntiFraudStage["Right"] = "EAuthMeIDCardAntiFraudStage_Right";
+  EAuthMeIDCardAntiFraudStage["IgnoreCardMatch"] = "EAuthMeIDCardAntiFraudStage_IgnoreCardMatch";
+  EAuthMeIDCardAntiFraudStage["Done"] = "EAuthMeIDCardAntiFraudStage_Done";
+})(EAuthMeIDCardAntiFraudStage || (EAuthMeIDCardAntiFraudStage = {}));
+
+var idRecognitionEnumModule = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get EAuthMeCardClass () { return EAuthMeCardClass; },
+    get EAuthMeIDCardMetalTagStatus () { return EAuthMeIDCardMetalTagStatus; },
+    get EAuthMeCardMatchStatus () { return EAuthMeCardMatchStatus; },
+    get EAuthMeCardOCRStatus () { return EAuthMeCardOCRStatus; },
+    get EAuthMeIDCardAntiFraudStatus () { return EAuthMeIDCardAntiFraudStatus; },
+    get EAuthMeMRZRecogStatus () { return EAuthMeMRZRecogStatus; },
+    get EAuthMePassportServiceStatus () { return EAuthMePassportServiceStatus; },
+    get EAuthMeIDCardAntiFraudStage () { return EAuthMeIDCardAntiFraudStage; }
+});
+
+var EAuthMeFASServiceStatus;
+(function (EAuthMeFASServiceStatus) {
+  EAuthMeFASServiceStatus["Failed"] = "EAuthMeFASServiceStatus_Failed";
+  EAuthMeFASServiceStatus["NoFace"] = "EAuthMeFASServiceStatus_NoFace";
+  EAuthMeFASServiceStatus["FaceNotAtCenter"] = "EAuthMeFASServiceStatus_FaceNotAtCenter";
+  EAuthMeFASServiceStatus["FaceTooSmall"] = "EAuthMeFASServiceStatus_FaceTooSmall";
+  EAuthMeFASServiceStatus["FaceTooLarge"] = "EAuthMeFASServiceStatus_FaceTooLarge";
+  EAuthMeFASServiceStatus["NeedFaceToCamera"] = "EAuthMeFASServiceStatus_NeedFaceToCamera";
+  EAuthMeFASServiceStatus["FaceMasked"] = "EAuthMeFASServiceStatus_FaceMasked";
+  EAuthMeFASServiceStatus["NeedOpenMouth"] = "EAuthMeFASServiceStatus_NeedOpenMouth";
+  EAuthMeFASServiceStatus["NeedCloseMouth"] = "EAuthMeFASServiceStatus_NeedCloseMouth";
+  EAuthMeFASServiceStatus["NeedSmile"] = "EAuthMeFASServiceStatus_NeedSmile";
+  EAuthMeFASServiceStatus["NeedOpenEyes"] = "EAuthMeFASServiceStatus_NeedOpenEyes";
+  EAuthMeFASServiceStatus["NeedMoreFrame"] = "EAuthMeFASServiceStatus_NeedMoreFrame";
+  EAuthMeFASServiceStatus["Error"] = "EAuthMeFASServiceStatus_Error";
+  EAuthMeFASServiceStatus["Pass"] = "EAuthMeFASServiceStatus_Pass";
+})(EAuthMeFASServiceStatus || (EAuthMeFASServiceStatus = {}));
+var EAuthMeFASServiceStage;
+(function (EAuthMeFASServiceStage) {
+  EAuthMeFASServiceStage["Passive"] = "EAuthMeFASServiceStage_Passive";
+  EAuthMeFASServiceStage["OpenMouth"] = "EAuthMeFASServiceStage_OpenMouth";
+  EAuthMeFASServiceStage["CloseMouth"] = "EAuthMeFASServiceStage_CloseMouth";
+  EAuthMeFASServiceStage["Smile"] = "EAuthMeFASServiceStage_Smile";
+  EAuthMeFASServiceStage["Done"] = "EAuthMeFASServiceStage_Done";
+})(EAuthMeFASServiceStage || (EAuthMeFASServiceStage = {}));
+var EAuthMeEyeStatus;
+(function (EAuthMeEyeStatus) {
+  EAuthMeEyeStatus["Eye_Close"] = "EAuthMeEyeStatus_Eye_Close";
+  EAuthMeEyeStatus["Eye_Open"] = "EAuthMeEyeStatus_Eye_Open";
+})(EAuthMeEyeStatus || (EAuthMeEyeStatus = {}));
+var EAuthMeMouthStatus;
+(function (EAuthMeMouthStatus) {
+  EAuthMeMouthStatus["Mouth_Close"] = "EAuthMeMouthStatus_Mouth_Close";
+  EAuthMeMouthStatus["Mouth_Open"] = "EAuthMeMouthStatus_Mouth_Open";
+})(EAuthMeMouthStatus || (EAuthMeMouthStatus = {}));
+var EAuthMeFacePose;
+(function (EAuthMeFacePose) {
+  EAuthMeFacePose["Unknown"] = "EAuthMeFacePose_Unknown";
+  EAuthMeFacePose["LeftProfile"] = "EAuthMeFacePose_LeftProfile";
+  EAuthMeFacePose["LeftFrontal"] = "EAuthMeFacePose_LeftFrontal";
+  EAuthMeFacePose["Frontal"] = "EAuthMeFacePose_Frontal";
+  EAuthMeFacePose["RightFrontal"] = "EAuthMeFacePose_RightFrontal";
+  EAuthMeFacePose["RightProfile"] = "EAuthMeFacePose_RightProfile";
+  EAuthMeFacePose["UpFrontal"] = "EAuthMeFacePose_UpFrontal";
+  EAuthMeFacePose["DownFrontal"] = "EAuthMeFacePose_DownFrontal";
+})(EAuthMeFacePose || (EAuthMeFacePose = {}));
+var EAuthMeFaceAntiSpoofingStatus;
+(function (EAuthMeFaceAntiSpoofingStatus) {
+  EAuthMeFaceAntiSpoofingStatus["FrameNotEnough"] = "EAuthMeFaceAntiSpoofingStatus_FrameNotEnough";
+  EAuthMeFaceAntiSpoofingStatus["Real"] = "EAuthMeFaceAntiSpoofingStatus_Real";
+  EAuthMeFaceAntiSpoofingStatus["Spoof"] = "EAuthMeFaceAntiSpoofingStatus_Spoof";
+})(EAuthMeFaceAntiSpoofingStatus || (EAuthMeFaceAntiSpoofingStatus = {}));
+
+var fasRecognitionEnumModule = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get EAuthMeFASServiceStatus () { return EAuthMeFASServiceStatus; },
+    get EAuthMeFASServiceStage () { return EAuthMeFASServiceStage; },
+    get EAuthMeEyeStatus () { return EAuthMeEyeStatus; },
+    get EAuthMeMouthStatus () { return EAuthMeMouthStatus; },
+    get EAuthMeFacePose () { return EAuthMeFacePose; },
+    get EAuthMeFaceAntiSpoofingStatus () { return EAuthMeFaceAntiSpoofingStatus; }
+});
+
+const defaultMlEngineConfig = {
+  token: '',
+  scriptPath: '/assets/',
+  apiBaseUrl: '/',
+  dataTransferMethod: 'binary'
+};
+
+var name = "@authme/engine";
+var version$1 = "2.2.1-rc.3";
+var peerDependencies = {
+	"core-js": "^3.6.0",
+	rxjs: "^7.4.0"
+};
+var packageInfo = {
+	name: name,
+	version: version$1,
+	peerDependencies: peerDependencies
+};
+
+var _a;
+var _b, _c;
+const version = packageInfo.version;
+(_a = (_b = window)[_c = Symbol.for('authme-sdk')]) !== null && _a !== void 0 ? _a : _b[_c] = {};
+window[Symbol.for('authme-sdk')][packageInfo.name] = version;
+
+const getDownloadOrder = function () {
+  // model 越大，在後續 worker service 載入與解密的時間越長，
+  // 所以盡可能讓越大的檔案排在越前面下載，以便讓耗費時間長的任務先排在背景執行。
+  //
+  // 但由於 api server 目前沒有提供檔案大小的相關資訊，
+  // 所以將順序相關的資訊寫死在 sdk 裡。
+  const DOWNLOAD_ORDER = Object.fromEntries(['FACE_03', 'FACE_00', 'IDCardAntiFraud_00', 'FACE_01', 'OCR_00', 'FACE_02', 'OCR_02', 'MRZ_00', 'OCR_01', 'MRZ_01' // 375k
+  ].map((key, index) => [key, index]));
+  return function getDownloadOrder(key) {
+    var _a;
+    return (_a = DOWNLOAD_ORDER[key]) !== null && _a !== void 0 ? _a : Number.MAX_VALUE;
+  };
+}();
+function isSimdSupported() {
+  try {
+    // Test for WebAssembly SIMD capability (for both browsers and Node.js)
+    // This typed array is a WebAssembly program containing SIMD instructions.
+    return WebAssembly.validate(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 253, 15, 26, 11]));
+  } catch (e) {
+    return false;
+  }
+}
+function getWasmContentAsync(url) {
+  return sendRequest(url, 'GET', {
+    expectedResponseContentTypes: ['application/wasm'],
+    accessToken: null,
+    baseUrl: null,
+    sdkInfo: null
+  });
+}
+function getJsContentAsync(url) {
+  return sendRequest(url, 'GET', {
+    expectedResponseContentTypes: ['text/javascript', 'application/javascript'],
+    accessToken: null,
+    baseUrl: null,
+    sdkInfo: null
+  });
+}
+function createWorkerWithObjectUrlAsync(url) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const scriptContent = yield getJsContentAsync(url);
+    const objectUrl = URL.createObjectURL(new Blob([scriptContent], {
+      type: 'text/javascript'
+    }));
+    const worker = new Worker(objectUrl);
+    URL.revokeObjectURL(objectUrl);
+    return worker;
+  });
+}
+function convertToModelQueryString(modelVersion) {
+  return `models=${modelVersion.name}[${modelVersion.version}]`;
+}
+function fetchModelCodesAsync(modelVersions) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const queryString = modelVersions.map(convertToModelQueryString).join('&');
+    const response = yield sendRequest('/api/model-management/v1/model?' + queryString);
+    return response.models;
+  });
+}
+function base64ToBufferAsync(base64) {
+  const dataUrl = 'data:application/octet-binary;base64,' + base64;
+  return fetch(dataUrl).then(res => res.arrayBuffer());
+}
+function fetchModelContentAsync(code, dataTransferMethod) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const payload = yield sendRequest(`/api/model-management/v1/model/${code}${dataTransferMethod === 'binary' ? '/file' : ''}`);
+    if (dataTransferMethod === 'binary') {
+      return payload;
+    } else {
+      return yield base64ToBufferAsync(payload.data);
+    }
+  });
+}
+function fetchModelContents(modelVersions, dataTransferMethod) {
+  return of(modelVersions).pipe(concatMap(modelVersions => defer(() => fetchModelCodesAsync(modelVersions))), concatAll(), mergeMap(({
+    name,
+    version,
+    code
+  }) => defer(() => __awaiter(this, void 0, void 0, function* () {
+    return {
+      modelVersion: {
+        name,
+        version: `${parseInt(version)}`
+      },
+      modelArrayBuffer: yield fetchModelContentAsync(code, dataTransferMethod)
+    };
+  })), 1
+  // 下載 model 過程會分為 wait time & download time，
+  // concurrent 設定越高，只能起到降低 wait time 的作用，但會拉長單一檔案完成下載的時間，
+  // 這會延遲 worker service 裡，載入與解密的時間。
+  //
+  // 所以 concurrent 建議設定為 1 或 2，盡量讓已下載好的 model 儘早進行載入與解密。
+  ));
+}
+
+class AuthmeFunctionModule {
+  init(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+      for (const key in config) {
+        if (Object.prototype.hasOwnProperty.call(config, key)) {
+          Storage.setItem(key, config[key]);
+        }
+      }
+    });
+  }
+  static getVersion() {
+    return version;
+  }
+}
+class MlEngine {
+  constructor(config) {
+    this.workerAndStreamPromise = undefined;
+    this.preloadPromise = undefined;
+    this.config = Object.assign(Object.assign(Object.assign({}, defaultMlEngineConfig), config), {
+      isMobile: isMobile()
+    });
+  }
+  _run(worker, workerMessage$, module, command, value = {}) {
+    const id = (Math.random() + 1).toString(36).substring(4) + Date.now();
+    worker.postMessage({
+      module,
+      command,
+      id,
+      value
+    });
+    return firstValueFrom(workerMessage$.pipe(filter(x => x.id === id), map(x => x.value)));
+  }
+  _makeWorkerAndStreamAsync() {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+      // use blobUrl to fix cross-domain problem on worker creating.
+      // ref:
+      // * https://stackoverflow.com/questions/25458104/can-should-html5-web-workers-use-cors-for-cross-origin
+      // * https://web.dev/workers-basics/
+      const worker = yield createWorkerWithObjectUrlAsync(`${(_a = this.config.scriptPath) !== null && _a !== void 0 ? _a : ''}engine-worker.js?t=${Date.now()}`);
+      const workerMessage$ = fromEvent(worker, 'message').pipe(map(x => x.data), shareReplay(1));
+      yield this._run(worker, workerMessage$, EngineModule.Core, 'setConfig', this.config);
+      return [worker, workerMessage$];
+    });
+  }
+  _backgroundPreloadAsync() {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+      const [worker, workerMessage$] = yield (_a = this.workerAndStreamPromise) !== null && _a !== void 0 ? _a : this.workerAndStreamPromise = this._makeWorkerAndStreamAsync();
+      yield this._loadEngineAsync(worker, workerMessage$);
+      yield this._checkEnumConsistencyAsync(worker, workerMessage$);
+      return [worker, workerMessage$];
+    });
+  }
+  terminateWorkerAsync() {
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.workerAndStreamPromise || this.preloadPromise) {
+        const [worker, _] = yield this._backgroundPreloadAsync();
+        this.workerAndStreamPromise = undefined;
+        this.preloadPromise = undefined;
+        worker.terminate();
+      }
+    });
+  }
+  _preloadAndWaitReadyAsync() {
+    var _a;
+    return (_a = this.preloadPromise) !== null && _a !== void 0 ? _a : this.preloadPromise = this._backgroundPreloadAsync();
+  }
+  _checkEnumConsistencyAsync(worker, workerMessage$) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const problem = yield this._run(worker, workerMessage$, 'Core', 'checkEnumConsistency', Object.assign(Object.assign(Object.assign({}, authEnumModule), idRecognitionEnumModule), fasRecognitionEnumModule));
+      if (problem.length > 0) {
+        throw new AuthmeError(ErrorCode.SDK_INTERNAL_ERROR, {
+          problem
+        });
+      }
+    });
+  }
+  run(module, command, value = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const [worker, workerMessage$] = yield this._preloadAndWaitReadyAsync();
+      return yield this._run(worker, workerMessage$, module, command, value);
+    });
+  }
+  getConfig() {
+    return this.config;
+  }
+  setConfig(config) {
+    return __awaiter(this, void 0, void 0, function* () {
+      this.config = Object.assign(Object.assign({}, this.config), config);
+      if (this.workerAndStreamPromise) {
+        const [worker, workerMessage$] = yield this._preloadAndWaitReadyAsync();
+        yield this._run(worker, workerMessage$, EngineModule.Core, 'setConfig', this.config);
+      }
+    });
+  }
+  _loadEngineAsync(worker, workerMessage$) {
+    var _a, _b, _c, _d, _e;
+    return __awaiter(this, void 0, void 0, function* () {
+      // load js/wasm outside the worker.
+      const simdSupported = isSimdSupported();
+      const jsUrl = simdSupported ? `${(_a = this.config.scriptPath) !== null && _a !== void 0 ? _a : ''}ml_engine_web.simd.js` : `${(_b = this.config.scriptPath) !== null && _b !== void 0 ? _b : ''}ml_engine_web.js`;
+      const wasmUrl = simdSupported ? `${(_c = this.config.scriptPath) !== null && _c !== void 0 ? _c : ''}ml_engine_web.simd.wasm` : `${(_d = this.config.scriptPath) !== null && _d !== void 0 ? _d : ''}ml_engine_web.wasm`;
+      const [engineJsContent, engineWasmContent] = yield (_e = MlEngine._ENGINE_CACHE) !== null && _e !== void 0 ? _e : MlEngine._ENGINE_CACHE = Promise.all([getJsContentAsync(`${jsUrl}?t=${Date.now()}`), getWasmContentAsync(`${wasmUrl}?t=${Date.now()}`)]);
+      return yield this._run(worker, workerMessage$, EngineModule.Core, 'loadEngine', {
+        engineJsContent,
+        engineWasmContent
+      });
+    });
+  }
+}
+MlEngine._ENGINE_CACHE = undefined;
+class AuthmeEngineModuleBase {
+  constructor(engine) {
+    this._initPromise = undefined;
+    this.initialized = false;
+    this.initializing = false;
+    this.setSized = false;
+    this.received = true;
+    this.engine = engine;
+  }
+  _engineRunAsync(command, value) {
+    return this.engine.run(this.moduleName, command, value);
+  }
+  _init() {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+      if (this.initialized) {
+        return true;
+      }
+      if (this.initializing) {
+        throw new AuthmeError(ErrorCode.ENGINE_MODULE_IS_INITIALIZING);
+      }
+      this.initializing = true;
+      try {
+        const noLoadedModelVersions = yield this._engineRunAsync('getNoLoadedModelVersions');
+        const noCachedModelVersions = noLoadedModelVersions.filter(({
+          name,
+          version
+        }) => !AuthmeEngineModuleBase._MODEL_CACHE[`${name}-${version}`]);
+        const newCachedValues = fetchModelContents(noCachedModelVersions.sort((a, b) => getDownloadOrder(a.name) - getDownloadOrder(b.name)), (_a = this.engine.getConfig().dataTransferMethod) !== null && _a !== void 0 ? _a : 'binary').pipe(shareReplay());
+        for (const {
+          name,
+          version
+        } of noCachedModelVersions) {
+          AuthmeEngineModuleBase._MODEL_CACHE[`${name}-${version}`] = newCachedValues.pipe(filter(({
+            modelVersion
+          }) => modelVersion.name === name && modelVersion.version === version));
+        }
+        const loadSessions$ = from(noLoadedModelVersions).pipe(map(({
+          name,
+          version
+        }) => AuthmeEngineModuleBase._MODEL_CACHE[`${name}-${version}`]), mergeAll(), concatMap(({
+          modelVersion,
+          modelArrayBuffer
+        }) => of(this._engineRunAsync('loadSession', {
+          modelVersion,
+          modelArrayBuffer
+        }))), reduce((promises, item) => {
+          promises.push(item);
+          return promises;
+        }, []), concatMap(promises => defer(() => Promise.all(promises))));
+        yield firstValueFrom(loadSessions$);
+        const result = yield this._engineRunAsync('init');
+        this.initialized = true;
+        return result;
+      } catch (error) {
+        throw new AuthmeError(ErrorCode.ENGINE_MODULE_INIT_ERROR, error);
+      } finally {
+        this.initializing = false;
+      }
+    });
+  }
+  init() {
+    var _a;
+    return (_a = this._initPromise) !== null && _a !== void 0 ? _a : this._initPromise = this._init();
+  }
+  preloadAsync() {
+    return this.init();
+  }
+  startSession() {
+    this.received = true;
+    return this._engineRunAsync('start');
+  }
+  stop() {
+    return this._engineRunAsync('stop');
+  }
+  getReport() {
+    return this._engineRunAsync('getJsonReport');
+  }
+  recognition(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+      // status control
+      if (!this.received || !this.initialized || !this.setSized) {
+        throw new AuthmeError(ErrorCode.RECOGNITION_NOT_AVAILABLE);
+      }
+      try {
+        this.received = false;
+        const start = performance.now();
+        const return$ = yield this._engineRunAsync('recognition', {
+          data
+        });
+        this.received = true;
+        return Object.assign(Object.assign({}, return$), {
+          debugInfo: {
+            inferenceTime: performance.now() - start
+          }
+        });
+      } catch (error) {
+        this.received = true;
+        throw new AuthmeError(ErrorCode.RECOGNITION_ERROR, error);
+      }
+    });
+  }
+  getDebugImageData(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+      // status control
+      if (!this.received || !this.initialized || !this.setSized) {
+        throw new AuthmeError(ErrorCode.RECOGNITION_NOT_AVAILABLE);
+      }
+      try {
+        this.received = false;
+        const start = performance.now();
+        const return$ = yield this._engineRunAsync('getDebugImage', {
+          data
+        });
+        this.received = true;
+        return$.debugInfo = {
+          inferenceTime: performance.now() - start
+        };
+        return return$;
+      } catch (error) {
+        this.received = true;
+        throw new AuthmeError(ErrorCode.RECOGNITION_ERROR, error);
+      }
+    });
+  }
+  setFrameSize(width, height) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const result = yield this._engineRunAsync('setFrameSize', {
+        width,
+        height
+      });
+      this.setSized = true;
+      return result;
+    });
+  }
+  getParams() {
+    return this._engineRunAsync('getParams');
+  }
+  setParams(params) {
+    return this._engineRunAsync('setParams', {
+      params
+    });
+  }
+  setMaskPosition(positions) {
+    return this._engineRunAsync('setMaskPosition', {
+      positions
+    });
+  }
+  destroy() {
+    return __awaiter(this, void 0, void 0, function* () {
+      yield this._engineRunAsync('destroy');
+      this.initialized = false;
+      this._initPromise = undefined;
+      return true;
+    });
+  }
+  static reset_MODEL_CACHE() {
+    this._MODEL_CACHE = {};
+  }
+}
+AuthmeEngineModuleBase._MODEL_CACHE = {};
+
+export { AuthmeEngineModuleBase, AuthmeFunctionModule, EAuthMeCardClass, EAuthMeCardMatchStatus, EAuthMeCardOCRStatus, EAuthMeEngineReturnCode, EAuthMeEyeStatus, EAuthMeFASServiceStage, EAuthMeFASServiceStatus, EAuthMeFaceAntiSpoofingStatus, EAuthMeFacePose, EAuthMeIDCardAntiFraudStage, EAuthMeIDCardAntiFraudStatus, EAuthMeIDCardMetalTagStatus, EAuthMeMRZRecogStatus, EAuthMeMouthStatus, EAuthMePassportServiceStatus, EngineModule, MlEngine, defaultMlEngineConfig, version };

package/package.json

@@ -1,17 +1,15 @@
 {
   "name": "@authme/engine",
-  "version": "2.2.0",
-  "devDependencies": {
-    "rxjs": "~7.4.0"
-  },
-  "main": "./src/index.js",
-  "typings": "./src/index.d.ts",
-  "dependencies": {},
+  "version": "2.2.1-rc.3",
   "peerDependencies": {
-    "@authme/core": "2.2.0",
-    "@authme/util": "2.2.0",
-    "three": "^0.136.0",
-    "lottie-web": "^5.9.2",
-    "tslib": "^2.3.0"
-  }
+    "core-js": "^3.6.0",
+    "rxjs": "^7.4.0",
+    "@authme/core": "2.2.1-rc.3",
+    "@authme/util": "2.2.1-rc.3"
+  },
+  "module": "./index.js",
+  "main": "./index.cjs",
+  "type": "module",
+  "types": "./src/index.d.ts",
+  "dependencies": {}
 }

package/src/index.d.ts

@@ -1,3 +1,4 @@
-export * from './lib/engine';
-export * from './lib/enum';
-export * from './lib/interface';
+export * from './lib/engine';
+export * from './lib/enum';
+export * from './lib/interface';
+export { version } from './lib/version';