@authme/core 2.8.41 → 2.8.44

package/index.cjs.js

@@ -0,0 +1,2091 @@
+'use strict';
+
+var util = require('@authme/util');
+require('core-js/modules/es.array.iterator.js');
+require('core-js/modules/es.array.push.js');
+require('core-js/modules/es.object.assign.js');
+require('core-js/modules/es.promise.js');
+require('core-js/modules/es.regexp.to-string.js');
+require('core-js/modules/esnext.iterator.constructor.js');
+require('core-js/modules/esnext.iterator.every.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/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');
+require('core-js/modules/es.regexp.constructor.js');
+require('core-js/modules/es.regexp.dot-all.js');
+require('core-js/modules/es.regexp.exec.js');
+require('core-js/modules/es.string.replace.js');
+require('core-js/modules/esnext.iterator.for-each.js');
+require('core-js/modules/es.json.stringify.js');
+require('core-js/modules/esnext.iterator.filter.js');
+require('core-js/modules/esnext.iterator.map.js');
+require('core-js/modules/es.symbol.description.js');
+require('core-js/modules/es.error.cause.js');
+require('core-js/modules/es.string.ends-with.js');
+
+function core() {
+  return 'core';
+}
+
+var name = "authme/sdk";
+var version$1 = "2.8.44";
+var packageInfo = {
+	name: name,
+	version: version$1};
+
+var _window, _Symbol$for, _window$_Symbol$for;
+const version = packageInfo.version;
+(_window$_Symbol$for = (_window = window)[_Symbol$for = Symbol.for('authme-sdk')]) != null ? _window$_Symbol$for : _window[_Symbol$for] = {};
+window[Symbol.for('authme-sdk')][packageInfo.name] = version;
+
+function requestLoggingWapper() {
+  let loggingFuncInstance = undefined;
+  return {
+    setRequestLoggingFunc: func => {
+      loggingFuncInstance = func;
+    },
+    getRequestLoggingFunc: () => loggingFuncInstance
+  };
+}
+const {
+  setRequestLoggingFunc,
+  getRequestLoggingFunc
+} = requestLoggingWapper();
+async function tryLoadAndParseJsonAsync(response) {
+  try {
+    return [undefined, await response.json()];
+  } catch (error) {
+    return [error, undefined];
+  }
+}
+async function tryLoadAndParseTextAsync(response) {
+  try {
+    return [undefined, await response.text()];
+  } catch (error) {
+    return [error, undefined];
+  }
+}
+async function tryLoadArrayBufferAsync(response) {
+  try {
+    return [undefined, await response.arrayBuffer()];
+  } catch (error) {
+    return [error, undefined];
+  }
+}
+async function sendRequest(url, method = 'GET', {
+  body = undefined,
+  contentType = 'application/json',
+  expectedResponseContentTypes = null,
+  // 可以透過代入 null 的方式來取消預設值。
+  accessToken = util.Storage.getItem('token'),
+  baseUrl = util.Storage.getItem('apiBaseUrl'),
+  sdkInfo = [`sdk-version: ${version}`, `platform: ${navigator.platform}`].join(';')
+} = {}) {
+  const requestLoggingFunction = getRequestLoggingFunc();
+  const options = Object.assign({
+    method
+  }, body !== undefined ? {
+    body: body
+  } : {}, {
+    headers: Object.assign({}, accessToken ? {
+      Authorization: 'Bearer ' + accessToken
+    } : {}, typeof body !== 'undefined' && contentType !== 'multipart/form-data' ? {
+      'Content-Type': contentType
+    } : {}, sdkInfo ? {
+      'sdk-info': sdkInfo
+    } : {})
+  });
+  let resp;
+  try {
+    const normalizedUrl = baseUrl ? new URL(url, baseUrl).toString() : url;
+    resp = requestLoggingFunction ? await requestLoggingFunction(() => fetch(normalizedUrl.toString(), options), {
+      runFunction: util.RUN_FUNCTION_NAME.API_REQUEST,
+      message: {
+        url: normalizedUrl.toString(),
+        options
+      }
+    }) : await fetch(normalizedUrl.toString(), options);
+  } catch (error) {
+    throw new util.AuthmeError(util.ErrorCode.NETWORK_ERROR, error);
+  }
+  const responseContentType = resp.headers.has('content-type') ? resp.headers.get('content-type') : undefined;
+  const errorMessages = [];
+  let parsedError;
+  let responseContent;
+  if (!responseContentType) {
+    [parsedError, responseContent] = [undefined, undefined];
+  } else if (responseContentType.indexOf('application/json') >= 0) {
+    [parsedError, responseContent] = await tryLoadAndParseJsonAsync(resp);
+  } else if (responseContentType.indexOf('text/json') >= 0) {
+    [parsedError, responseContent] = await tryLoadAndParseJsonAsync(resp);
+  } else if (responseContentType.indexOf('text/') >= 0) {
+    [parsedError, responseContent] = await tryLoadAndParseTextAsync(resp);
+  } else if (responseContentType.indexOf('application/javascript') >= 0) {
+    [parsedError, responseContent] = await tryLoadAndParseTextAsync(resp);
+  } else {
+    [parsedError, responseContent] = await tryLoadArrayBufferAsync(resp);
+  }
+  if (!resp.ok) {
+    errorMessages.push('status code not in the range 200-299');
+  }
+  if (parsedError) {
+    errorMessages.push('parsedError when load/parse response');
+  }
+  if (expectedResponseContentTypes) {
+    if (!responseContentType || expectedResponseContentTypes.every(v => responseContentType.indexOf(v) < 0)) {
+      errorMessages.push(`responseContentType: expected value = ${expectedResponseContentTypes}` + `, but actual value = ${responseContentType}`);
+    }
+  }
+  if (errorMessages.length !== 0) {
+    // 5XX
+    if (resp.status >= 500 && resp.status < 600 && resp.status !== 503 && resp.status !== 504) {
+      throw new util.AuthmeError(util.ErrorCode.SERVER_ERROR, {
+        errorMessages,
+        meta: {
+          status: resp.status,
+          ok: resp.ok,
+          url,
+          responseContentType,
+          responseContent,
+          parsedError
+        }
+      });
+    }
+    throw new util.AuthmeError(util.ErrorCode.HTTP_ERROR_RESPONSE, {
+      errorMessages,
+      meta: {
+        status: resp.status,
+        ok: resp.ok,
+        url,
+        responseContentType,
+        responseContent,
+        parsedError
+      }
+    });
+  }
+  return responseContent;
+}
+
+exports.AuthmeLanguage = void 0;
+(function (AuthmeLanguage) {
+  AuthmeLanguage["zh-TW"] = "zh_Hant_TW";
+  AuthmeLanguage["en-US"] = "en_US";
+  AuthmeLanguage["ja-JP"] = "ja_JP";
+})(exports.AuthmeLanguage || (exports.AuthmeLanguage = {}));
+
+var _TranslateService;
+class TranslateService {
+  constructor() {
+    this.originalDict = {};
+    this.customDict = {};
+    this.languageOptions = [exports.AuthmeLanguage['zh-TW'], exports.AuthmeLanguage['en-US'], exports.AuthmeLanguage['ja-JP']];
+    this.currentLang = exports.AuthmeLanguage['zh-TW'];
+  }
+  async fetchSource(path) {
+    for (let i = 0; i < this.languageOptions.length; i++) {
+      const [resp, oldKeyResp] = await Promise.all([fetch(`${path}/${this.languageOptions[i]}.json`), fetch(`${path}/old/${this.languageOptions[i]}.json`)]);
+      if (oldKeyResp.ok && !localStorage.getItem('local')) {
+        this.originalDict[this.languageOptions[i]] = await oldKeyResp.json();
+      }
+      if (resp.ok) {
+        this.originalDict[this.languageOptions[i]] = Object.assign({}, this.originalDict[this.languageOptions[i]], await resp.json());
+      }
+    }
+    return true;
+  }
+  async extendSource(path, lang) {
+    const resp = await fetch(`${path}`);
+    if (resp.ok) {
+      this.customDict[lang] = await resp.json();
+    }
+    return true;
+  }
+  async setLang(lang) {
+    this.currentLang = lang;
+  }
+  translate(key, args = {}) {
+    var _ref, _this$customDict$this, _this$customDict$this2, _this$originalDict$th;
+    let str = (_ref = (_this$customDict$this = (_this$customDict$this2 = this.customDict[this.currentLang]) == null ? void 0 : _this$customDict$this2[key]) != null ? _this$customDict$this : (_this$originalDict$th = this.originalDict[this.currentLang]) == null ? void 0 : _this$originalDict$th[key]) != null ? _ref : key;
+    if (!str) {
+      return '';
+    }
+    if (Object.keys(args).length > 0) {
+      Object.keys(args).forEach(key => {
+        str = str.replace(new RegExp(`{{${key}}}`, 'g'), args[key].toString());
+      });
+    }
+    return str.replace(/\n$/, '').replace(/\n/g, '<br>');
+  }
+  getCurrentLang() {
+    return this.currentLang;
+  }
+}
+_TranslateService = TranslateService;
+_TranslateService.instance = null;
+function getTranslateInstance() {
+  if (!TranslateService.instance) {
+    TranslateService.instance = new TranslateService();
+  }
+  return TranslateService.instance;
+}
+
+/******************************************************************************
+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.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+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());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+function createErrorClass(createImpl) {
+    var _super = function (instance) {
+        Error.call(instance);
+        instance.stack = new Error().stack;
+    };
+    var ctorFunc = createImpl(_super);
+    ctorFunc.prototype = Object.create(Error.prototype);
+    ctorFunc.prototype.constructor = ctorFunc;
+    return ctorFunc;
+}
+
+var UnsubscriptionError = createErrorClass(function (_super) {
+    return function UnsubscriptionErrorImpl(errors) {
+        _super(this);
+        this.message = errors
+            ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n  ')
+            : '';
+        this.name = 'UnsubscriptionError';
+        this.errors = errors;
+    };
+});
+
+function arrRemove(arr, item) {
+    if (arr) {
+        var index = arr.indexOf(item);
+        0 <= index && arr.splice(index, 1);
+    }
+}
+
+var Subscription = (function () {
+    function Subscription(initialTeardown) {
+        this.initialTeardown = initialTeardown;
+        this.closed = false;
+        this._parentage = null;
+        this._finalizers = null;
+    }
+    Subscription.prototype.unsubscribe = function () {
+        var e_1, _a, e_2, _b;
+        var errors;
+        if (!this.closed) {
+            this.closed = true;
+            var _parentage = this._parentage;
+            if (_parentage) {
+                this._parentage = null;
+                if (Array.isArray(_parentage)) {
+                    try {
+                        for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+                            var parent_1 = _parentage_1_1.value;
+                            parent_1.remove(this);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+                else {
+                    _parentage.remove(this);
+                }
+            }
+            var initialFinalizer = this.initialTeardown;
+            if (isFunction(initialFinalizer)) {
+                try {
+                    initialFinalizer();
+                }
+                catch (e) {
+                    errors = e instanceof UnsubscriptionError ? e.errors : [e];
+                }
+            }
+            var _finalizers = this._finalizers;
+            if (_finalizers) {
+                this._finalizers = null;
+                try {
+                    for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+                        var finalizer = _finalizers_1_1.value;
+                        try {
+                            execFinalizer(finalizer);
+                        }
+                        catch (err) {
+                            errors = errors !== null && errors !== void 0 ? errors : [];
+                            if (err instanceof UnsubscriptionError) {
+                                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                            }
+                            else {
+                                errors.push(err);
+                            }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            if (errors) {
+                throw new UnsubscriptionError(errors);
+            }
+        }
+    };
+    Subscription.prototype.add = function (teardown) {
+        var _a;
+        if (teardown && teardown !== this) {
+            if (this.closed) {
+                execFinalizer(teardown);
+            }
+            else {
+                if (teardown instanceof Subscription) {
+                    if (teardown.closed || teardown._hasParent(this)) {
+                        return;
+                    }
+                    teardown._addParent(this);
+                }
+                (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+            }
+        }
+    };
+    Subscription.prototype._hasParent = function (parent) {
+        var _parentage = this._parentage;
+        return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
+    };
+    Subscription.prototype._addParent = function (parent) {
+        var _parentage = this._parentage;
+        this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+    };
+    Subscription.prototype._removeParent = function (parent) {
+        var _parentage = this._parentage;
+        if (_parentage === parent) {
+            this._parentage = null;
+        }
+        else if (Array.isArray(_parentage)) {
+            arrRemove(_parentage, parent);
+        }
+    };
+    Subscription.prototype.remove = function (teardown) {
+        var _finalizers = this._finalizers;
+        _finalizers && arrRemove(_finalizers, teardown);
+        if (teardown instanceof Subscription) {
+            teardown._removeParent(this);
+        }
+    };
+    Subscription.EMPTY = (function () {
+        var empty = new Subscription();
+        empty.closed = true;
+        return empty;
+    })();
+    return Subscription;
+}());
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+    return (value instanceof Subscription ||
+        (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
+}
+function execFinalizer(finalizer) {
+    if (isFunction(finalizer)) {
+        finalizer();
+    }
+    else {
+        finalizer.unsubscribe();
+    }
+}
+
+var config = {
+    Promise: undefined};
+
+var timeoutProvider = {
+    setTimeout: function (handler, timeout) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+    },
+    clearTimeout: function (handle) {
+        return (clearTimeout)(handle);
+    },
+    delegate: undefined,
+};
+
+function reportUnhandledError(err) {
+    timeoutProvider.setTimeout(function () {
+        {
+            throw err;
+        }
+    });
+}
+
+function noop() { }
+
+function errorContext(cb) {
+    {
+        cb();
+    }
+}
+
+var Subscriber = (function (_super) {
+    __extends(Subscriber, _super);
+    function Subscriber(destination) {
+        var _this = _super.call(this) || this;
+        _this.isStopped = false;
+        if (destination) {
+            _this.destination = destination;
+            if (isSubscription(destination)) {
+                destination.add(_this);
+            }
+        }
+        else {
+            _this.destination = EMPTY_OBSERVER;
+        }
+        return _this;
+    }
+    Subscriber.create = function (next, error, complete) {
+        return new SafeSubscriber(next, error, complete);
+    };
+    Subscriber.prototype.next = function (value) {
+        if (this.isStopped) ;
+        else {
+            this._next(value);
+        }
+    };
+    Subscriber.prototype.error = function (err) {
+        if (this.isStopped) ;
+        else {
+            this.isStopped = true;
+            this._error(err);
+        }
+    };
+    Subscriber.prototype.complete = function () {
+        if (this.isStopped) ;
+        else {
+            this.isStopped = true;
+            this._complete();
+        }
+    };
+    Subscriber.prototype.unsubscribe = function () {
+        if (!this.closed) {
+            this.isStopped = true;
+            _super.prototype.unsubscribe.call(this);
+            this.destination = null;
+        }
+    };
+    Subscriber.prototype._next = function (value) {
+        this.destination.next(value);
+    };
+    Subscriber.prototype._error = function (err) {
+        try {
+            this.destination.error(err);
+        }
+        finally {
+            this.unsubscribe();
+        }
+    };
+    Subscriber.prototype._complete = function () {
+        try {
+            this.destination.complete();
+        }
+        finally {
+            this.unsubscribe();
+        }
+    };
+    return Subscriber;
+}(Subscription));
+var ConsumerObserver = (function () {
+    function ConsumerObserver(partialObserver) {
+        this.partialObserver = partialObserver;
+    }
+    ConsumerObserver.prototype.next = function (value) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.next) {
+            try {
+                partialObserver.next(value);
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+    };
+    ConsumerObserver.prototype.error = function (err) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.error) {
+            try {
+                partialObserver.error(err);
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+        else {
+            handleUnhandledError(err);
+        }
+    };
+    ConsumerObserver.prototype.complete = function () {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.complete) {
+            try {
+                partialObserver.complete();
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+    };
+    return ConsumerObserver;
+}());
+var SafeSubscriber = (function (_super) {
+    __extends(SafeSubscriber, _super);
+    function SafeSubscriber(observerOrNext, error, complete) {
+        var _this = _super.call(this) || this;
+        var partialObserver;
+        if (isFunction(observerOrNext) || !observerOrNext) {
+            partialObserver = {
+                next: (observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined),
+                error: error !== null && error !== void 0 ? error : undefined,
+                complete: complete !== null && complete !== void 0 ? complete : undefined,
+            };
+        }
+        else {
+            {
+                partialObserver = observerOrNext;
+            }
+        }
+        _this.destination = new ConsumerObserver(partialObserver);
+        return _this;
+    }
+    return SafeSubscriber;
+}(Subscriber));
+function handleUnhandledError(error) {
+    {
+        reportUnhandledError(error);
+    }
+}
+function defaultErrorHandler(err) {
+    throw err;
+}
+var EMPTY_OBSERVER = {
+    closed: true,
+    next: noop,
+    error: defaultErrorHandler,
+    complete: noop,
+};
+
+var observable = (function () { return (typeof Symbol === 'function' && Symbol.observable) || '@@observable'; })();
+
+function identity(x) {
+    return x;
+}
+
+function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce(function (prev, fn) { return fn(prev); }, input);
+    };
+}
+
+var Observable = (function () {
+    function Observable(subscribe) {
+        if (subscribe) {
+            this._subscribe = subscribe;
+        }
+    }
+    Observable.prototype.lift = function (operator) {
+        var observable = new Observable();
+        observable.source = this;
+        observable.operator = operator;
+        return observable;
+    };
+    Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+        var _this = this;
+        var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+        errorContext(function () {
+            var _a = _this, operator = _a.operator, source = _a.source;
+            subscriber.add(operator
+                ?
+                    operator.call(subscriber, source)
+                : source
+                    ?
+                        _this._subscribe(subscriber)
+                    :
+                        _this._trySubscribe(subscriber));
+        });
+        return subscriber;
+    };
+    Observable.prototype._trySubscribe = function (sink) {
+        try {
+            return this._subscribe(sink);
+        }
+        catch (err) {
+            sink.error(err);
+        }
+    };
+    Observable.prototype.forEach = function (next, promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function (resolve, reject) {
+            var subscriber = new SafeSubscriber({
+                next: function (value) {
+                    try {
+                        next(value);
+                    }
+                    catch (err) {
+                        reject(err);
+                        subscriber.unsubscribe();
+                    }
+                },
+                error: reject,
+                complete: resolve,
+            });
+            _this.subscribe(subscriber);
+        });
+    };
+    Observable.prototype._subscribe = function (subscriber) {
+        var _a;
+        return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+    };
+    Observable.prototype[observable] = function () {
+        return this;
+    };
+    Observable.prototype.pipe = function () {
+        var operations = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            operations[_i] = arguments[_i];
+        }
+        return pipeFromArray(operations)(this);
+    };
+    Observable.prototype.toPromise = function (promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function (resolve, reject) {
+            var value;
+            _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); });
+        });
+    };
+    Observable.create = function (subscribe) {
+        return new Observable(subscribe);
+    };
+    return Observable;
+}());
+function getPromiseCtor(promiseCtor) {
+    var _a;
+    return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+    return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+    return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
+}
+
+function hasLift(source) {
+    return isFunction(source === null || source === void 0 ? void 0 : source.lift);
+}
+function operate(init) {
+    return function (source) {
+        if (hasLift(source)) {
+            return source.lift(function (liftedSource) {
+                try {
+                    return init(liftedSource, this);
+                }
+                catch (err) {
+                    this.error(err);
+                }
+            });
+        }
+        throw new TypeError('Unable to lift unknown Observable type');
+    };
+}
+
+function createOperatorSubscriber(destination, onNext, onComplete, onError, onFinalize) {
+    return new OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize);
+}
+var OperatorSubscriber = (function (_super) {
+    __extends(OperatorSubscriber, _super);
+    function OperatorSubscriber(destination, onNext, onComplete, onError, onFinalize, shouldUnsubscribe) {
+        var _this = _super.call(this, destination) || this;
+        _this.onFinalize = onFinalize;
+        _this.shouldUnsubscribe = shouldUnsubscribe;
+        _this._next = onNext
+            ? function (value) {
+                try {
+                    onNext(value);
+                }
+                catch (err) {
+                    destination.error(err);
+                }
+            }
+            : _super.prototype._next;
+        _this._error = onError
+            ? function (err) {
+                try {
+                    onError(err);
+                }
+                catch (err) {
+                    destination.error(err);
+                }
+                finally {
+                    this.unsubscribe();
+                }
+            }
+            : _super.prototype._error;
+        _this._complete = onComplete
+            ? function () {
+                try {
+                    onComplete();
+                }
+                catch (err) {
+                    destination.error(err);
+                }
+                finally {
+                    this.unsubscribe();
+                }
+            }
+            : _super.prototype._complete;
+        return _this;
+    }
+    OperatorSubscriber.prototype.unsubscribe = function () {
+        var _a;
+        if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+            var closed_1 = this.closed;
+            _super.prototype.unsubscribe.call(this);
+            !closed_1 && ((_a = this.onFinalize) === null || _a === void 0 ? void 0 : _a.call(this));
+        }
+    };
+    return OperatorSubscriber;
+}(Subscriber));
+
+var ObjectUnsubscribedError = createErrorClass(function (_super) {
+    return function ObjectUnsubscribedErrorImpl() {
+        _super(this);
+        this.name = 'ObjectUnsubscribedError';
+        this.message = 'object unsubscribed';
+    };
+});
+
+var Subject = (function (_super) {
+    __extends(Subject, _super);
+    function Subject() {
+        var _this = _super.call(this) || this;
+        _this.closed = false;
+        _this.currentObservers = null;
+        _this.observers = [];
+        _this.isStopped = false;
+        _this.hasError = false;
+        _this.thrownError = null;
+        return _this;
+    }
+    Subject.prototype.lift = function (operator) {
+        var subject = new AnonymousSubject(this, this);
+        subject.operator = operator;
+        return subject;
+    };
+    Subject.prototype._throwIfClosed = function () {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+    };
+    Subject.prototype.next = function (value) {
+        var _this = this;
+        errorContext(function () {
+            var e_1, _a;
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                if (!_this.currentObservers) {
+                    _this.currentObservers = Array.from(_this.observers);
+                }
+                try {
+                    for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var observer = _c.value;
+                        observer.next(value);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+        });
+    };
+    Subject.prototype.error = function (err) {
+        var _this = this;
+        errorContext(function () {
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                _this.hasError = _this.isStopped = true;
+                _this.thrownError = err;
+                var observers = _this.observers;
+                while (observers.length) {
+                    observers.shift().error(err);
+                }
+            }
+        });
+    };
+    Subject.prototype.complete = function () {
+        var _this = this;
+        errorContext(function () {
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                _this.isStopped = true;
+                var observers = _this.observers;
+                while (observers.length) {
+                    observers.shift().complete();
+                }
+            }
+        });
+    };
+    Subject.prototype.unsubscribe = function () {
+        this.isStopped = this.closed = true;
+        this.observers = this.currentObservers = null;
+    };
+    Object.defineProperty(Subject.prototype, "observed", {
+        get: function () {
+            var _a;
+            return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Subject.prototype._trySubscribe = function (subscriber) {
+        this._throwIfClosed();
+        return _super.prototype._trySubscribe.call(this, subscriber);
+    };
+    Subject.prototype._subscribe = function (subscriber) {
+        this._throwIfClosed();
+        this._checkFinalizedStatuses(subscriber);
+        return this._innerSubscribe(subscriber);
+    };
+    Subject.prototype._innerSubscribe = function (subscriber) {
+        var _this = this;
+        var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+        if (hasError || isStopped) {
+            return EMPTY_SUBSCRIPTION;
+        }
+        this.currentObservers = null;
+        observers.push(subscriber);
+        return new Subscription(function () {
+            _this.currentObservers = null;
+            arrRemove(observers, subscriber);
+        });
+    };
+    Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+        var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+        if (hasError) {
+            subscriber.error(thrownError);
+        }
+        else if (isStopped) {
+            subscriber.complete();
+        }
+    };
+    Subject.prototype.asObservable = function () {
+        var observable = new Observable();
+        observable.source = this;
+        return observable;
+    };
+    Subject.create = function (destination, source) {
+        return new AnonymousSubject(destination, source);
+    };
+    return Subject;
+}(Observable));
+var AnonymousSubject = (function (_super) {
+    __extends(AnonymousSubject, _super);
+    function AnonymousSubject(destination, source) {
+        var _this = _super.call(this) || this;
+        _this.destination = destination;
+        _this.source = source;
+        return _this;
+    }
+    AnonymousSubject.prototype.next = function (value) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+    };
+    AnonymousSubject.prototype.error = function (err) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+    };
+    AnonymousSubject.prototype.complete = function () {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+    };
+    AnonymousSubject.prototype._subscribe = function (subscriber) {
+        var _a, _b;
+        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+    };
+    return AnonymousSubject;
+}(Subject));
+
+var BehaviorSubject = (function (_super) {
+    __extends(BehaviorSubject, _super);
+    function BehaviorSubject(_value) {
+        var _this = _super.call(this) || this;
+        _this._value = _value;
+        return _this;
+    }
+    Object.defineProperty(BehaviorSubject.prototype, "value", {
+        get: function () {
+            return this.getValue();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BehaviorSubject.prototype._subscribe = function (subscriber) {
+        var subscription = _super.prototype._subscribe.call(this, subscriber);
+        !subscription.closed && subscriber.next(this._value);
+        return subscription;
+    };
+    BehaviorSubject.prototype.getValue = function () {
+        var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, _value = _a._value;
+        if (hasError) {
+            throw thrownError;
+        }
+        this._throwIfClosed();
+        return _value;
+    };
+    BehaviorSubject.prototype.next = function (value) {
+        _super.prototype.next.call(this, (this._value = value));
+    };
+    return BehaviorSubject;
+}(Subject));
+
+var dateTimestampProvider = {
+    now: function () {
+        return (Date).now();
+    }};
+
+var Action = (function (_super) {
+    __extends(Action, _super);
+    function Action(scheduler, work) {
+        return _super.call(this) || this;
+    }
+    Action.prototype.schedule = function (state, delay) {
+        return this;
+    };
+    return Action;
+}(Subscription));
+
+var intervalProvider = {
+    setInterval: function (handler, timeout) {
+        var args = [];
+        for (var _i = 2; _i < arguments.length; _i++) {
+            args[_i - 2] = arguments[_i];
+        }
+        return setInterval.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+    },
+    clearInterval: function (handle) {
+        return (clearInterval)(handle);
+    },
+    delegate: undefined,
+};
+
+var AsyncAction = (function (_super) {
+    __extends(AsyncAction, _super);
+    function AsyncAction(scheduler, work) {
+        var _this = _super.call(this, scheduler, work) || this;
+        _this.scheduler = scheduler;
+        _this.work = work;
+        _this.pending = false;
+        return _this;
+    }
+    AsyncAction.prototype.schedule = function (state, delay) {
+        var _a;
+        if (delay === void 0) { delay = 0; }
+        if (this.closed) {
+            return this;
+        }
+        this.state = state;
+        var id = this.id;
+        var scheduler = this.scheduler;
+        if (id != null) {
+            this.id = this.recycleAsyncId(scheduler, id, delay);
+        }
+        this.pending = true;
+        this.delay = delay;
+        this.id = (_a = this.id) !== null && _a !== void 0 ? _a : this.requestAsyncId(scheduler, this.id, delay);
+        return this;
+    };
+    AsyncAction.prototype.requestAsyncId = function (scheduler, _id, delay) {
+        if (delay === void 0) { delay = 0; }
+        return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+    };
+    AsyncAction.prototype.recycleAsyncId = function (_scheduler, id, delay) {
+        if (delay === void 0) { delay = 0; }
+        if (delay != null && this.delay === delay && this.pending === false) {
+            return id;
+        }
+        if (id != null) {
+            intervalProvider.clearInterval(id);
+        }
+        return undefined;
+    };
+    AsyncAction.prototype.execute = function (state, delay) {
+        if (this.closed) {
+            return new Error('executing a cancelled action');
+        }
+        this.pending = false;
+        var error = this._execute(state, delay);
+        if (error) {
+            return error;
+        }
+        else if (this.pending === false && this.id != null) {
+            this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+        }
+    };
+    AsyncAction.prototype._execute = function (state, _delay) {
+        var errored = false;
+        var errorValue;
+        try {
+            this.work(state);
+        }
+        catch (e) {
+            errored = true;
+            errorValue = e ? e : new Error('Scheduled action threw falsy error');
+        }
+        if (errored) {
+            this.unsubscribe();
+            return errorValue;
+        }
+    };
+    AsyncAction.prototype.unsubscribe = function () {
+        if (!this.closed) {
+            var _a = this, id = _a.id, scheduler = _a.scheduler;
+            var actions = scheduler.actions;
+            this.work = this.state = this.scheduler = null;
+            this.pending = false;
+            arrRemove(actions, this);
+            if (id != null) {
+                this.id = this.recycleAsyncId(scheduler, id, null);
+            }
+            this.delay = null;
+            _super.prototype.unsubscribe.call(this);
+        }
+    };
+    return AsyncAction;
+}(Action));
+
+var Scheduler = (function () {
+    function Scheduler(schedulerActionCtor, now) {
+        if (now === void 0) { now = Scheduler.now; }
+        this.schedulerActionCtor = schedulerActionCtor;
+        this.now = now;
+    }
+    Scheduler.prototype.schedule = function (work, delay, state) {
+        if (delay === void 0) { delay = 0; }
+        return new this.schedulerActionCtor(this, work).schedule(state, delay);
+    };
+    Scheduler.now = dateTimestampProvider.now;
+    return Scheduler;
+}());
+
+var AsyncScheduler = (function (_super) {
+    __extends(AsyncScheduler, _super);
+    function AsyncScheduler(SchedulerAction, now) {
+        if (now === void 0) { now = Scheduler.now; }
+        var _this = _super.call(this, SchedulerAction, now) || this;
+        _this.actions = [];
+        _this._active = false;
+        return _this;
+    }
+    AsyncScheduler.prototype.flush = function (action) {
+        var actions = this.actions;
+        if (this._active) {
+            actions.push(action);
+            return;
+        }
+        var error;
+        this._active = true;
+        do {
+            if ((error = action.execute(action.state, action.delay))) {
+                break;
+            }
+        } while ((action = actions.shift()));
+        this._active = false;
+        if (error) {
+            while ((action = actions.shift())) {
+                action.unsubscribe();
+            }
+            throw error;
+        }
+    };
+    return AsyncScheduler;
+}(Scheduler));
+
+var asyncScheduler = new AsyncScheduler(AsyncAction);
+
+function isScheduler(value) {
+    return value && isFunction(value.schedule);
+}
+
+function last(arr) {
+    return arr[arr.length - 1];
+}
+function popScheduler(args) {
+    return isScheduler(last(args)) ? args.pop() : undefined;
+}
+
+var isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
+
+function isPromise(value) {
+    return isFunction(value === null || value === void 0 ? void 0 : value.then);
+}
+
+function isInteropObservable(input) {
+    return isFunction(input[observable]);
+}
+
+function isAsyncIterable(obj) {
+    return Symbol.asyncIterator && isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
+}
+
+function createInvalidObservableTypeError(input) {
+    return new TypeError("You provided " + (input !== null && typeof input === 'object' ? 'an invalid object' : "'" + input + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+
+function getSymbolIterator() {
+    if (typeof Symbol !== 'function' || !Symbol.iterator) {
+        return '@@iterator';
+    }
+    return Symbol.iterator;
+}
+var iterator = getSymbolIterator();
+
+function isIterable(input) {
+    return isFunction(input === null || input === void 0 ? void 0 : input[iterator]);
+}
+
+function readableStreamLikeToAsyncGenerator(readableStream) {
+    return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
+        var reader, _a, value, done;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    reader = readableStream.getReader();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, , 9, 10]);
+                    _b.label = 2;
+                case 2:
+                    return [4, __await(reader.read())];
+                case 3:
+                    _a = _b.sent(), value = _a.value, done = _a.done;
+                    if (!done) return [3, 5];
+                    return [4, __await(void 0)];
+                case 4: return [2, _b.sent()];
+                case 5: return [4, __await(value)];
+                case 6: return [4, _b.sent()];
+                case 7:
+                    _b.sent();
+                    return [3, 2];
+                case 8: return [3, 10];
+                case 9:
+                    reader.releaseLock();
+                    return [7];
+                case 10: return [2];
+            }
+        });
+    });
+}
+function isReadableStreamLike(obj) {
+    return isFunction(obj === null || obj === void 0 ? void 0 : obj.getReader);
+}
+
+function innerFrom(input) {
+    if (input instanceof Observable) {
+        return input;
+    }
+    if (input != null) {
+        if (isInteropObservable(input)) {
+            return fromInteropObservable(input);
+        }
+        if (isArrayLike(input)) {
+            return fromArrayLike(input);
+        }
+        if (isPromise(input)) {
+            return fromPromise(input);
+        }
+        if (isAsyncIterable(input)) {
+            return fromAsyncIterable(input);
+        }
+        if (isIterable(input)) {
+            return fromIterable(input);
+        }
+        if (isReadableStreamLike(input)) {
+            return fromReadableStreamLike(input);
+        }
+    }
+    throw createInvalidObservableTypeError(input);
+}
+function fromInteropObservable(obj) {
+    return new Observable(function (subscriber) {
+        var obs = obj[observable]();
+        if (isFunction(obs.subscribe)) {
+            return obs.subscribe(subscriber);
+        }
+        throw new TypeError('Provided object does not correctly implement Symbol.observable');
+    });
+}
+function fromArrayLike(array) {
+    return new Observable(function (subscriber) {
+        for (var i = 0; i < array.length && !subscriber.closed; i++) {
+            subscriber.next(array[i]);
+        }
+        subscriber.complete();
+    });
+}
+function fromPromise(promise) {
+    return new Observable(function (subscriber) {
+        promise
+            .then(function (value) {
+            if (!subscriber.closed) {
+                subscriber.next(value);
+                subscriber.complete();
+            }
+        }, function (err) { return subscriber.error(err); })
+            .then(null, reportUnhandledError);
+    });
+}
+function fromIterable(iterable) {
+    return new Observable(function (subscriber) {
+        var e_1, _a;
+        try {
+            for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) {
+                var value = iterable_1_1.value;
+                subscriber.next(value);
+                if (subscriber.closed) {
+                    return;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        subscriber.complete();
+    });
+}
+function fromAsyncIterable(asyncIterable) {
+    return new Observable(function (subscriber) {
+        process(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); });
+    });
+}
+function fromReadableStreamLike(readableStream) {
+    return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream));
+}
+function process(asyncIterable, subscriber) {
+    var asyncIterable_1, asyncIterable_1_1;
+    var e_2, _a;
+    return __awaiter(this, void 0, void 0, function () {
+        var value, e_2_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _b.trys.push([0, 5, 6, 11]);
+                    asyncIterable_1 = __asyncValues(asyncIterable);
+                    _b.label = 1;
+                case 1: return [4, asyncIterable_1.next()];
+                case 2:
+                    if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4];
+                    value = asyncIterable_1_1.value;
+                    subscriber.next(value);
+                    if (subscriber.closed) {
+                        return [2];
+                    }
+                    _b.label = 3;
+                case 3: return [3, 1];
+                case 4: return [3, 11];
+                case 5:
+                    e_2_1 = _b.sent();
+                    e_2 = { error: e_2_1 };
+                    return [3, 11];
+                case 6:
+                    _b.trys.push([6, , 9, 10]);
+                    if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8];
+                    return [4, _a.call(asyncIterable_1)];
+                case 7:
+                    _b.sent();
+                    _b.label = 8;
+                case 8: return [3, 10];
+                case 9:
+                    if (e_2) throw e_2.error;
+                    return [7];
+                case 10: return [7];
+                case 11:
+                    subscriber.complete();
+                    return [2];
+            }
+        });
+    });
+}
+
+function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+    if (delay === void 0) { delay = 0; }
+    if (repeat === void 0) { repeat = false; }
+    var scheduleSubscription = scheduler.schedule(function () {
+        work();
+        if (repeat) {
+            parentSubscription.add(this.schedule(null, delay));
+        }
+        else {
+            this.unsubscribe();
+        }
+    }, delay);
+    parentSubscription.add(scheduleSubscription);
+    if (!repeat) {
+        return scheduleSubscription;
+    }
+}
+
+function map(project, thisArg) {
+    return operate(function (source, subscriber) {
+        var index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+            subscriber.next(project.call(thisArg, value, index++));
+        }));
+    });
+}
+
+function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
+    var buffer = [];
+    var active = 0;
+    var index = 0;
+    var isComplete = false;
+    var checkComplete = function () {
+        if (isComplete && !buffer.length && !active) {
+            subscriber.complete();
+        }
+    };
+    var outerNext = function (value) { return (active < concurrent ? doInnerSub(value) : buffer.push(value)); };
+    var doInnerSub = function (value) {
+        active++;
+        var innerComplete = false;
+        innerFrom(project(value, index++)).subscribe(createOperatorSubscriber(subscriber, function (innerValue) {
+            {
+                subscriber.next(innerValue);
+            }
+        }, function () {
+            innerComplete = true;
+        }, undefined, function () {
+            if (innerComplete) {
+                try {
+                    active--;
+                    var _loop_1 = function () {
+                        var bufferedValue = buffer.shift();
+                        if (innerSubScheduler) ;
+                        else {
+                            doInnerSub(bufferedValue);
+                        }
+                    };
+                    while (buffer.length && active < concurrent) {
+                        _loop_1();
+                    }
+                    checkComplete();
+                }
+                catch (err) {
+                    subscriber.error(err);
+                }
+            }
+        }));
+    };
+    source.subscribe(createOperatorSubscriber(subscriber, outerNext, function () {
+        isComplete = true;
+        checkComplete();
+    }));
+    return function () {
+    };
+}
+
+function mergeMap(project, resultSelector, concurrent) {
+    if (concurrent === void 0) { concurrent = Infinity; }
+    if (isFunction(resultSelector)) {
+        return mergeMap(function (a, i) { return map(function (b, ii) { return resultSelector(a, b, i, ii); })(innerFrom(project(a, i))); }, concurrent);
+    }
+    else if (typeof resultSelector === 'number') {
+        concurrent = resultSelector;
+    }
+    return operate(function (source, subscriber) { return mergeInternals(source, subscriber, project, concurrent); });
+}
+
+function filter(predicate, thisArg) {
+    return operate(function (source, subscriber) {
+        var index = 0;
+        source.subscribe(createOperatorSubscriber(subscriber, function (value) { return predicate.call(thisArg, value, index++) && subscriber.next(value); }));
+    });
+}
+
+function bufferTime(bufferTimeSpan) {
+    var _a, _b;
+    var otherArgs = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        otherArgs[_i - 1] = arguments[_i];
+    }
+    var scheduler = (_a = popScheduler(otherArgs)) !== null && _a !== void 0 ? _a : asyncScheduler;
+    var bufferCreationInterval = (_b = otherArgs[0]) !== null && _b !== void 0 ? _b : null;
+    var maxBufferSize = otherArgs[1] || Infinity;
+    return operate(function (source, subscriber) {
+        var bufferRecords = [];
+        var restartOnEmit = false;
+        var emit = function (record) {
+            var buffer = record.buffer, subs = record.subs;
+            subs.unsubscribe();
+            arrRemove(bufferRecords, record);
+            subscriber.next(buffer);
+            restartOnEmit && startBuffer();
+        };
+        var startBuffer = function () {
+            if (bufferRecords) {
+                var subs = new Subscription();
+                subscriber.add(subs);
+                var buffer = [];
+                var record_1 = {
+                    buffer: buffer,
+                    subs: subs,
+                };
+                bufferRecords.push(record_1);
+                executeSchedule(subs, scheduler, function () { return emit(record_1); }, bufferTimeSpan);
+            }
+        };
+        if (bufferCreationInterval !== null && bufferCreationInterval >= 0) {
+            executeSchedule(subscriber, scheduler, startBuffer, bufferCreationInterval, true);
+        }
+        else {
+            restartOnEmit = true;
+        }
+        startBuffer();
+        var bufferTimeSubscriber = createOperatorSubscriber(subscriber, function (value) {
+            var e_1, _a;
+            var recordsCopy = bufferRecords.slice();
+            try {
+                for (var recordsCopy_1 = __values(recordsCopy), recordsCopy_1_1 = recordsCopy_1.next(); !recordsCopy_1_1.done; recordsCopy_1_1 = recordsCopy_1.next()) {
+                    var record = recordsCopy_1_1.value;
+                    var buffer = record.buffer;
+                    buffer.push(value);
+                    maxBufferSize <= buffer.length && emit(record);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (recordsCopy_1_1 && !recordsCopy_1_1.done && (_a = recordsCopy_1.return)) _a.call(recordsCopy_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }, function () {
+            while (bufferRecords === null || bufferRecords === void 0 ? void 0 : bufferRecords.length) {
+                subscriber.next(bufferRecords.shift().buffer);
+            }
+            bufferTimeSubscriber === null || bufferTimeSubscriber === void 0 ? void 0 : bufferTimeSubscriber.unsubscribe();
+            subscriber.complete();
+            subscriber.unsubscribe();
+        }, undefined, function () { return (bufferRecords = null); });
+        source.subscribe(bufferTimeSubscriber);
+    });
+}
+
+function tap(observerOrNext, error, complete) {
+    var tapObserver = isFunction(observerOrNext) || error || complete
+        ?
+            { next: observerOrNext, error: error, complete: complete }
+        : observerOrNext;
+    return tapObserver
+        ? operate(function (source, subscriber) {
+            var _a;
+            (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+            var isUnsub = true;
+            source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                var _a;
+                (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
+                subscriber.next(value);
+            }, function () {
+                var _a;
+                isUnsub = false;
+                (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                subscriber.complete();
+            }, function (err) {
+                var _a;
+                isUnsub = false;
+                (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
+                subscriber.error(err);
+            }, function () {
+                var _a, _b;
+                if (isUnsub) {
+                    (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                }
+                (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+            }));
+        })
+        :
+            identity;
+}
+
+class MockApiService {
+  constructor() {
+    this.data = [];
+  }
+  async postStatus(status) {
+    this.data.push(status);
+    return Promise.resolve(status);
+  }
+  async postMutiStatus(status) {
+    this.data.push(...status);
+    return Promise.resolve(status);
+  }
+  async getStatus() {
+    return Promise.resolve(this.data);
+  }
+}
+
+async function sendEventLogging(events, pingMethod) {
+  var _Storage$getItem;
+  if (util.Storage.getItem(util.STORAGE_KEY.ENABLE_EVENT_TRACKING) === false) {
+    return;
+  }
+  const logs = events.filter(event => event.customerId !== '').map(event => {
+    return {
+      message: event,
+      createTime: event.userTime
+    };
+  });
+  const pingEvent = await pingMethod();
+  const newLog = [{
+    message: pingEvent,
+    createTime: pingEvent.userTime
+  }, ...logs];
+  return sendRequest('/api/event-logging/v1/log/ekyc-sdk', 'POST', {
+    body: JSON.stringify({
+      logs: newLog
+    }),
+    baseUrl: (_Storage$getItem = util.Storage.getItem(util.STORAGE_KEY.EVENT_TRACK_URL)) != null ? _Storage$getItem : util.Storage.getItem(util.STORAGE_KEY.API_BASE_URL)
+  });
+}
+
+const initialStatus = {
+  eventId: '',
+  sessionId: '',
+  eventType: '',
+  userTime: new Date().toISOString(),
+  tenantId: '',
+  customerId: '',
+  duration: 0,
+  deviceInfo: '',
+  systemInfo: '',
+  version: '1.0.0',
+  language: '',
+  description: 'description',
+  platform: 'Web',
+  extraInfo: 'extra info'
+};
+const BUFFER_TINTERVAL = 3000;
+class EventListenerService {
+  constructor(getStatusProcess, options) {
+    var _options$pingInterval;
+    this.getStatusProcess = getStatusProcess;
+    this.apiService = new MockApiService();
+    this.pingInterval = (_options$pingInterval = options == null ? void 0 : options.pingInterval) != null ? _options$pingInterval : BUFFER_TINTERVAL;
+    this.statusSubject = new BehaviorSubject(initialStatus);
+  }
+  start() {
+    this.statusSubject = new BehaviorSubject(initialStatus);
+    this.statusSubject.pipe(bufferTime(this.pingInterval), filter(() => util.Storage.getItem(util.STORAGE_KEY.ENABLE_EVENT_TRACKING) === true), mergeMap(events => {
+      sendEventLogging(events, this.getStatusProcess);
+      return events;
+    })).subscribe();
+  }
+  stop() {
+    if (this.pingSubscription) {
+      this.pingSubscription.unsubscribe();
+      this.pingSubscription = undefined;
+    }
+    this.statusSubject.complete();
+  }
+  sendUserActionStatus(status) {
+    this.statusSubject.next(status);
+    return this.sendStatus(status);
+  }
+  sendStatus(status) {
+    return this.apiService.postStatus(status);
+  }
+  getStatusObservable() {
+    return this.statusSubject;
+  }
+}
+
+// Unique ID creation requires a high quality random # generator. In the browser we therefore
+// require the crypto API and do not support built-in fallback to lower quality random number
+// generators (like Math.random()).
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+  // lazy load so that environments that need to polyfill have a chance to do so
+  if (!getRandomValues) {
+    // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
+    // find the complete implementation of crypto (msCrypto) on IE11.
+    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
+
+    if (!getRandomValues) {
+      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
+    }
+  }
+
+  return getRandomValues(rnds8);
+}
+
+var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
+
+function validate(uuid) {
+  return typeof uuid === 'string' && REGEX.test(uuid);
+}
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+var byteToHex = [];
+
+for (var i = 0; i < 256; ++i) {
+  byteToHex.push((i + 0x100).toString(16).substr(1));
+}
+
+function stringify(arr) {
+  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  // Note: Be careful editing this code!  It's been tuned for performance
+  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one
+  // of the following:
+  // - One or more input array values don't map to a hex octet (leading to
+  // "undefined" in the uuid)
+  // - Invalid input values for the RFC `version` or `variant` fields
+
+  if (!validate(uuid)) {
+    throw TypeError('Stringified UUID is invalid');
+  }
+
+  return uuid;
+}
+
+function v4(options, buf, offset) {
+  options = options || {};
+  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  return stringify(rnds);
+}
+
+exports.Feature = void 0;
+(function (Feature) {
+  Feature["OCRFraud"] = "OCRFraud";
+  Feature["OCR"] = "OCR";
+  Feature["SelectCardTypeAndCountry"] = "SelectCardTypeAndCountry";
+  Feature["LivenessActive"] = "LivenessActive";
+  Feature["LivenessPassive"] = "LivenessPassive";
+})(exports.Feature || (exports.Feature = {}));
+exports.StatusEvent = void 0;
+(function (StatusEvent) {
+  StatusEvent["TWID"] = "TWID";
+  StatusEvent["TWIDFraud"] = "TWIDFraud";
+  StatusEvent["TWIDFront"] = "TWIDFront";
+  StatusEvent["TWDriverLicenseFront"] = "TWDriverLicenseFront";
+  StatusEvent["Passport"] = "Passport";
+  StatusEvent["ResidencePermitFront"] = "ResidencePermitFront";
+  StatusEvent["ResidencePermitBack"] = "ResidencePermitBack";
+  StatusEvent["TWIDBack"] = "TWIDBack";
+  StatusEvent["TWDriverLicenseBack"] = "TWDriverLicenseBack";
+  StatusEvent["TWHealthCardFront"] = "TWHealthCardFront";
+  StatusEvent["TWDriverLicense"] = "TWDriverLicense";
+  StatusEvent["TWHealthCard"] = "TWHealthCard";
+  StatusEvent["ResidencePermit"] = "ResidencePermit";
+  StatusEvent["PassportFront"] = "PassportFront";
+  StatusEvent["OpenMouth"] = "OpenMouth";
+  StatusEvent["CloseMouth"] = "CloseMouth";
+  StatusEvent["Smile"] = "Smile";
+  StatusEvent["Scale"] = "Scale";
+  StatusEvent["Done"] = "Done";
+  StatusEvent["Passive"] = "Passive";
+  StatusEvent["SelectCardTypeAndCountry"] = "SelectCardTypeAndCountry";
+  StatusEvent["CardThicknessFailed"] = "CardThicknessFailed";
+})(exports.StatusEvent || (exports.StatusEvent = {}));
+exports.StatusView = void 0;
+(function (StatusView) {
+  StatusView["Info"] = "Info";
+  StatusView["Init"] = "Init";
+  StatusView["Aligning"] = "Aligning";
+  StatusView["Start"] = "Start";
+  StatusView["Up"] = "Up";
+  StatusView["Down"] = "Down";
+  StatusView["Left"] = "Left";
+  StatusView["Right"] = "Right";
+  StatusView["Running"] = "Running";
+  StatusView["Confirm"] = "Confirm";
+  StatusView["Uploading"] = "Uploading";
+  StatusView["Select"] = "Select";
+})(exports.StatusView || (exports.StatusView = {}));
+exports.StatusAction = void 0;
+(function (StatusAction) {
+  StatusAction["Uploading"] = "Uploading";
+  StatusAction["Show"] = "Show";
+  StatusAction["BtnClose"] = "BtnClose";
+  StatusAction["BtnStart"] = "BtnStart";
+  StatusAction["InitError"] = "InitError";
+  StatusAction["Start"] = "Start";
+  StatusAction["Confirm"] = "Confirm";
+  StatusAction["Retry"] = "Retry";
+})(exports.StatusAction || (exports.StatusAction = {}));
+exports.StatusDescription = void 0;
+(function (StatusDescription) {
+  StatusDescription["NoCard"] = "NoCard";
+  StatusDescription["WrongCardType"] = "WrongCardType";
+  StatusDescription["PositionNotMatch"] = "PositionNotMatch";
+  StatusDescription["Reflective"] = "Reflective";
+  StatusDescription["Blur"] = "Blur";
+  StatusDescription["Motion"] = "Motion";
+  StatusDescription["Pass"] = "Pass";
+  StatusDescription["Error"] = "Error";
+  StatusDescription["Failed"] = "Failed";
+  StatusDescription["Timeout"] = "Timeout";
+  StatusDescription["Gray"] = "Gray";
+  StatusDescription["NeedMoreFrame"] = "NeedMoreFrame";
+  StatusDescription["NotAligned"] = "NotAligned";
+  StatusDescription["NoFace"] = "NoFace";
+  StatusDescription["FaceNotAtCenter"] = "FaceNotAtCenter";
+  StatusDescription["FaceTooSmall"] = "FaceTooSmall";
+  StatusDescription["FaceTooLarge"] = "FaceTooLarge";
+  StatusDescription["NeedFaceToCamera"] = "NeedFaceToCamera";
+  StatusDescription["FaceMasked"] = "FaceMasked";
+  StatusDescription["NeedOpenMouth"] = "NeedOpenMouth";
+  StatusDescription["NeedCloseMouth"] = "NeedCloseMouth";
+  StatusDescription["NeedSmile"] = "NeedSmile";
+  StatusDescription["NeedOpenEyes"] = "NeedOpenEyes";
+  StatusDescription["UploadingStart"] = "UploadingStart";
+  StatusDescription["UploadingEnd"] = "UploadingEnd";
+  StatusDescription["Complete"] = "Complete";
+  StatusDescription["CardThicknessFailed"] = "CardThicknessFailed";
+})(exports.StatusDescription || (exports.StatusDescription = {}));
+
+class TrackingEvent {
+  constructor(params) {
+    this._feature = params.feature;
+    this._event = params.event;
+    this._view = params.view;
+    this._action = params.action;
+    this._description = params.description;
+  }
+  nonNull(data) {
+    return data !== null && data !== undefined;
+  }
+  get feature() {
+    return this._feature;
+  }
+  set feature(value) {
+    if (value && !(value in exports.Feature)) {
+      throw new Error('Invalid feature');
+    }
+    this._feature = value;
+  }
+  get event() {
+    return this._event;
+  }
+  set event(value) {
+    if (value && !(value in exports.StatusEvent)) {
+      throw new Error('Invalid event');
+    }
+    this._event = value;
+  }
+  get view() {
+    return this._view;
+  }
+  set view(value) {
+    if (value && !(value in exports.StatusView)) {
+      throw new Error('Invalid view');
+    }
+    this._view = value;
+  }
+  get action() {
+    return this._action;
+  }
+  set action(value) {
+    if (value && !(value in exports.StatusAction)) {
+      throw new Error('Invalid action');
+    }
+    this._action = value;
+  }
+  get description() {
+    return this._description;
+  }
+  set description(value) {
+    if (value && !(value in exports.StatusDescription)) {
+      throw new Error('Invalid description');
+    }
+    this._description = value;
+  }
+  toString() {
+    let result = '';
+    if (this.nonNull(this._feature)) {
+      result += `${this._feature}:`;
+    }
+    if (this.nonNull(this._event)) {
+      result += `${this._event}:`;
+    }
+    if (this.nonNull(this._view)) {
+      result += `${this._view}:`;
+    }
+    if (this.nonNull(this._action)) {
+      result += `${this._action}:`;
+    }
+    if (this.nonNull(this._description)) {
+      result += `${this._description}`;
+    }
+    if (result.endsWith(':')) {
+      result = result.slice(0, -1); // 刪除最後一個字符
+    }
+    return result;
+  }
+}
+
+const tokenSubject = new BehaviorSubject('');
+tokenSubject.pipe(tap(token => {
+  if (!token) return;
+  const _jwt = util.decodeToken(token);
+  setAuthmeJWT(_jwt.payload);
+})).subscribe();
+const defaultEventName = new TrackingEvent({});
+const [getAuthmeJWT, setAuthmeJWT] = util.useState();
+const [getAccessToken, setAccessToken] = util.useState('', tokenSubject);
+const [getSessionId, setSessionId] = util.useState('');
+function generateStatus(params = {}) {
+  const _authmeJWT = getAuthmeJWT();
+  const {
+    eventType = defaultEventName,
+    sessionId = getSessionId(),
+    userTime = new Date().toISOString(),
+    tenantId = _authmeJWT.client_tenant,
+    customerId = _authmeJWT.client_id,
+    duration = 0,
+    deviceInfo = util.getDeviceInfo(),
+    systemInfo = util.getSystemInfo(),
+    version: version$1 = version,
+    language = '',
+    description = '',
+    platform = 'web',
+    extraInfo = ''
+  } = params;
+  return {
+    eventId: v4(),
+    eventType: eventType.toString(),
+    sessionId,
+    userTime,
+    tenantId,
+    customerId,
+    duration,
+    deviceInfo,
+    systemInfo,
+    version: version$1,
+    language,
+    description,
+    platform,
+    extraInfo
+  };
+}
+
+function getCustomerState() {
+  return sendRequest(`/api/identity-verification/v1/verification/state`, 'GET').then(res => {
+    return {
+      state: res.state,
+      createTime: res.createTime,
+      code: res.code,
+      customDetails: res.customDetails || null,
+      message: util.verificationErrorMessages(res.code)
+    };
+  }).catch(error => {
+    // if (error instanceof AuthmeError) {
+    //   return {
+    //     code: error.code,
+    //     message: error.message,
+    //   };
+    // }
+    throw error;
+  });
+}
+
+Object.defineProperty(exports, "AuthmeError", {
+  enumerable: true,
+  get: function () { return util.AuthmeError; }
+});
+Object.defineProperty(exports, "ErrorCode", {
+  enumerable: true,
+  get: function () { return util.ErrorCode; }
+});
+exports.EventListenerService = EventListenerService;
+exports.TrackingEvent = TrackingEvent;
+exports.core = core;
+exports.generateStatus = generateStatus;
+exports.getAccessToken = getAccessToken;
+exports.getCustomerState = getCustomerState;
+exports.getSessionId = getSessionId;
+exports.getTranslateInstance = getTranslateInstance;
+exports.sendRequest = sendRequest;
+exports.setAccessToken = setAccessToken;
+exports.setRequestLoggingFunc = setRequestLoggingFunc;
+exports.setSessionId = setSessionId;
+exports.version = version;