@authme/engine 2.8.41 → 2.8.44

package/{index.cjs → index.cjs.js}

@@ -1,58 +1,47 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 require('core-js/modules/es.array.iterator.js');
+require('core-js/modules/es.array.push.js');
+require('core-js/modules/es.array.sort.js');
+require('core-js/modules/es.array-buffer.constructor.js');
+require('core-js/modules/es.array-buffer.slice.js');
+require('core-js/modules/es.array-buffer.detached.js');
+require('core-js/modules/es.array-buffer.transfer.js');
+require('core-js/modules/es.array-buffer.transfer-to-fixed-length.js');
+require('core-js/modules/es.json.stringify.js');
+require('core-js/modules/es.object.assign.js');
 require('core-js/modules/es.object.from-entries.js');
+require('core-js/modules/es.parse-int.js');
+require('core-js/modules/es.promise.js');
 require('core-js/modules/es.regexp.exec.js');
-require('core-js/modules/es.array-buffer.slice.js');
+require('core-js/modules/es.regexp.test.js');
+require('core-js/modules/es.regexp.to-string.js');
 require('core-js/modules/es.typed-array.uint8-array.js');
+require('core-js/modules/es.typed-array.at.js');
 require('core-js/modules/es.typed-array.fill.js');
+require('core-js/modules/es.typed-array.find-last.js');
+require('core-js/modules/es.typed-array.find-last-index.js');
 require('core-js/modules/es.typed-array.set.js');
 require('core-js/modules/es.typed-array.sort.js');
 require('core-js/modules/es.typed-array.to-locale-string.js');
+require('core-js/modules/es.typed-array.to-reversed.js');
+require('core-js/modules/es.typed-array.to-sorted.js');
+require('core-js/modules/es.typed-array.with.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/esnext.uint8-array.to-base64.js');
+require('core-js/modules/esnext.uint8-array.to-hex.js');
 require('core-js/modules/web.dom-collections.iterator.js');
 require('core-js/modules/web.url.js');
+require('core-js/modules/web.url.to-json.js');
 require('core-js/modules/web.url-search-params.js');
-require('core-js/modules/es.promise.js');
-require('core-js/modules/es.parse-int.js');
-require('core-js/modules/es.object.assign.js');
-require('core-js/modules/es.regexp.to-string.js');
-require('core-js/modules/es.array.sort.js');
+require('core-js/modules/web.url-search-params.delete.js');
+require('core-js/modules/web.url-search-params.has.js');
+require('core-js/modules/web.url-search-params.size.js');
 var core = require('@authme/core');
 var util = require('@authme/util');
 var rxjs = require('rxjs');
-require('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());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
 
 exports.EngineModule = void 0;
 (function (EngineModule) {
@@ -71,8 +60,8 @@ exports.EAuthMeEngineReturnCode = void 0;
 })(exports.EAuthMeEngineReturnCode || (exports.EAuthMeEngineReturnCode = {}));
 
 var authEnumModule = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get EAuthMeEngineReturnCode () { return exports.EAuthMeEngineReturnCode; }
+  __proto__: null,
+  get EAuthMeEngineReturnCode () { return exports.EAuthMeEngineReturnCode; }
 });
 
 exports.EAuthMeCardClass = void 0;
@@ -80,7 +69,7 @@ exports.EAuthMeCardClass = void 0;
   EAuthMeCardClass["Invalid"] = "EAuthMeCardClass_Invalid";
   EAuthMeCardClass["Unknown"] = "EAuthMeCardClass_UnknownCard";
   EAuthMeCardClass["Passport"] = "EAuthMeCardClass_Passport";
-  EAuthMeCardClass["ALL_PASSPORT_CONTENT"] = "EAuthMeCardClass_Passport";
+  EAuthMeCardClass["ALL_PASSPORT_CONTENT"] = "EAuthMeCardClass_ALL_PASSPORT_CONTENT";
   EAuthMeCardClass["TWN_IDCard_Front"] = "EAuthMeCardClass_TWN_IDCard_Front";
   EAuthMeCardClass["TWN_IDCard_Back"] = "EAuthMeCardClass_TWN_IDCard_Back";
   EAuthMeCardClass["TWN_DriverLicense_Front"] = "EAuthMeCardClass_TWN_DriverLicense_Front";
@@ -109,10 +98,11 @@ exports.EAuthMeCardOCRStatus = void 0;
   EAuthMeCardOCRStatus["WrongCardType"] = "EAuthMeCardOCRStatus_WrongCardType";
   EAuthMeCardOCRStatus["PositionNotMatch"] = "EAuthMeCardOCRStatus_PositionNotMatch";
   EAuthMeCardOCRStatus["Reflective"] = "EAuthMeCardOCRStatus_Reflective";
+  EAuthMeCardOCRStatus["Gray"] = "EAuthMeCardOCRStatus_Gray";
   EAuthMeCardOCRStatus["Blur"] = "EAuthMeCardOCRStatus_Blur";
-  EAuthMeCardOCRStatus["Motion"] = "EAuthMeCardOCRStatus_Motion";
   EAuthMeCardOCRStatus["Pass"] = "EAuthMeCardOCRStatus_Pass";
   EAuthMeCardOCRStatus["Error"] = "EAuthMeCardOCRStatus_Error";
+  EAuthMeCardOCRStatus["Motion"] = "EAuthMeCardOCRStatus_Motion";
 })(exports.EAuthMeCardOCRStatus || (exports.EAuthMeCardOCRStatus = {}));
 exports.EAuthMeIDCardAntiFraudStatus = void 0;
 (function (EAuthMeIDCardAntiFraudStatus) {
@@ -138,6 +128,7 @@ exports.EAuthMeIDCardAntiFraudStatus = void 0;
   EAuthMeIDCardAntiFraudStatus["NeedHoldCard"] = "EAuthMeIDCardAntiFraudStatus_NeedHoldCard";
   EAuthMeIDCardAntiFraudStatus["StagePass"] = "EAuthMeIDCardAntiFraudStatus_StagePass";
   EAuthMeIDCardAntiFraudStatus["CardThicknessFailed"] = "EAuthMeIDCardAntiFraudStatus_CardThicknessFailed";
+  EAuthMeIDCardAntiFraudStatus["Undefined"] = "EAuthMeIDCardAntiFraudStatus_Undefined";
 })(exports.EAuthMeIDCardAntiFraudStatus || (exports.EAuthMeIDCardAntiFraudStatus = {}));
 exports.EAuthMeMRZRecogStatus = void 0;
 (function (EAuthMeMRZRecogStatus) {
@@ -146,13 +137,15 @@ exports.EAuthMeMRZRecogStatus = void 0;
 })(exports.EAuthMeMRZRecogStatus || (exports.EAuthMeMRZRecogStatus = {}));
 exports.EAuthMeMRZServiceStatus = void 0;
 (function (EAuthMeMRZServiceStatus) {
-  EAuthMeMRZServiceStatus["Success"] = "EAuthMeMRZServiceStatus_Success";
   EAuthMeMRZServiceStatus["NotFound"] = "EAuthMeMRZServiceStatus_NotFound";
-  EAuthMeMRZServiceStatus["RecogFailed"] = "EAuthMeMRZServiceStatus_RecogFailed";
-  EAuthMeMRZServiceStatus["WrongCardType"] = "EAuthMeMRZServiceStatus_WrongCardType";
-  EAuthMeMRZServiceStatus["Error"] = "EAuthMeMRZServiceStatus_Error";
   EAuthMeMRZServiceStatus["NotAligned"] = "EAuthMeMRZServiceStatus_NotAligned";
   EAuthMeMRZServiceStatus["Reflective"] = "EAuthMeMRZServiceStatus_Reflective";
+  EAuthMeMRZServiceStatus["Blur"] = "EAuthMeMRZServiceStatus_Blur";
+  EAuthMeMRZServiceStatus["WrongCardType"] = "EAuthMeMRZServiceStatus_WrongCardType";
+  EAuthMeMRZServiceStatus["MRZNotFound"] = "EAuthMeMRZServiceStatus_MRZNotFound";
+  EAuthMeMRZServiceStatus["RecogFailed"] = "EAuthMeMRZServiceStatus_RecogFailed";
+  EAuthMeMRZServiceStatus["Success"] = "EAuthMeMRZServiceStatus_Success";
+  EAuthMeMRZServiceStatus["Error"] = "EAuthMeMRZServiceStatus_Error";
 })(exports.EAuthMeMRZServiceStatus || (exports.EAuthMeMRZServiceStatus = {}));
 exports.EAuthMeIDCardAntiFraudStage = void 0;
 (function (EAuthMeIDCardAntiFraudStage) {
@@ -166,15 +159,15 @@ exports.EAuthMeIDCardAntiFraudStage = void 0;
 })(exports.EAuthMeIDCardAntiFraudStage || (exports.EAuthMeIDCardAntiFraudStage = {}));
 
 var idRecognitionEnumModule = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get EAuthMeCardClass () { return exports.EAuthMeCardClass; },
-    get EAuthMeIDCardMetalTagStatus () { return exports.EAuthMeIDCardMetalTagStatus; },
-    get EAuthMeCardMatchStatus () { return exports.EAuthMeCardMatchStatus; },
-    get EAuthMeCardOCRStatus () { return exports.EAuthMeCardOCRStatus; },
-    get EAuthMeIDCardAntiFraudStatus () { return exports.EAuthMeIDCardAntiFraudStatus; },
-    get EAuthMeMRZRecogStatus () { return exports.EAuthMeMRZRecogStatus; },
-    get EAuthMeMRZServiceStatus () { return exports.EAuthMeMRZServiceStatus; },
-    get EAuthMeIDCardAntiFraudStage () { return exports.EAuthMeIDCardAntiFraudStage; }
+  __proto__: null,
+  get EAuthMeCardClass () { return exports.EAuthMeCardClass; },
+  get EAuthMeCardMatchStatus () { return exports.EAuthMeCardMatchStatus; },
+  get EAuthMeCardOCRStatus () { return exports.EAuthMeCardOCRStatus; },
+  get EAuthMeIDCardAntiFraudStage () { return exports.EAuthMeIDCardAntiFraudStage; },
+  get EAuthMeIDCardAntiFraudStatus () { return exports.EAuthMeIDCardAntiFraudStatus; },
+  get EAuthMeIDCardMetalTagStatus () { return exports.EAuthMeIDCardMetalTagStatus; },
+  get EAuthMeMRZRecogStatus () { return exports.EAuthMeMRZRecogStatus; },
+  get EAuthMeMRZServiceStatus () { return exports.EAuthMeMRZServiceStatus; }
 });
 
 exports.EAuthMeFASServiceStatus = void 0;
@@ -234,13 +227,13 @@ exports.EAuthMeFaceAntiSpoofingStatus = void 0;
 })(exports.EAuthMeFaceAntiSpoofingStatus || (exports.EAuthMeFaceAntiSpoofingStatus = {}));
 
 var fasRecognitionEnumModule = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get EAuthMeFASServiceStatus () { return exports.EAuthMeFASServiceStatus; },
-    get EAuthMeFASServiceStage () { return exports.EAuthMeFASServiceStage; },
-    get EAuthMeEyeStatus () { return exports.EAuthMeEyeStatus; },
-    get EAuthMeMouthStatus () { return exports.EAuthMeMouthStatus; },
-    get EAuthMeFacePose () { return exports.EAuthMeFacePose; },
-    get EAuthMeFaceAntiSpoofingStatus () { return exports.EAuthMeFaceAntiSpoofingStatus; }
+  __proto__: null,
+  get EAuthMeEyeStatus () { return exports.EAuthMeEyeStatus; },
+  get EAuthMeFASServiceStage () { return exports.EAuthMeFASServiceStage; },
+  get EAuthMeFASServiceStatus () { return exports.EAuthMeFASServiceStatus; },
+  get EAuthMeFaceAntiSpoofingStatus () { return exports.EAuthMeFaceAntiSpoofingStatus; },
+  get EAuthMeFacePose () { return exports.EAuthMeFacePose; },
+  get EAuthMeMouthStatus () { return exports.EAuthMeMouthStatus; }
 });
 
 const defaultMlEngineConfig = {
@@ -253,18 +246,14 @@ const defaultMlEngineConfig = {
 };
 
 var name = "authme/sdk";
-var version$1 = "2.8.41";
-var date = "2026-01-30T10:27:23+0000";
+var version$1 = "2.8.44";
 var sdkInfo = {
 	name: name,
-	version: version$1,
-	date: date
-};
+	version: version$1};
 
-var _a;
-var _b, _c;
+var _window, _Symbol$for, _window$_Symbol$for;
 const version = sdkInfo.version;
-(_a = (_b = window)[_c = Symbol.for('authme-sdk')]) !== null && _a !== void 0 ? _a : _b[_c] = {};
+(_window$_Symbol$for = (_window = window)[_Symbol$for = Symbol.for('authme-sdk')]) != null ? _window$_Symbol$for : _window[_Symbol$for] = {};
 window[Symbol.for('authme-sdk')][sdkInfo.name] = version;
 
 function logCollect(message, stackTrace) {
@@ -281,17 +270,36 @@ function logCollect(message, stackTrace) {
   });
 }
 
+var _MlEngine, _AuthmeEngineModuleBase;
 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
+  const DOWNLOAD_ORDER = Object.fromEntries(['FACE_03',
+  // 3.7m
+  'FACE_00',
+  // 1.6m
+  'IDCardAntiFraud_00',
+  //1.5m
+  'FACE_01',
+  // 1.4m
+  'OCR_00',
+  // 1.4m
+  'FACE_02',
+  // 1.3m
+  'OCR_02',
+  // 548k
+  'MRZ_00',
+  // 548k
+  'OCR_01',
+  // 375k
+  '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;
+    var _DOWNLOAD_ORDER$key;
+    return (_DOWNLOAD_ORDER$key = DOWNLOAD_ORDER[key]) != null ? _DOWNLOAD_ORDER$key : Number.MAX_VALUE;
   };
 }();
 function isSimdSupported() {
@@ -323,54 +331,46 @@ function getJsContentAsync(url) {
     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;
-  });
+async function createWorkerWithObjectUrlAsync(url) {
+  const scriptContent = await 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 core.sendRequest('/api/model-management/v1/model?' + queryString);
-    return response.models;
-  });
+async function fetchModelCodesAsync(modelVersions) {
+  const queryString = modelVersions.map(convertToModelQueryString).join('&');
+  const response = await core.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 core.sendRequest(`/api/model-management/v1/model/${code}${dataTransferMethod === 'binary' ? '/file' : ''}`);
-    if (dataTransferMethod === 'binary') {
-      return payload;
-    } else {
-      return yield base64ToBufferAsync(payload.data);
-    }
-  });
+async function fetchModelContentAsync(code, dataTransferMethod) {
+  const payload = await core.sendRequest(`/api/model-management/v1/model/${code}${dataTransferMethod === 'binary' ? '/file' : ''}`);
+  if (dataTransferMethod === 'binary') {
+    return payload;
+  } else {
+    return await base64ToBufferAsync(payload.data);
+  }
 }
 function fetchModelContents(modelVersions, dataTransferMethod) {
   return rxjs.of(modelVersions).pipe(rxjs.concatMap(modelVersions => rxjs.defer(() => fetchModelCodesAsync(modelVersions))), rxjs.concatAll(), rxjs.mergeMap(({
     name,
     version,
     code
-  }) => rxjs.defer(() => __awaiter(this, void 0, void 0, function* () {
-    return {
-      modelVersion: {
-        name,
-        version: `${parseInt(version)}`
-      },
-      modelArrayBuffer: yield fetchModelContentAsync(code, dataTransferMethod)
-    };
+  }) => rxjs.defer(async () => ({
+    modelVersion: {
+      name,
+      version: `${parseInt(version)}`
+    },
+    modelArrayBuffer: await fetchModelContentAsync(code, dataTransferMethod)
   })), 1
   // 下載 model 過程會分為 wait time & download time，
   // concurrent 設定越高，只能起到降低 wait time 的作用，但會拉長單一檔案完成下載的時間，
@@ -379,16 +379,13 @@ function fetchModelContents(modelVersions, dataTransferMethod) {
   // 所以 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)) {
-          util.Storage.setItem(key, config[key]);
-        }
+  async init(config) {
+    for (const key in config) {
+      if (Object.prototype.hasOwnProperty.call(config, key)) {
+        util.Storage.setItem(key, config[key]);
       }
-    });
+    }
   }
   static getVersion() {
     return version;
@@ -399,7 +396,7 @@ class MlEngine {
     this.workerAndStreamPromise = undefined;
     this.preloadPromise = undefined;
     this.debugTools = util.debugTools();
-    this.config = Object.assign(Object.assign(Object.assign({}, defaultMlEngineConfig), config), {
+    this.config = Object.assign({}, defaultMlEngineConfig, config, {
       isMobile: util.isMobile()
     });
   }
@@ -416,102 +413,88 @@ class MlEngine {
       durationTimeWorker.end();
     })));
   }
-  _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$ = rxjs.fromEvent(worker, 'message').pipe(rxjs.map(x => {
-        var _a, _b, _c, _d;
-        if ((_b = (_a = x.data) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.error) {
-          logCollect('workerMessage error', JSON.stringify((_d = (_c = x.data) === null || _c === void 0 ? void 0 : _c.value) === null || _d === void 0 ? void 0 : _d.error));
-          throw new core.AuthmeError(core.ErrorCode.SDK_INTERNAL_ERROR, 'unexpected worker error');
-        }
-        return x.data;
-      }), rxjs.shareReplay(1));
-      yield this._run(worker, workerMessage$, exports.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();
+  async _makeWorkerAndStreamAsync() {
+    var _this$config$scriptPa;
+    // 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 = await createWorkerWithObjectUrlAsync(`${(_this$config$scriptPa = this.config.scriptPath) != null ? _this$config$scriptPa : ''}engine-worker.js?t=${Date.now()}`);
+    const workerMessage$ = rxjs.fromEvent(worker, 'message').pipe(rxjs.map(x => {
+      var _x$data;
+      if ((_x$data = x.data) != null && (_x$data = _x$data.value) != null && _x$data.error) {
+        var _x$data2;
+        logCollect('workerMessage error', JSON.stringify((_x$data2 = x.data) == null || (_x$data2 = _x$data2.value) == null ? void 0 : _x$data2.error));
+        throw new core.AuthmeError(core.ErrorCode.SDK_INTERNAL_ERROR, 'unexpected worker error');
       }
-    });
+      return x.data;
+    }), rxjs.shareReplay(1));
+    await this._run(worker, workerMessage$, exports.EngineModule.Core, 'setConfig', this.config);
+    return [worker, workerMessage$];
+  }
+  async _backgroundPreloadAsync() {
+    var _this$workerAndStream;
+    const [worker, workerMessage$] = await ((_this$workerAndStream = this.workerAndStreamPromise) != null ? _this$workerAndStream : this.workerAndStreamPromise = this._makeWorkerAndStreamAsync());
+    await this._loadEngineAsync(worker, workerMessage$);
+    await this._checkEnumConsistencyAsync(worker, workerMessage$);
+    return [worker, workerMessage$];
+  }
+  async terminateWorkerAsync() {
+    if (this.workerAndStreamPromise || this.preloadPromise) {
+      const [worker, _] = await 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) {
-        logCollect('enum consistency problem', JSON.stringify(problem));
-        throw new core.AuthmeError(core.ErrorCode.SDK_INTERNAL_ERROR, {
-          problem
-        });
-      }
-    });
+    var _this$preloadPromise;
+    return (_this$preloadPromise = this.preloadPromise) != null ? _this$preloadPromise : this.preloadPromise = this._backgroundPreloadAsync();
+  }
+  async _checkEnumConsistencyAsync(worker, workerMessage$) {
+    const problem = await this._run(worker, workerMessage$, 'Core', 'checkEnumConsistency', Object.assign({}, authEnumModule, idRecognitionEnumModule, fasRecognitionEnumModule));
+    if (problem.length > 0) {
+      logCollect('enum consistency problem', JSON.stringify(problem));
+      throw new core.AuthmeError(core.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);
-    });
+  async run(module, command, value = {}) {
+    const [worker, workerMessage$] = await this._preloadAndWaitReadyAsync();
+    return await 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$, exports.EngineModule.Core, 'setConfig', this.config);
-      }
-    });
-  }
-  setPublicKeyForJson(pubKey) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const [worker, workerMessage$] = yield this._preloadAndWaitReadyAsync();
-      yield this._run(worker, workerMessage$, exports.EngineModule.Fas, 'setPublicKeyForJson', pubKey);
-    });
+  async setConfig(config) {
+    this.config = Object.assign({}, this.config, config);
+    if (this.workerAndStreamPromise) {
+      const [worker, workerMessage$] = await this._preloadAndWaitReadyAsync();
+      await this._run(worker, workerMessage$, exports.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 durationTimeNetworkEngine = this.debugTools.setTimeDuration('loadEngine_network');
-      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()}`)]);
-      durationTimeNetworkEngine.end();
-      return yield this._run(worker, workerMessage$, exports.EngineModule.Core, 'loadEngine', {
-        engineJsContent,
-        engineWasmContent
-      });
+  async setPublicKeyForJson(pubKey) {
+    const [worker, workerMessage$] = await this._preloadAndWaitReadyAsync();
+    await this._run(worker, workerMessage$, exports.EngineModule.Fas, 'setPublicKeyForJson', pubKey);
+  }
+  async _loadEngineAsync(worker, workerMessage$) {
+    var _this$config$scriptPa2, _this$config$scriptPa3, _this$config$scriptPa4, _this$config$scriptPa5, _MlEngine$_ENGINE_CAC;
+    // load js/wasm outside the worker.
+    const simdSupported = isSimdSupported();
+    const jsUrl = simdSupported ? `${(_this$config$scriptPa2 = this.config.scriptPath) != null ? _this$config$scriptPa2 : ''}ml_engine_web.simd.js` : `${(_this$config$scriptPa3 = this.config.scriptPath) != null ? _this$config$scriptPa3 : ''}ml_engine_web.js`;
+    const wasmUrl = simdSupported ? `${(_this$config$scriptPa4 = this.config.scriptPath) != null ? _this$config$scriptPa4 : ''}ml_engine_web.simd.wasm` : `${(_this$config$scriptPa5 = this.config.scriptPath) != null ? _this$config$scriptPa5 : ''}ml_engine_web.wasm`;
+    const durationTimeNetworkEngine = this.debugTools.setTimeDuration('loadEngine_network');
+    const [engineJsContent, engineWasmContent] = await ((_MlEngine$_ENGINE_CAC = MlEngine._ENGINE_CACHE) != null ? _MlEngine$_ENGINE_CAC : MlEngine._ENGINE_CACHE = Promise.all([getJsContentAsync(`${jsUrl}?t=${Date.now()}`), getWasmContentAsync(`${wasmUrl}?t=${Date.now()}`)]));
+    durationTimeNetworkEngine.end();
+    return await this._run(worker, workerMessage$, exports.EngineModule.Core, 'loadEngine', {
+      engineJsContent,
+      engineWasmContent
     });
   }
 }
-MlEngine._ENGINE_CACHE = undefined;
+_MlEngine = MlEngine;
+_MlEngine._ENGINE_CACHE = undefined;
 class AuthmeEngineModuleBase {
   constructor(engine) {
     this._initPromise = undefined;
@@ -524,59 +507,57 @@ class AuthmeEngineModuleBase {
   _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 core.AuthmeError(core.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(rxjs.shareReplay());
-        for (const {
-          name,
-          version
-        } of noCachedModelVersions) {
-          AuthmeEngineModuleBase._MODEL_CACHE[`${name}-${version}`] = newCachedValues.pipe(rxjs.filter(({
-            modelVersion
-          }) => modelVersion.name === name && modelVersion.version === version));
-        }
-        const loadSessions$ = rxjs.from(noLoadedModelVersions).pipe(rxjs.map(({
-          name,
-          version
-        }) => AuthmeEngineModuleBase._MODEL_CACHE[`${name}-${version}`]), rxjs.mergeAll(), rxjs.concatMap(({
-          modelVersion,
-          modelArrayBuffer
-        }) => rxjs.of(this._engineRunAsync('loadSession', {
-          modelVersion,
-          modelArrayBuffer
-        }))), rxjs.reduce((promises, item) => {
-          promises.push(item);
-          return promises;
-        }, []), rxjs.concatMap(promises => rxjs.defer(() => Promise.all(promises))));
-        yield rxjs.firstValueFrom(loadSessions$);
-        const result = yield this._engineRunAsync('init');
-        this.initialized = true;
-        return result;
-      } catch (error) {
-        logCollect('engine init error', JSON.stringify(error));
-        throw new core.AuthmeError(core.ErrorCode.ENGINE_MODULE_INIT_ERROR, error);
-      } finally {
-        this.initializing = false;
+  async _init() {
+    if (this.initialized) {
+      return true;
+    }
+    if (this.initializing) {
+      throw new core.AuthmeError(core.ErrorCode.ENGINE_MODULE_IS_INITIALIZING);
+    }
+    this.initializing = true;
+    try {
+      var _this$engine$getConfi;
+      const noLoadedModelVersions = await 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)), (_this$engine$getConfi = this.engine.getConfig().dataTransferMethod) != null ? _this$engine$getConfi : 'binary').pipe(rxjs.shareReplay());
+      for (const {
+        name,
+        version
+      } of noCachedModelVersions) {
+        AuthmeEngineModuleBase._MODEL_CACHE[`${name}-${version}`] = newCachedValues.pipe(rxjs.filter(({
+          modelVersion
+        }) => modelVersion.name === name && modelVersion.version === version));
       }
-    });
+      const loadSessions$ = rxjs.from(noLoadedModelVersions).pipe(rxjs.map(({
+        name,
+        version
+      }) => AuthmeEngineModuleBase._MODEL_CACHE[`${name}-${version}`]), rxjs.mergeAll(), rxjs.concatMap(({
+        modelVersion,
+        modelArrayBuffer
+      }) => rxjs.of(this._engineRunAsync('loadSession', {
+        modelVersion,
+        modelArrayBuffer
+      }))), rxjs.reduce((promises, item) => {
+        promises.push(item);
+        return promises;
+      }, []), rxjs.concatMap(promises => rxjs.defer(() => Promise.all(promises))));
+      await rxjs.firstValueFrom(loadSessions$);
+      const result = await this._engineRunAsync('init');
+      this.initialized = true;
+      return result;
+    } catch (error) {
+      logCollect('engine init error', JSON.stringify(error));
+      throw new core.AuthmeError(core.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();
+    var _this$_initPromise;
+    return (_this$_initPromise = this._initPromise) != null ? _this$_initPromise : this._initPromise = this._init();
   }
   preloadAsync() {
     return this.init();
@@ -594,66 +575,60 @@ class AuthmeEngineModuleBase {
   setOption(params) {
     return this._engineRunAsync('setOption', params);
   }
-  recognition(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-      // status control
-      if (!this.received || !this.initialized || !this.setSized) {
-        logCollect('recognition not available', JSON.stringify(core.ErrorCode.RECOGNITION_NOT_AVAILABLE));
-        throw new core.AuthmeError(core.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;
-        logCollect('recognition error', JSON.stringify(error));
-        throw new core.AuthmeError(core.ErrorCode.RECOGNITION_ERROR, error);
-      }
-    });
-  }
-  getDebugImageData(data) {
-    return __awaiter(this, void 0, void 0, function* () {
-      // status control
-      if (!this.received || !this.initialized || !this.setSized) {
-        logCollect('getDebugImageData recognition not available', JSON.stringify(core.ErrorCode.RECOGNITION_NOT_AVAILABLE));
-        throw new core.AuthmeError(core.ErrorCode.RECOGNITION_NOT_AVAILABLE);
-      }
-      try {
-        this.received = false;
-        const start = performance.now();
-        const return$ = yield this._engineRunAsync('getDebugImage', {
-          data
-        });
-        this.received = true;
-        return$.debugInfo = {
+  async recognition(data) {
+    // status control
+    if (!this.received || !this.initialized || !this.setSized) {
+      logCollect('recognition not available', JSON.stringify(core.ErrorCode.RECOGNITION_NOT_AVAILABLE));
+      throw new core.AuthmeError(core.ErrorCode.RECOGNITION_NOT_AVAILABLE);
+    }
+    try {
+      this.received = false;
+      const start = performance.now();
+      const return$ = await this._engineRunAsync('recognition', {
+        data
+      });
+      this.received = true;
+      return Object.assign({}, return$, {
+        debugInfo: {
           inferenceTime: performance.now() - start
-        };
-        return return$;
-      } catch (error) {
-        this.received = true;
-        logCollect('getDebugImageData recognition error', JSON.stringify(error));
-        throw new core.AuthmeError(core.ErrorCode.RECOGNITION_ERROR, error);
-      }
-    });
+        }
+      });
+    } catch (error) {
+      this.received = true;
+      logCollect('recognition error', JSON.stringify(error));
+      throw new core.AuthmeError(core.ErrorCode.RECOGNITION_ERROR, error);
+    }
   }
-  setFrameSize(width, height) {
-    return __awaiter(this, void 0, void 0, function* () {
-      const result = yield this._engineRunAsync('setFrameSize', {
-        width,
-        height
+  async getDebugImageData(data) {
+    // status control
+    if (!this.received || !this.initialized || !this.setSized) {
+      logCollect('getDebugImageData recognition not available', JSON.stringify(core.ErrorCode.RECOGNITION_NOT_AVAILABLE));
+      throw new core.AuthmeError(core.ErrorCode.RECOGNITION_NOT_AVAILABLE);
+    }
+    try {
+      this.received = false;
+      const start = performance.now();
+      const return$ = await this._engineRunAsync('getDebugImage', {
+        data
       });
-      this.setSized = true;
-      return result;
+      this.received = true;
+      return$.debugInfo = {
+        inferenceTime: performance.now() - start
+      };
+      return return$;
+    } catch (error) {
+      this.received = true;
+      logCollect('getDebugImageData recognition error', JSON.stringify(error));
+      throw new core.AuthmeError(core.ErrorCode.RECOGNITION_ERROR, error);
+    }
+  }
+  async setFrameSize(width, height) {
+    const result = await this._engineRunAsync('setFrameSize', {
+      width,
+      height
     });
+    this.setSized = true;
+    return result;
   }
   getParams() {
     return this._engineRunAsync('getParams');
@@ -668,38 +643,30 @@ class AuthmeEngineModuleBase {
       positions
     });
   }
-  encryptString(str, key) {
-    return __awaiter(this, void 0, void 0, function* () {
-      return yield this._engineRunAsync('encryptString', {
-        string: str,
-        key
-      });
+  async encryptString(str, key) {
+    return await this._engineRunAsync('encryptString', {
+      string: str,
+      key
     });
   }
-  encryptBlob(uint8Array, key) {
-    return __awaiter(this, void 0, void 0, function* () {
-      return yield this._engineRunAsync('encryptBlob', {
-        uint8Array: uint8Array,
-        key
-      });
+  async encryptBlob(uint8Array, key) {
+    return await this._engineRunAsync('encryptBlob', {
+      uint8Array: uint8Array,
+      key
     });
   }
   // 測試圖片上傳加密用，未來實作後請刪除。
-  _decryptString(str, key) {
-    return __awaiter(this, void 0, void 0, function* () {
-      return yield this._engineRunAsync('_decryptString', {
-        string: str,
-        key
-      });
+  async _decryptString(str, key) {
+    return await this._engineRunAsync('_decryptString', {
+      string: str,
+      key
     });
   }
-  destroy() {
-    return __awaiter(this, void 0, void 0, function* () {
-      yield this._engineRunAsync('destroy');
-      this.initialized = false;
-      this._initPromise = undefined;
-      return true;
-    });
+  async destroy() {
+    await this._engineRunAsync('destroy');
+    this.initialized = false;
+    this._initPromise = undefined;
+    return true;
   }
   getUIParams() {
     return this.engine.run(this.moduleName, 'getUIParams');
@@ -711,7 +678,8 @@ class AuthmeEngineModuleBase {
     this._MODEL_CACHE = {};
   }
 }
-AuthmeEngineModuleBase._MODEL_CACHE = {};
+_AuthmeEngineModuleBase = AuthmeEngineModuleBase;
+_AuthmeEngineModuleBase._MODEL_CACHE = {};
 
 exports.AuthmeEngineModuleBase = AuthmeEngineModuleBase;
 exports.AuthmeFunctionModule = AuthmeFunctionModule;