@sambath999/localize-token 12.2.3 → 12.2.4

package/bundles/sambath999-localize-token.umd.js

@@ -0,0 +1,1150 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs'), require('jwt-decode'), require('@angular/common/http'), require('primeng/api'), require('primeng/dynamicdialog'), require('@angular/common'), require('primeng/toast'), require('primeng/inputtext'), require('primeng/button'), require('@angular/platform-browser'), require('@angular/forms')) :
+    typeof define === 'function' && define.amd ? define('@sambath999/localize-token', ['exports', '@angular/core', 'rxjs', 'jwt-decode', '@angular/common/http', 'primeng/api', 'primeng/dynamicdialog', '@angular/common', 'primeng/toast', 'primeng/inputtext', 'primeng/button', '@angular/platform-browser', '@angular/forms'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.sambath999 = global.sambath999 || {}, global.sambath999["localize-token"] = {}), global.ng.core, global.rxjs, global.jwt_decode, global.ng.common.http, global.api, global.dynamicdialog, global.ng.common, global.toast, global.inputtext, global.button, global.ng.platformBrowser, global.ng.forms));
+})(this, (function (exports, i0, rxjs, jwt_decode, i1, api, dynamicdialog, common, toast, inputtext, button, platformBrowser, forms) { 'use strict';
+
+    function _interopNamespace(e) {
+        if (e && e.__esModule) return e;
+        var n = Object.create(null);
+        if (e) {
+            Object.keys(e).forEach(function (k) {
+                if (k !== 'default') {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function () { return e[k]; }
+                    });
+                }
+            });
+        }
+        n["default"] = e;
+        return Object.freeze(n);
+    }
+
+    var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
+    var jwt_decode__namespace = /*#__PURE__*/_interopNamespace(jwt_decode);
+    var i1__namespace = /*#__PURE__*/_interopNamespace(i1);
+
+    /*! *****************************************************************************
+    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 */
+    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 __());
+    }
+    var __assign = function () {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s)
+                    if (Object.prototype.hasOwnProperty.call(s, p))
+                        t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+                t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+    function __decorate(decorators, target, key, desc) {
+        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+        if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+            r = Reflect.decorate(decorators, target, key, desc);
+        else
+            for (var i = decorators.length - 1; i >= 0; i--)
+                if (d = decorators[i])
+                    r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+        return c > 3 && r && Object.defineProperty(target, key, r), r;
+    }
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); };
+    }
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+            return Reflect.metadata(metadataKey, metadataValue);
+    }
+    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;
+        return g = { next: verb(0), "throw": verb(1), "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 (_)
+                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 };
+        }
+    }
+    var __createBinding = Object.create ? (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
+    }) : (function (o, m, k, k2) {
+        if (k2 === undefined)
+            k2 = k;
+        o[k2] = m[k];
+    });
+    function __exportStar(m, o) {
+        for (var p in m)
+            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
+                __createBinding(o, m, p);
+    }
+    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;
+    }
+    /** @deprecated */
+    function __spread() {
+        for (var ar = [], i = 0; i < arguments.length; i++)
+            ar = ar.concat(__read(arguments[i]));
+        return ar;
+    }
+    /** @deprecated */
+    function __spreadArrays() {
+        for (var s = 0, i = 0, il = arguments.length; i < il; i++)
+            s += arguments[i].length;
+        for (var r = Array(s), k = 0, i = 0; i < il; i++)
+            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+                r[k] = a[j];
+        return r;
+    }
+    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 || 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 = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n])
+            i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        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 __asyncDelegator(o) {
+        var i, p;
+        return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+    }
+    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); }
+    }
+    function __makeTemplateObject(cooked, raw) {
+        if (Object.defineProperty) {
+            Object.defineProperty(cooked, "raw", { value: raw });
+        }
+        else {
+            cooked.raw = raw;
+        }
+        return cooked;
+    }
+    ;
+    var __setModuleDefault = Object.create ? (function (o, v) {
+        Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function (o, v) {
+        o["default"] = v;
+    };
+    function __importStar(mod) {
+        if (mod && mod.__esModule)
+            return mod;
+        var result = {};
+        if (mod != null)
+            for (var k in mod)
+                if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+                    __createBinding(result, mod, k);
+        __setModuleDefault(result, mod);
+        return result;
+    }
+    function __importDefault(mod) {
+        return (mod && mod.__esModule) ? mod : { default: mod };
+    }
+    function __classPrivateFieldGet(receiver, state, kind, f) {
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a getter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot read private member from an object whose class did not declare it");
+        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+    }
+    function __classPrivateFieldSet(receiver, state, value, kind, f) {
+        if (kind === "m")
+            throw new TypeError("Private method is not writable");
+        if (kind === "a" && !f)
+            throw new TypeError("Private accessor was defined without a setter");
+        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
+            throw new TypeError("Cannot write private member to an object whose class did not declare it");
+        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+    }
+
+    /**
+    * Assembly of @package ng2-cookies @see https://www.npmjs.com/package/ng2-cookies
+    *
+    * Reassembled by
+    * @author sambath999
+    * @date_29_09_2021
+    * Updated from raw parameters to
+    * @param {ICookieOptions} options and added another newer cookie flag
+    * @param {string} samesite
+    * @param {constant} SameSiteTypes, @param {string} strict "strict", @param {string} lax "lax", @param {string} none "none"
+    *
+    * @enum
+    */
+    var LocalizeTokenStorage = /** @class */ (function () {
+        function LocalizeTokenStorage(_defaultOptions) {
+            this.defaultOptions = _defaultOptions !== null && _defaultOptions !== void 0 ? _defaultOptions : this.getDefaultOptions;
+        }
+        Object.defineProperty(LocalizeTokenStorage.prototype, "getDefaultOptions", {
+            get: function () {
+                var mainDomain = extractMainDomain(window.location.hostname);
+                return {
+                    path: '/',
+                    domain: mainDomain,
+                    secure: true,
+                    // samesite: SameSiteType.strict,
+                    expires: 1
+                };
+            },
+            enumerable: false,
+            configurable: true
+        });
+        /**
+         * Checks the existence of a single cookie by it's name
+         *
+         * @param  {string} name Identification of the cookie
+         * @returns existence of the cookie
+         */
+        LocalizeTokenStorage.prototype.check = function (name) {
+            if (typeof document === "undefined")
+                return false;
+            name = encodeURIComponent(name);
+            var regexp = new RegExp('(?:^' + name + '|;\\s*' + name + ')=(.*?)(?:;|$)', 'g');
+            return regexp.test(document.cookie);
+        };
+        /**
+         * Retrieves a single cookie by it's name
+         *
+         * @param  {string} name Identification of the Cookie
+         * @returns The Cookie's value
+         */
+        LocalizeTokenStorage.prototype.get = function (name) {
+            if (!this.check(name))
+                return undefined;
+            name = encodeURIComponent(name);
+            var regexp = new RegExp('(?:^' + name + '|;\\s*' + name + ')=(.*?)(?:;|$)', 'g');
+            var result = regexp.exec(document.cookie);
+            return result ? decodeURIComponent(result[1]) : undefined;
+        };
+        /**
+         * Retrieves a a list of all cookie avaiable
+         *
+         * @returns Object with all Cookies
+         */
+        LocalizeTokenStorage.prototype.getAll = function () {
+            var e_1, _a;
+            var cookies = {};
+            if (document.cookie) {
+                var split = document.cookie.split(';');
+                try {
+                    for (var split_1 = __values(split), split_1_1 = split_1.next(); !split_1_1.done; split_1_1 = split_1.next()) {
+                        var s = split_1_1.value;
+                        var currCookie = s.split('=');
+                        currCookie[0] = currCookie[0].trim();
+                        cookies[decodeURIComponent(currCookie[0])] = decodeURIComponent(currCookie[1]);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (split_1_1 && !split_1_1.done && (_a = split_1.return)) _a.call(split_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            return cookies;
+        };
+        LocalizeTokenStorage.prototype.set = function (name, value, options) {
+            options !== null && options !== void 0 ? options : (options = this.defaultOptions);
+            var _a = Object.assign(Object.assign({}, this.defaultOptions), options), expires = _a.expires, path = _a.path, domain = _a.domain, secure = _a.secure, samesite = _a.samesite;
+            var cookieStr = encodeURIComponent(name) + "=" + encodeURIComponent(value) + ";";
+            if (expires) {
+                var dtExpires = typeof expires === 'number' ? new Date(Date.now() + expires * 864e5) : expires;
+                cookieStr += "expires=" + dtExpires.toUTCString() + ";";
+            }
+            cookieStr += path ? "path=" + path + ";" : '';
+            cookieStr += domain ? "domain=" + domain + ";" : '';
+            cookieStr += secure ? 'secure;' : '';
+            cookieStr += samesite ? "samesite=" + samesite + ";" : '';
+            document.cookie = cookieStr;
+        };
+        /**
+         * Removes specified Cookie
+         *
+         * @param  {string} name Cookie's identification
+         * @param  {string} path Path relative to the domain where the cookie should be avaiable. Default /
+         * @param  {string} domain Domain where the cookie should be avaiable. Default current domain
+         */
+        LocalizeTokenStorage.prototype.delete = function (name, path, domain) {
+            if (path === void 0) { path = '/'; }
+            if (domain === void 0) { domain = window.location.hostname; }
+            this.set(name, '', { path: path, domain: domain, expires: -1 });
+        };
+        /**
+         * Delete all cookie avaiable
+         */
+        LocalizeTokenStorage.prototype.deleteAll = function (path, domain) {
+            var e_2, _a;
+            var cookies = this.getAll();
+            try {
+                for (var _b = __values(Object.keys(cookies)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var cookieName = _c.value;
+                    this.delete(cookieName, path, domain);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        };
+        return LocalizeTokenStorage;
+    }());
+
+    var LocalizeToken = /** @class */ (function () {
+        function LocalizeToken() {
+            this.configSubject = new rxjs.BehaviorSubject(LocalizeToken.config);
+        }
+        Object.defineProperty(LocalizeToken.prototype, "getConfig", {
+            get: function () { return this.configSubject.value; },
+            enumerable: false,
+            configurable: true
+        });
+        LocalizeToken.init = function (config) {
+            var lConfig = new LocalizeToken();
+            LocalizeToken.config = Object.assign(Object.assign({}, LocalizeToken.config), config);
+            lConfig.configSubject.next(LocalizeToken.config);
+        };
+        return LocalizeToken;
+    }());
+    LocalizeToken.config = {
+        mainDomain: extractMainDomain(),
+        authTokenName: 'auth-token',
+        refreshTokenName: '_lze_rftkp_',
+        needTenant: false,
+        isProduction: false,
+        revokeTokenUrl: ''
+    };
+    LocalizeToken.storage = new LocalizeTokenStorage();
+    LocalizeToken.httpHeaders = {
+        AUTHORIZATION: 'Authorization',
+        X_TENANT: 'X-Tenant',
+        X_REFRESH_TOKEN: 'X-RefreshToken',
+        CONTENT_TYPE: 'Content-Type',
+    };
+    /**
+     *  Waits for a specified amount of time.
+     * @param milliseconds  - The milliseconds to wait.
+     * @param when  - The condition to wait for. Default is true.
+     * @returns  - Promise<void>
+     */
+    function waitFor(milliseconds, when) {
+        if (when === void 0) { when = true; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!when)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, milliseconds); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    /**
+     *  Waits until the condition is met.
+     * @param when  - The condition to wait for.
+     * @param intervalNumber  - The interval number in milliseconds to check the condition. Default is 50.
+     */
+    function waitUntil(when, intervalNumber) {
+        if (intervalNumber === void 0) { intervalNumber = 50; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new Promise(function (resolve) {
+                            var interval = setInterval(function () { return __awaiter(_this, void 0, void 0, function () {
+                                var cond, result, _a;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            cond = when();
+                                            if (!(cond instanceof Promise)) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, cond];
+                                        case 1:
+                                            _a = _b.sent();
+                                            return [3 /*break*/, 3];
+                                        case 2:
+                                            _a = cond;
+                                            _b.label = 3;
+                                        case 3:
+                                            result = _a;
+                                            if (result) {
+                                                clearInterval(interval);
+                                                resolve(true);
+                                            }
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }, intervalNumber);
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    }
+    function extractMainDomain(subdomain) {
+        subdomain !== null && subdomain !== void 0 ? subdomain : (subdomain = window.location.hostname);
+        var parts = subdomain.split('.');
+        return parts.length > 2 ? parts.slice(-2).join('.') : subdomain;
+    }
+
+    var LocalizeTokenService = /** @class */ (function () {
+        function LocalizeTokenService(tokenConfig) {
+            this.tokenConfig = tokenConfig;
+            this.isRevokingTokenSubject = new rxjs.BehaviorSubject(false);
+            this.decodeToken = function (token) { return jwt_decode__namespace.jwtDecode(token); };
+            if (!this.tokenConfig.getConfig.authTokenName || !this.tokenConfig.getConfig.refreshTokenName || !this.tokenConfig.getConfig.tenantTokenName) {
+                throw new Error('authTokenName, refreshTokenName, and tenantTokenName must be defined in LocalizeToken.config');
+            }
+            this.config = this.tokenConfig.getConfig;
+        }
+        Object.defineProperty(LocalizeTokenService.prototype, "authToken", {
+            get: function () { return this.storageGet(); },
+            set: function (value) {
+                value
+                    ? this.storageSet(value)
+                    : LocalizeToken.storage.delete(this.config.authTokenName);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(LocalizeTokenService.prototype, "refreshToken", {
+            get: function () { return LocalizeToken.storage.get(this.config.refreshTokenName); },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(LocalizeTokenService.prototype, "accessToken", {
+            get: function () { var _a; return (_a = this.authToken) === null || _a === void 0 ? void 0 : _a.token; },
+            set: function (value) {
+                if (value) {
+                    this.authToken = { token: value, revoke: false };
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(LocalizeTokenService.prototype, "isRevokingToken", {
+            get: function () { return this.isRevokingTokenSubject.value; /* this.authToken?.revoke ?? false */ },
+            set: function (value) {
+                this.isRevokingTokenSubject.next(value);
+                if (this.authToken) {
+                    this.authToken = Object.assign(Object.assign({}, this.authToken), { revoke: value });
+                }
+            },
+            enumerable: false,
+            configurable: true
+        });
+        LocalizeTokenService.prototype.tenantToken = function () { return LocalizeToken.storage.get(this.config.tenantTokenName); };
+        LocalizeTokenService.prototype.storageGet = function () {
+            try {
+                var encoded = LocalizeToken.storage.get(this.config.authTokenName);
+                var decoded = atob(encoded || '');
+                return JSON.parse(decoded);
+            }
+            catch (_a) {
+                return undefined;
+            }
+        };
+        LocalizeTokenService.prototype.storageSet = function (value) {
+            var base64 = btoa(JSON.stringify(value));
+            LocalizeToken.storage.set(this.config.authTokenName, base64);
+        };
+        LocalizeTokenService.prototype.tokensValid = function () {
+            var _a, _b;
+            return ((_a = this.refreshToken) === null || _a === void 0 ? void 0 : _a.length) && (!this.config.needTenant || ((_b = this.tenantToken()) === null || _b === void 0 ? void 0 : _b.length));
+        };
+        Object.defineProperty(LocalizeTokenService.prototype, "decodeRefreshToken", {
+            get: function () {
+                var token = LocalizeToken.storage.get(this.config.refreshTokenName);
+                if (!token)
+                    return null;
+                return this.decodeToken(token);
+            },
+            enumerable: false,
+            configurable: true
+        });
+        return LocalizeTokenService;
+    }());
+    LocalizeTokenService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function LocalizeTokenService_Factory() { return new LocalizeTokenService(i0__namespace.ɵɵinject(LocalizeToken)); }, token: LocalizeTokenService, providedIn: "root" });
+    LocalizeTokenService.decorators = [
+        { type: i0.Injectable, args: [{ providedIn: 'root' },] }
+    ];
+    LocalizeTokenService.ctorParameters = function () { return [
+        { type: LocalizeToken }
+    ]; };
+
+    /**
+     * Http method options
+     */
+    exports.EMethod = void 0;
+    (function (EMethod) {
+        EMethod[EMethod["POST"] = 1] = "POST";
+        EMethod[EMethod["GET"] = 2] = "GET";
+        EMethod[EMethod["PUT"] = 3] = "PUT";
+        EMethod[EMethod["DELETE"] = 4] = "DELETE";
+        EMethod[EMethod["PATCH"] = 5] = "PATCH";
+    })(exports.EMethod || (exports.EMethod = {}));
+    var LocalizeApiService = /** @class */ (function () {
+        function LocalizeApiService(httpClient, tokenConfig, localizeTokenService) {
+            var _this = this;
+            this.httpClient = httpClient;
+            this.tokenConfig = tokenConfig;
+            this.localizeTokenService = localizeTokenService;
+            this.isRequestingSubject = new rxjs.BehaviorSubject(false);
+            this.isResolvedStartupSubject = new rxjs.BehaviorSubject(false);
+            this.apiConfigs = {};
+            /**
+             * A higher-order function that returns a curried function for making API requests.
+             *
+             * @param baseUrl - The base URL of the API.
+             * @returns A curried function that can be used to make API requests.
+             */
+            this.func = function (baseUrl) { return function (path, method, value, isFormData, headers) {
+                if (method === void 0) { method = exports.EMethod.GET; }
+                if (value === void 0) { value = null; }
+                if (isFormData === void 0) { isFormData = false; }
+                return _this.base(baseUrl, path, method, value, isFormData, headers);
+            }; };
+        }
+        Object.defineProperty(LocalizeApiService.prototype, "isRequesting", {
+            get: function () { return this.isRequestingSubject.value; },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(LocalizeApiService.prototype, "isResolvedStartup", {
+            get: function () { return this.isResolvedStartupSubject.value; },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(LocalizeApiService.prototype, "config", {
+            get: function () { return this.tokenConfig.getConfig; },
+            enumerable: false,
+            configurable: true
+        });
+        /**
+         * Initialize the API service.
+         * @param apiConfigs - The API configurations.
+         */
+        LocalizeApiService.prototype.init = function (apiConfigs) {
+            this.apiConfigs = apiConfigs;
+        };
+        LocalizeApiService.prototype.base = function (baseUrl, path, method, value, isFormData, headers) {
+            if (method === void 0) { method = exports.EMethod.GET; }
+            if (value === void 0) { value = null; }
+            if (isFormData === void 0) { isFormData = false; }
+            return __awaiter(this, void 0, void 0, function () {
+                var url, httpMethod, request, error_1;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, this.ifPromise(this.apiConfigs.onPrepareRequest)];
+                        case 1:
+                            _b.sent();
+                            url = "" + baseUrl.trim().replace(/\/?$/, '/') + path.trim().replace(/^\//, '');
+                            httpMethod = exports.EMethod[method].toLowerCase();
+                            request = function () { return { body: value, headers: _this.options(isFormData, headers) }; };
+                            // Wait for previous request to complete
+                            return [4 /*yield*/, this.toWaitForPreviousRequest()];
+                        case 2:
+                            // Wait for previous request to complete
+                            _b.sent();
+                            _b.label = 3;
+                        case 3:
+                            _b.trys.push([3, 5, , 7]);
+                            return [4 /*yield*/, this.processRequest(httpMethod, url, request())];
+                        case 4: return [2 /*return*/, _b.sent()];
+                        case 5:
+                            error_1 = _b.sent();
+                            if (error_1.status !== 401) {
+                                throw error_1;
+                            }
+                            return [4 /*yield*/, this.onUnauthorizedError(httpMethod, url, request)];
+                        case 6: return [2 /*return*/, _b.sent()];
+                        case 7: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        LocalizeApiService.prototype.onUnauthorizedError = function (httpMethod, url, request) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0: return [4 /*yield*/, this.revokeToken()];
+                        case 1:
+                            _b.sent();
+                            if (!!this.isResolvedStartup) return [3 /*break*/, 3];
+                            return [4 /*yield*/, this.processRequest(httpMethod, url, request())];
+                        case 2: return [2 /*return*/, _b.sent()];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        LocalizeApiService.prototype.toWaitForPreviousRequest = function () {
+            var _a;
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!this.localizeTokenService.isRevokingToken) return [3 /*break*/, 2];
+                            return [4 /*yield*/, waitUntil(function () { return !_this.localizeTokenService.isRevokingToken; })];
+                        case 1:
+                            _b.sent();
+                            _b.label = 2;
+                        case 2:
+                            if (!((_a = this.apiConfigs.waitEachRequest) === null || _a === void 0 ? void 0 : _a.milliseconds)) return [3 /*break*/, 4];
+                            return [4 /*yield*/, waitFor(this.apiConfigs.waitEachRequest.milliseconds, this.isRequesting)];
+                        case 3:
+                            _b.sent();
+                            _b.label = 4;
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        LocalizeApiService.prototype.processRequest = function (method, url, options) {
+            return __awaiter(this, void 0, void 0, function () {
+                var result;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            this.isRequestingSubject.next(true);
+                            return [4 /*yield*/, new Promise(function (resolve, reject) { return _this.httpClient.request(method, url, options).subscribe({ next: resolve, error: reject }); })];
+                        case 1:
+                            result = _b.sent();
+                            this.isRequestingSubject.next(false);
+                            return [2 /*return*/, result];
+                    }
+                });
+            });
+        };
+        LocalizeApiService.prototype.revokeToken = function (force) {
+            if (force === void 0) { force = false; }
+            return __awaiter(this, void 0, void 0, function () {
+                var reqUrl_1, reqHeaders_1, revokeToken;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (!(this.localizeTokenService.isRevokingToken && !force)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, waitUntil(function () { return !_this.localizeTokenService.isRevokingToken; })];
+                        case 1:
+                            _b.sent();
+                            return [2 /*return*/];
+                        case 2:
+                            _b.trys.push([2, , 10, 11]);
+                            this.localizeTokenService.isRevokingToken = true;
+                            reqUrl_1 = this.config.revokeTokenUrl;
+                            reqHeaders_1 = this.options().append(LocalizeToken.httpHeaders.X_REFRESH_TOKEN, "" + this.localizeTokenService.refreshToken);
+                            return [4 /*yield*/, new Promise(function (resolve, reject) { return _this.httpClient.get(reqUrl_1, { headers: reqHeaders_1 }).subscribe({ next: resolve, error: reject }); })];
+                        case 3:
+                            revokeToken = _b.sent();
+                            if (!(revokeToken === null || revokeToken === void 0 ? void 0 : revokeToken.status)) return [3 /*break*/, 4];
+                            this.localizeTokenService.accessToken = revokeToken.message;
+                            return [3 /*break*/, 9];
+                        case 4:
+                            if (!!this.localizeTokenService.refreshToken) return [3 /*break*/, 6];
+                            return [4 /*yield*/, this.ifPromise(this.apiConfigs.onAutoLogout)];
+                        case 5:
+                            _b.sent();
+                            return [3 /*break*/, 9];
+                        case 6:
+                            if (!this.apiConfigs.onRevokeUnauthorized) return [3 /*break*/, 9];
+                            return [4 /*yield*/, this.ifPromise(this.apiConfigs.onRevokeUnauthorized)];
+                        case 7:
+                            _b.sent();
+                            return [4 /*yield*/, this.revokeToken(true)];
+                        case 8:
+                            _b.sent();
+                            _b.label = 9;
+                        case 9: return [3 /*break*/, 11];
+                        case 10:
+                            this.localizeTokenService.isRevokingToken = false;
+                            return [7 /*endfinally*/];
+                        case 11: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        /** default http request options */
+        LocalizeApiService.prototype.options = function (isFormData, headers) {
+            var _b;
+            if (isFormData === void 0) { isFormData = false; }
+            if (headers === void 0) { headers = {}; }
+            var defaultHeaders = (_b = {}, _b[LocalizeToken.httpHeaders.AUTHORIZATION] = "Bearer " + this.localizeTokenService.accessToken, _b);
+            if (this.config.needTenant) {
+                defaultHeaders[LocalizeToken.httpHeaders.X_TENANT] = "" + this.localizeTokenService.tenantToken();
+            }
+            if (!isFormData) {
+                defaultHeaders[LocalizeToken.httpHeaders.CONTENT_TYPE] = 'application/json';
+            }
+            var filteredHeaders = Object.keys(defaultHeaders).filter(function (key) { return !Object.keys(headers).includes(key); })
+                .reduce(function (acc, key) {
+                var _b;
+                return (Object.assign(Object.assign({}, acc), (_b = {}, _b[key] = defaultHeaders[key], _b)));
+            }, {});
+            var mergedHeaders = Object.assign(Object.assign({}, filteredHeaders), headers);
+            return new i1.HttpHeaders(mergedHeaders);
+        };
+        LocalizeApiService.prototype.ifPromise = function (fn) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (!fn)
+                                return [2 /*return*/];
+                            if (!(fn instanceof Promise)) return [3 /*break*/, 2];
+                            return [4 /*yield*/, fn()];
+                        case 1:
+                            _b = _c.sent();
+                            return [3 /*break*/, 3];
+                        case 2:
+                            _b = fn();
+                            _c.label = 3;
+                        case 3: return [2 /*return*/, _b];
+                    }
+                });
+            });
+        };
+        return LocalizeApiService;
+    }()); //class
+    LocalizeApiService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function LocalizeApiService_Factory() { return new LocalizeApiService(i0__namespace.ɵɵinject(i1__namespace.HttpClient), i0__namespace.ɵɵinject(LocalizeToken), i0__namespace.ɵɵinject(LocalizeTokenService)); }, token: LocalizeApiService, providedIn: "root" });
+    LocalizeApiService.decorators = [
+        { type: i0.Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    LocalizeApiService.ctorParameters = function () { return [
+        { type: i1.HttpClient },
+        { type: LocalizeToken },
+        { type: LocalizeTokenService }
+    ]; };
+
+    var LocalizeTokenModule = /** @class */ (function () {
+        function LocalizeTokenModule() {
+        }
+        return LocalizeTokenModule;
+    }());
+    LocalizeTokenModule.decorators = [
+        { type: i0.NgModule, args: [{
+                    providers: [
+                        LocalizeTokenService,
+                        LocalizeApiService,
+                        LocalizeToken
+                    ],
+                },] }
+    ];
+
+    var LocalizeLogindlgComponent = /** @class */ (function () {
+        function LocalizeLogindlgComponent(messageService, cdt, dlgRef, dlgConfig, tokenService, httpClient, tokenConfig) {
+            var _this = this;
+            this.messageService = messageService;
+            this.cdt = cdt;
+            this.dlgRef = dlgRef;
+            this.dlgConfig = dlgConfig;
+            this.tokenService = tokenService;
+            this.httpClient = httpClient;
+            this.tokenConfig = tokenConfig;
+            this.messageKey = "$login-dlg";
+            this.loading = false;
+            this.success = false;
+            this.clickLogout = function () { var _a; return (_a = _this.logout) === null || _a === void 0 ? void 0 : _a.call(_this); };
+            this.decodeToken = this.tokenService.decodeRefreshToken;
+            this.loginConfig = this.dlgConfig.data.loginConfig;
+        }
+        Object.defineProperty(LocalizeLogindlgComponent.prototype, "config", {
+            get: function () { return this.tokenConfig.getConfig; },
+            enumerable: false,
+            configurable: true
+        });
+        LocalizeLogindlgComponent.prototype.ngOnInit = function () {
+            var _this = this;
+            this.dlgConfig.closable = false;
+            this.logout = this.loginConfig.logoutFunc;
+            this.loginUrl = this.loginConfig.loginUrl;
+            if (!this.decodeToken) {
+                this.showMessage("error", "Token is invalid");
+                setTimeout(function () { var _a; return (_a = _this.logout) === null || _a === void 0 ? void 0 : _a.call(_this); }, 2000);
+            }
+        };
+        LocalizeLogindlgComponent.prototype.ngAfterViewInit = function () {
+            this.cdt.detectChanges();
+        };
+        LocalizeLogindlgComponent.prototype.clickLogin = function () {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function () {
+                var loginRes, cookieOptions;
+                var _this = this;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (!this.isValidPassword) {
+                                this.showMessage("error", "Password is required and must be at least 6 characters");
+                                return [2 /*return*/];
+                            }
+                            this.loading = true;
+                            return [4 /*yield*/, this.login()];
+                        case 1:
+                            loginRes = _c.sent();
+                            if (!(loginRes === null || loginRes === void 0 ? void 0 : loginRes.status)) {
+                                this.showMessage("error", (_a = loginRes.message) !== null && _a !== void 0 ? _a : "An error occurred");
+                                return [2 /*return*/];
+                            }
+                            this.tokenService.accessToken = loginRes.tokens.accessToken;
+                            cookieOptions = { expires: (_b = this.loginConfig.expire) !== null && _b !== void 0 ? _b : 5 };
+                            LocalizeToken.storage.set(this.config.refreshTokenName, loginRes.tokens.refreshToken, cookieOptions);
+                            this.success = true;
+                            setTimeout(function () { return _this.dlgRef.close(true); }, 2000);
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        LocalizeLogindlgComponent.prototype.login = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var e_1;
+                var _this = this;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            if (!this.loginUrl || !this.loginUrl.trim().length) {
+                                this.showMessage("error", "Login url is required");
+                                throw new Error("Login url is required");
+                            }
+                            _c.label = 1;
+                        case 1:
+                            _c.trys.push([1, 3, , 4]);
+                            return [4 /*yield*/, new Promise(function (resolve, reject) { return _this.httpClient.post(_this.loginUrl, { password: _this.password.trim() }, { headers: _this.getHeaders() })
+                                    .subscribe({ next: resolve, error: reject }); })];
+                        case 2: return [2 /*return*/, _c.sent()];
+                        case 3:
+                            e_1 = _c.sent();
+                            this.showMessage("error", e_1.message);
+                            return [2 /*return*/, null];
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        LocalizeLogindlgComponent.prototype.getHeaders = function () {
+            var _c;
+            var _a, _b;
+            return _c = {},
+                _c[LocalizeToken.httpHeaders.X_REFRESH_TOKEN] = (_a = LocalizeToken.storage.get(this.config.refreshTokenName)) !== null && _a !== void 0 ? _a : "",
+                _c[LocalizeToken.httpHeaders.X_TENANT] = (_b = LocalizeToken.storage.get(this.config.tenantTokenName)) !== null && _b !== void 0 ? _b : "",
+                _c;
+        };
+        Object.defineProperty(LocalizeLogindlgComponent.prototype, "isValidPassword", {
+            get: function () {
+                this.loading = false;
+                return this.password && this.password.trim().length >= 6 && this.password.trim().length <= 16;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        LocalizeLogindlgComponent.prototype.showMessage = function (severity, summary) {
+            this.messageService.add({ key: this.messageKey, severity: severity, summary: summary });
+            this.loading = false;
+        };
+        return LocalizeLogindlgComponent;
+    }());
+    LocalizeLogindlgComponent.decorators = [
+        { type: i0.Component, args: [{
+                    template: "<p-toast key=\"$login-dlg\" position=\"top-center\"></p-toast>\n  <div id=\"login-dlg-wrap\">\n    <div id=\"login-dlg-header\">\n      <div id=\"login-logo\" class=\"p-mb-2\"></div>\n      <h3 *ngIf=\"!success\">Your session is expired! <br> Please login again to continue.</h3>\n      <h3 *ngIf=\"success\" style=\"color:green !important;\">You haved successfully logged in.</h3>\n    </div>\n    <div id=\"login-dlg-content\">\n      <ng-container *ngIf=\"!success\">\n        <div *ngIf=\"loading\" class=\"loader-wrap\">\n          <div class=\"login-dlg-loader\"></div>\n        </div>\n        <div class=\"login-dlg-elm\">\n          <div class=\"p-inputgroup\">\n            <span class=\"p-inputgroup-addon\">\n              <i class=\"material-icons-round\">person</i>\n            </span>\n            <input disabled pInputText type=\"text\" placeholder=\"Username\" [value]=\"decodeToken?.email\" />\n          </div>\n        </div>\n  \n        <div class=\"login-dlg-elm\">\n          <div class=\"p-inputgroup\">\n            <span class=\"p-inputgroup-addon\">\n              <i class=\"material-icons-round\">lock</i>\n            </span>\n            <input [disabled]=\"loading\" (keydown.enter)=\"clickLogin()\" pInputText type=\"password\" placeholder=\"Password\" [(ngModel)]=\"password\"\n              autofocus />\n          </div>\n        </div>\n        <div class=\"login-dlg-elm\">\n          <button style=\"width: 100%;\" pButton type=\"button\" label=\"Login\" (click)=\"clickLogin()\"\n            [disabled]=\"!password || loading\"></button>\n        </div>\n  \n        <div class=\"login-dlg-elm\" style=\"display:flex;align-items: center;user-select: none;\">\n          <span>No, I want to login with another user.</span>\n          <button class=\"p-button-text\" pButton type=\"button\" label=\"Logout\" (click)=\"clickLogout()\"></button>\n        </div>\n      </ng-container>\n  \n      <ng-container *ngIf=\"success\">\n        <div style=\"margin-top:35px;\"></div>\n        <div class=\"check-animation-wrap\">\n          <div class=\"check-main-container\">\n            <div class=\"check-container\">\n              <div class=\"check-background\">\n                <svg viewBox=\"0 0 65 51\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n                  <path d=\"M7 25L27.3077 44L58.5 7\" stroke=\"white\" stroke-width=\"13\" stroke-linecap=\"round\"\n                    stroke-linejoin=\"round\"></path>\n                </svg>\n              </div>\n            </div>\n          </div>\n        </div>\n      </ng-container>\n    </div>\n  </div>",
+                    selector: "app-localize-logindlg",
+                    providers: [api.MessageService],
+                    encapsulation: i0.ViewEncapsulation.None,
+                    styles: ["\n  #login-dlg-wrap {\n    width: 100%;\n    max-width: 400px;\n    margin: 0 auto;\n    padding: 30px;\n  }\n  \n  .login-dlg-elm {\n    margin-top: 1rem;\n  }\n  \n  #login-dlg-header {\n    display: flex;\n    flex-direction: column;\n    align-items: center;\n    justify-content: center;\n  }\n  \n  #login-dlg-header h3 {\n    font-weight: bold;\n    font-size: 0.9rem;\n    color: orange;\n    text-align: center;\n  }\n  \n  #login-logo {\n    height: 40px;\n    width: 40px;\n    background: url(\"/assets/images/logo-300px.png\") no-repeat;\n    background-size: contain;\n  }\n  \n  #login-dlg-content .p-inputgroup {\n    height: 45px;\n  }\n  \n  #login-dlg-content .p-inputgroup .p-inputgroup-addon {\n    height: 45px;\n    border-radius: 15px 0 0 15px;\n    width: 50px;\n  }\n  \n  #login-dlg-content .p-inputgroup .p-inputgroup-addon * {\n    font-size: 1rem;\n  }\n  \n  #login-dlg-content .p-inputgroup input {\n    height: 45px;\n    border-radius: 0 15px 15px 0;\n  }\n  \n  #login-dlg-content button {\n    height: 45px;\n    border-radius: 15px;\n  }\n  \n  /*check animation block*/\n  \n  .check-animation-wrap {\n    top: 0;\n    left: 0;\n    position: absolute;\n    display: flex;\n    flex-direction: column;\n    align-items: center;\n    justify-content: center;\n    width: 100%;\n    height: calc(100% - 200px);\n    min-height: 400px;\n  }\n  \n  .check-main-container {\n    width: 100%;\n    height: 100vh;\n    display: flex;\n    flex-flow: column;\n    justify-content: center;\n    align-items: center;\n  }\n  \n  .check-container {\n    width: 6.25rem;\n    height: 7.5rem;\n    display: flex;\n    flex-flow: column;\n    align-items: center;\n    justify-content: space-between;\n  }\n  \n  .check-container .check-background {\n    width: 100%;\n    height: calc(100% - 1.25rem);\n    background: linear-gradient(to bottom right, #5de593, #41d67c);\n    box-shadow: 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset;\n    transform: scale(0.84);\n    border-radius: 50%;\n    animation: animateContainer 0.75s ease-out forwards 0.75s;\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    opacity: 0;\n  }\n  \n  .check-container .check-background svg {\n    width: 65%;\n    transform: translateY(0.25rem);\n    stroke-dasharray: 80;\n    stroke-dashoffset: 80;\n    animation: animateCheck 0.35s forwards 1.25s ease-out;\n    min-width: auto !important;\n  }\n  \n  .check-container .check-shadow {\n    bottom: calc(-15% - 5px);\n    left: 0;\n    border-radius: 50%;\n    background: radial-gradient(closest-side, rgba(73, 218, 131, 1), transparent);\n    animation: animateShadow 0.75s ease-out forwards 0.75s;\n  }\n  \n  @keyframes animateContainer {\n    0% {\n      opacity: 0;\n      transform: scale(0);\n      box-shadow: 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset;\n    }\n  \n    25% {\n      opacity: 1;\n      transform: scale(0.9);\n      box-shadow: 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset;\n    }\n  \n    43.75% {\n      transform: scale(1.15);\n      box-shadow: 0px 0px 0px 43.334px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 65px rgba(255, 255, 255, 0.25) inset;\n    }\n  \n    62.5% {\n      transform: scale(1);\n      box-shadow: 0px 0px 0px 0px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 21.667px rgba(255, 255, 255, 0.25) inset;\n    }\n  \n    81.25% {\n      box-shadow: 0px 0px 0px 0px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 0px rgba(255, 255, 255, 0.25) inset;\n    }\n  \n    100% {\n      opacity: 1;\n      box-shadow: 0px 0px 0px 0px rgba(255, 255, 255, 0.25) inset, 0px 0px 0px 0px rgba(255, 255, 255, 0.25) inset;\n    }\n  }\n  \n  @keyframes animateCheck {\n    from {\n      stroke-dashoffset: 80;\n    }\n  \n    to {\n      stroke-dashoffset: 0;\n    }\n  }\n  \n  @keyframes animateShadow {\n    0% {\n      opacity: 0;\n      width: 100%;\n      height: 15%;\n    }\n  \n    25% {\n      opacity: 0.25;\n    }\n  \n    43.75% {\n      width: 40%;\n      height: 7%;\n      opacity: 0.35;\n    }\n  \n    100% {\n      width: 85%;\n      height: 15%;\n      opacity: 0.25;\n    }\n  }\n  #login-dlg-wrap .loader-wrap {\n    display: flex;\n    justify-content: center;\n    align-items: center;\n    height:100%;\n    width:100%;\n    position: absolute;\n    top: 0;\n    left: 0;\n    z-index: 100;\n    background: #ffffff42;\n    backdrop-filter: blur(1px);\n  }\n\n  #login-dlg-wrap .login-dlg-loader {\n    border: 15px solid #e7e7e7;\n    border-top: 15px solid #52dba1;\n    border-radius: 50%;\n    width: 100px;\n    height: 100px;\n    animation: spinloader 2s linear infinite;\n  }\n\n  #login-dlg-wrap .loader-wrap::before {\n    content: \"\";\n    position: absolute;\n    width: 70px;\n    height: 70px;\n    transform: translate(-50%, -50%);\n    z-index: 1;\n    border: 15px solid #e7e7e700;\n    border-top: 15px solid #52dba1c9;\n    border-radius: 50%;\n    animation: spinloader .75s linear infinite;\n  }\n\n  @keyframes spinloader {\n    0% { transform: rotate(0deg); }\n    100% { transform: rotate(360deg); }\n  }\n  "]
+                },] }
+    ];
+    LocalizeLogindlgComponent.ctorParameters = function () { return [
+        { type: api.MessageService },
+        { type: i0.ChangeDetectorRef },
+        { type: dynamicdialog.DynamicDialogRef },
+        { type: dynamicdialog.DynamicDialogConfig },
+        { type: LocalizeTokenService },
+        { type: i1.HttpClient },
+        { type: LocalizeToken }
+    ]; };
+
+    var LocalizeLogindlgService = /** @class */ (function () {
+        function LocalizeLogindlgService(injector) {
+            this.injector = injector;
+        }
+        LocalizeLogindlgService.prototype.openLoginDialog = function (loginConfig, config) {
+            return __awaiter(this, void 0, void 0, function () {
+                var dialogService, dialog;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            config !== null && config !== void 0 ? config : (config = {
+                                header: 'Login',
+                                height: '650px',
+                                style: { 'max-width': '400px', width: '100%', 'height': '650px' },
+                            });
+                            config.data = Object.assign(Object.assign({}, config.data || {}), { loginConfig: loginConfig });
+                            dialogService = this.injector.get(dynamicdialog.DialogService);
+                            dialog = dialogService.open(LocalizeLogindlgComponent, config);
+                            return [4 /*yield*/, new Promise(function (resolve) { return dialog.onClose.subscribe(function (res) {
+                                    if (res) {
+                                        resolve();
+                                    }
+                                }); })];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return LocalizeLogindlgService;
+    }());
+    LocalizeLogindlgService.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function LocalizeLogindlgService_Factory() { return new LocalizeLogindlgService(i0__namespace.ɵɵinject(i0__namespace.INJECTOR)); }, token: LocalizeLogindlgService, providedIn: "root" });
+    LocalizeLogindlgService.decorators = [
+        { type: i0.Injectable, args: [{
+                    providedIn: 'root'
+                },] }
+    ];
+    LocalizeLogindlgService.ctorParameters = function () { return [
+        { type: i0.Injector }
+    ]; };
+
+    var LocalizeLogindlgModule = /** @class */ (function () {
+        function LocalizeLogindlgModule() {
+        }
+        return LocalizeLogindlgModule;
+    }());
+    LocalizeLogindlgModule.decorators = [
+        { type: i0.NgModule, args: [{
+                    declarations: [LocalizeLogindlgComponent],
+                    exports: [LocalizeLogindlgComponent],
+                    imports: [
+                        common.CommonModule,
+                        toast.ToastModule,
+                        inputtext.InputTextModule,
+                        platformBrowser.BrowserModule,
+                        forms.FormsModule,
+                        button.ButtonModule,
+                    ],
+                    providers: [LocalizeLogindlgService],
+                    schemas: [i0.CUSTOM_ELEMENTS_SCHEMA],
+                },] }
+    ];
+
+    /**
+     * Generated bundle index. Do not edit.
+     */
+
+    exports.LocalizeApiService = LocalizeApiService;
+    exports.LocalizeLogindlgComponent = LocalizeLogindlgComponent;
+    exports.LocalizeLogindlgModule = LocalizeLogindlgModule;
+    exports.LocalizeLogindlgService = LocalizeLogindlgService;
+    exports.LocalizeToken = LocalizeToken;
+    exports.LocalizeTokenModule = LocalizeTokenModule;
+    exports.LocalizeTokenService = LocalizeTokenService;
+    exports.LocalizeTokenStorage = LocalizeTokenStorage;
+    exports.extractMainDomain = extractMainDomain;
+    exports.waitFor = waitFor;
+    exports.waitUntil = waitUntil;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=sambath999-localize-token.umd.js.map