@sambath999/localize-token 12.0.8 → 12.1.1

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

@@ -0,0 +1,1113 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs'), require('jwt-decode'), require('@angular/common/http')) :
+  typeof define === 'function' && define.amd ? define('@sambath999/localize-token', ['exports', '@angular/core', 'rxjs', 'jwt-decode', '@angular/common/http'], 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));
+})(this, (function (exports, i0, rxjs, jwt_decode, http) { '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);
+
+  /******************************************************************************
+  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 __());
+  }
+  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 __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+      function accept(f) { if (f !== void 0 && typeof f !== "function")
+          throw new TypeError("Function expected"); return f; }
+      var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+      var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+      var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+      var _, done = false;
+      for (var i = decorators.length - 1; i >= 0; i--) {
+          var context = {};
+          for (var p in contextIn)
+              context[p] = p === "access" ? {} : contextIn[p];
+          for (var p in contextIn.access)
+              context.access[p] = contextIn.access[p];
+          context.addInitializer = function (f) { if (done)
+              throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+          var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+          if (kind === "accessor") {
+              if (result === void 0)
+                  continue;
+              if (result === null || typeof result !== "object")
+                  throw new TypeError("Object expected");
+              if (_ = accept(result.get))
+                  descriptor.get = _;
+              if (_ = accept(result.set))
+                  descriptor.set = _;
+              if (_ = accept(result.init))
+                  initializers.unshift(_);
+          }
+          else if (_ = accept(result)) {
+              if (kind === "field")
+                  initializers.unshift(_);
+              else
+                  descriptor[key] = _;
+          }
+      }
+      if (target)
+          Object.defineProperty(target, contextIn.name, descriptor);
+      done = true;
+  }
+  ;
+  function __runInitializers(thisArg, initializers, value) {
+      var useValue = arguments.length > 2;
+      for (var i = 0; i < initializers.length; i++) {
+          value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+      }
+      return useValue ? value : void 0;
+  }
+  ;
+  function __propKey(x) {
+      return typeof x === "symbol" ? x : "".concat(x);
+  }
+  ;
+  function __setFunctionName(f, name, prefix) {
+      if (typeof name === "symbol")
+          name = name.description ? "[".concat(name.description, "]") : "";
+      return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+  }
+  ;
+  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 = 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 };
+      }
+  }
+  var __createBinding = Object.create ? (function (o, m, k, k2) {
+      if (k2 === undefined)
+          k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = { enumerable: true, get: function () { return m[k]; } };
+      }
+      Object.defineProperty(o, k2, desc);
+  }) : (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 || 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 __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: false } : 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;
+  };
+  var ownKeys = function (o) {
+      ownKeys = Object.getOwnPropertyNames || function (o) {
+          var ar = [];
+          for (var k in o)
+              if (Object.prototype.hasOwnProperty.call(o, k))
+                  ar[ar.length] = k;
+          return ar;
+      };
+      return ownKeys(o);
+  };
+  function __importStar(mod) {
+      if (mod && mod.__esModule)
+          return mod;
+      var result = {};
+      if (mod != null)
+          for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+              if (k[i] !== "default")
+                  __createBinding(result, mod, k[i]);
+      __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;
+  }
+  function __classPrivateFieldIn(state, receiver) {
+      if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function"))
+          throw new TypeError("Cannot use 'in' operator on non-object");
+      return typeof state === "function" ? receiver === state : state.has(receiver);
+  }
+  function __addDisposableResource(env, value, async) {
+      if (value !== null && value !== void 0) {
+          if (typeof value !== "object" && typeof value !== "function")
+              throw new TypeError("Object expected.");
+          var dispose, inner;
+          if (async) {
+              if (!Symbol.asyncDispose)
+                  throw new TypeError("Symbol.asyncDispose is not defined.");
+              dispose = value[Symbol.asyncDispose];
+          }
+          if (dispose === void 0) {
+              if (!Symbol.dispose)
+                  throw new TypeError("Symbol.dispose is not defined.");
+              dispose = value[Symbol.dispose];
+              if (async)
+                  inner = dispose;
+          }
+          if (typeof dispose !== "function")
+              throw new TypeError("Object not disposable.");
+          if (inner)
+              dispose = function () { try {
+                  inner.call(this);
+              }
+              catch (e) {
+                  return Promise.reject(e);
+              } };
+          env.stack.push({ value: value, dispose: dispose, async: async });
+      }
+      else if (async) {
+          env.stack.push({ async: true });
+      }
+      return value;
+  }
+  var _SuppressedError = 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 __disposeResources(env) {
+      function fail(e) {
+          env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+          env.hasError = true;
+      }
+      var r, s = 0;
+      function next() {
+          while (r = env.stack.pop()) {
+              try {
+                  if (!r.async && s === 1)
+                      return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                  if (r.dispose) {
+                      var result = r.dispose.call(r.value);
+                      if (r.async)
+                          return s |= 2, Promise.resolve(result).then(next, function (e) { fail(e); return next(); });
+                  }
+                  else
+                      s |= 1;
+              }
+              catch (e) {
+                  fail(e);
+              }
+          }
+          if (s === 1)
+              return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+          if (env.hasError)
+              throw env.error;
+      }
+      return next();
+  }
+  function __rewriteRelativeImportExtension(path, preserveJsx) {
+      if (typeof path === "string" && /^\.\.?\//.test(path)) {
+          return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+              return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+          });
+      }
+      return path;
+  }
+  var tslib_es6 = {
+      __extends: __extends,
+      __assign: __assign,
+      __rest: __rest,
+      __decorate: __decorate,
+      __param: __param,
+      __esDecorate: __esDecorate,
+      __runInitializers: __runInitializers,
+      __propKey: __propKey,
+      __setFunctionName: __setFunctionName,
+      __metadata: __metadata,
+      __awaiter: __awaiter,
+      __generator: __generator,
+      __createBinding: __createBinding,
+      __exportStar: __exportStar,
+      __values: __values,
+      __read: __read,
+      __spread: __spread,
+      __spreadArrays: __spreadArrays,
+      __spreadArray: __spreadArray,
+      __await: __await,
+      __asyncGenerator: __asyncGenerator,
+      __asyncDelegator: __asyncDelegator,
+      __asyncValues: __asyncValues,
+      __makeTemplateObject: __makeTemplateObject,
+      __importStar: __importStar,
+      __importDefault: __importDefault,
+      __classPrivateFieldGet: __classPrivateFieldGet,
+      __classPrivateFieldSet: __classPrivateFieldSet,
+      __classPrivateFieldIn: __classPrivateFieldIn,
+      __addDisposableResource: __addDisposableResource,
+      __disposeResources: __disposeResources,
+      __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,
+  };
+
+  /**
+  * 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 LocalizeTokenStorageHelper = /** @class */ (function () {
+      function LocalizeTokenStorageHelper() {
+      }
+      /**
+       * Checks the existence of a single cookie by it's name
+       *
+       * @param  {string} name Identification of the cookie
+       * @returns existence of the cookie
+       */
+      LocalizeTokenStorageHelper.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
+       */
+      LocalizeTokenStorageHelper.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
+       */
+      LocalizeTokenStorageHelper.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;
+      };
+      Object.defineProperty(LocalizeTokenStorageHelper.prototype, "defaultOptions", {
+          get: function () { return LocalizeToken.cookieOptions; },
+          enumerable: false,
+          configurable: true
+      });
+      LocalizeTokenStorageHelper.prototype.set = function (name, value, options) {
+          options !== null && options !== void 0 ? options : (options = this.defaultOptions);
+          var expires = options.expires, path = options.path, domain = options.domain, secure = options.secure, samesite = options.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
+       */
+      LocalizeTokenStorageHelper.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
+       */
+      LocalizeTokenStorageHelper.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 LocalizeTokenStorageHelper;
+  }());
+  exports.ISameSiteType = void 0;
+  (function (ISameSiteType) {
+      ISameSiteType["strict"] = "strict";
+      ISameSiteType["lax"] = "lax";
+      ISameSiteType["none"] = "none";
+  })(exports.ISameSiteType || (exports.ISameSiteType = {}));
+
+  var LocalizeToken = /** @class */ (function () {
+      function LocalizeToken() {
+      }
+      return LocalizeToken;
+  }());
+  LocalizeToken.config = {
+      mainDomain: location.hostname,
+      authTokenName: 'auth-token',
+      tenantTokenName: 'tenant-token',
+      refreshTokenName: 'refresh-token',
+      needTenant: false,
+      isProduction: false,
+  };
+  LocalizeToken.cookieOptions = {
+      path: '/',
+      domain: LocalizeToken.config.mainDomain,
+      secure: true,
+      // samesite: SameSiteType.strict,
+      expires: 1
+  };
+  LocalizeToken.storage = new LocalizeTokenStorageHelper();
+  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*/];
+              }
+          });
+      });
+  }
+
+  var LocalizeTokenService = /** @class */ (function () {
+      function LocalizeTokenService() {
+          this.isRevokingTokenSubject = new rxjs.BehaviorSubject(false);
+          this.decodeToken = function (token) { return jwt_decode__namespace.jwtDecode(token); };
+      }
+      Object.defineProperty(LocalizeTokenService.prototype, "authToken", {
+          get: function () { return this.storageGet(); },
+          set: function (value) {
+              value
+                  ? this.storageSet(value)
+                  : LocalizeToken.storage.delete(LocalizeToken.config.authTokenName);
+          },
+          enumerable: false,
+          configurable: true
+      });
+      Object.defineProperty(LocalizeTokenService.prototype, "refreshToken", {
+          get: function () { return LocalizeToken.storage.get(LocalizeToken.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
+      });
+      Object.defineProperty(LocalizeTokenService.prototype, "tenantToken", {
+          get: function () { return LocalizeToken.storage.get(LocalizeToken.config.tenantTokenName); },
+          enumerable: false,
+          configurable: true
+      });
+      LocalizeTokenService.prototype.storageGet = function () {
+          try {
+              var encoded = LocalizeToken.storage.get(LocalizeToken.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(LocalizeToken.config.authTokenName, base64);
+      };
+      LocalizeTokenService.prototype.tokensValid = function () {
+          var _a, _b;
+          return ((_a = this.refreshToken) === null || _a === void 0 ? void 0 : _a.length) && (!LocalizeToken.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(LocalizeToken.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(); }, token: LocalizeTokenService, providedIn: "root" });
+  LocalizeTokenService.decorators = [
+      { type: i0.Injectable, args: [{ providedIn: 'root' },] }
+  ];
+  LocalizeTokenService.ctorParameters = function () { return []; };
+
+  /**
+   * 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(localizeTokenService) {
+          var _this = this;
+          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
+      });
+      /**
+       * Initialize the API service.
+       * @param apiConfigs - The API configurations.
+       */
+      LocalizeApiService.prototype.init = function (apiConfigs, httpClient) {
+          this.httpClient = httpClient;
+          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 () {
+          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: 
+                      // to wait for each request in 50ms, even if the request is not completed
+                      return [4 /*yield*/, waitFor(50, this.isRequesting)];
+                      case 3:
+                          // to wait for each request in 50ms, even if the request is not completed
+                          _b.sent();
+                          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) { var _a; return (_a = _this.httpClient) === null || _a === void 0 ? void 0 : _a.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 = LocalizeToken.config.revokeTokenUrl;
+                          reqHeaders_1 = this.options().append(LocalizeToken.httpHeaders.X_REFRESH_TOKEN, "" + this.localizeTokenService.refreshToken);
+                          return [4 /*yield*/, new Promise(function (resolve, reject) { var _a; return (_a = _this.httpClient) === null || _a === void 0 ? void 0 : _a.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 (LocalizeToken.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 http.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(LocalizeTokenService)); }, token: LocalizeApiService, providedIn: "root" });
+  LocalizeApiService.decorators = [
+      { type: i0.Injectable, args: [{
+                  providedIn: 'root'
+              },] }
+  ];
+  LocalizeApiService.ctorParameters = function () { return [
+      { type: LocalizeTokenService }
+  ]; };
+
+  var LocalizeTokenModule = /** @class */ (function () {
+      function LocalizeTokenModule() {
+      }
+      return LocalizeTokenModule;
+  }());
+  LocalizeTokenModule.decorators = [
+      { type: i0.NgModule, args: [{
+                  providers: [
+                      LocalizeTokenService,
+                      LocalizeApiService
+                  ],
+              },] }
+  ];
+
+  /**
+   * Generated bundle index. Do not edit.
+   */
+
+  exports.LocalizeApiService = LocalizeApiService;
+  exports.LocalizeToken = LocalizeToken;
+  exports.LocalizeTokenModule = LocalizeTokenModule;
+  exports.LocalizeTokenService = LocalizeTokenService;
+  exports.LocalizeTokenStorageHelper = LocalizeTokenStorageHelper;
+  exports.waitFor = waitFor;
+  exports.waitUntil = waitUntil;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=sambath999-localize-token.umd.js.map