mp-front-cli 0.0.37 → 0.0.38

package/dist/custom-header-ef367c86.js

@@ -0,0 +1,882 @@
+var J = Object.defineProperty;
+var N = (e, t, r) => t in e ? J(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var b = (e, t, r) => (N(e, typeof t != "symbol" ? t + "" : t, r), r);
+import { C as V, p as v } from "./custom-logger-a671be8b.js";
+import { switchMap as S, of as g, catchError as q } from "rxjs";
+import { B as z } from "./custom-encoder-50b5eb15.js";
+import { C as Q } from "./custom-validator-9ec2d3d0.js";
+var C = function(e, t) {
+  return C = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, n) {
+    r.__proto__ = n;
+  } || function(r, n) {
+    for (var i in n)
+      Object.prototype.hasOwnProperty.call(n, i) && (r[i] = n[i]);
+  }, C(e, t);
+};
+function x(e, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+  C(e, t);
+  function r() {
+    this.constructor = e;
+  }
+  e.prototype = t === null ? Object.create(t) : (r.prototype = t.prototype, new r());
+}
+var P = function() {
+  return P = Object.assign || function(t) {
+    for (var r, n = 1, i = arguments.length; n < i; n++) {
+      r = arguments[n];
+      for (var o in r)
+        Object.prototype.hasOwnProperty.call(r, o) && (t[o] = r[o]);
+    }
+    return t;
+  }, P.apply(this, arguments);
+};
+function X(e, t) {
+  var r = {};
+  for (var n in e)
+    Object.prototype.hasOwnProperty.call(e, n) && t.indexOf(n) < 0 && (r[n] = e[n]);
+  if (e != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var i = 0, n = Object.getOwnPropertySymbols(e); i < n.length; i++)
+      t.indexOf(n[i]) < 0 && Object.prototype.propertyIsEnumerable.call(e, n[i]) && (r[n[i]] = e[n[i]]);
+  return r;
+}
+function Z(e, t, r, n) {
+  function i(o) {
+    return o instanceof r ? o : new r(function(a) {
+      a(o);
+    });
+  }
+  return new (r || (r = Promise))(function(o, a) {
+    function s(f) {
+      try {
+        u(n.next(f));
+      } catch (y) {
+        a(y);
+      }
+    }
+    function c(f) {
+      try {
+        u(n.throw(f));
+      } catch (y) {
+        a(y);
+      }
+    }
+    function u(f) {
+      f.done ? o(f.value) : i(f.value).then(s, c);
+    }
+    u((n = n.apply(e, t || [])).next());
+  });
+}
+function M(e, t) {
+  var r = { label: 0, sent: function() {
+    if (o[0] & 1)
+      throw o[1];
+    return o[1];
+  }, trys: [], ops: [] }, n, i, o, a;
+  return a = { next: s(0), throw: s(1), return: s(2) }, typeof Symbol == "function" && (a[Symbol.iterator] = function() {
+    return this;
+  }), a;
+  function s(u) {
+    return function(f) {
+      return c([u, f]);
+    };
+  }
+  function c(u) {
+    if (n)
+      throw new TypeError("Generator is already executing.");
+    for (; a && (a = 0, u[0] && (r = 0)), r; )
+      try {
+        if (n = 1, i && (o = u[0] & 2 ? i.return : u[0] ? i.throw || ((o = i.return) && o.call(i), 0) : i.next) && !(o = o.call(i, u[1])).done)
+          return o;
+        switch (i = 0, o && (u = [u[0] & 2, o.value]), u[0]) {
+          case 0:
+          case 1:
+            o = u;
+            break;
+          case 4:
+            return r.label++, { value: u[1], done: !1 };
+          case 5:
+            r.label++, i = u[1], u = [0];
+            continue;
+          case 7:
+            u = r.ops.pop(), r.trys.pop();
+            continue;
+          default:
+            if (o = r.trys, !(o = o.length > 0 && o[o.length - 1]) && (u[0] === 6 || u[0] === 2)) {
+              r = 0;
+              continue;
+            }
+            if (u[0] === 3 && (!o || u[1] > o[0] && u[1] < o[3])) {
+              r.label = u[1];
+              break;
+            }
+            if (u[0] === 6 && r.label < o[1]) {
+              r.label = o[1], o = u;
+              break;
+            }
+            if (o && r.label < o[2]) {
+              r.label = o[2], r.ops.push(u);
+              break;
+            }
+            o[2] && r.ops.pop(), r.trys.pop();
+            continue;
+        }
+        u = t.call(e, r);
+      } catch (f) {
+        u = [6, f], i = 0;
+      } finally {
+        n = o = 0;
+      }
+    if (u[0] & 5)
+      throw u[1];
+    return { value: u[0] ? u[1] : void 0, done: !0 };
+  }
+}
+function T(e) {
+  var t = typeof Symbol == "function" && Symbol.iterator, r = t && e[t], n = 0;
+  if (r)
+    return r.call(e);
+  if (e && typeof e.length == "number")
+    return {
+      next: function() {
+        return e && n >= e.length && (e = void 0), { value: e && e[n++], done: !e };
+      }
+    };
+  throw new TypeError(t ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function E(e, t) {
+  var r = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!r)
+    return e;
+  var n = r.call(e), i, o = [], a;
+  try {
+    for (; (t === void 0 || t-- > 0) && !(i = n.next()).done; )
+      o.push(i.value);
+  } catch (s) {
+    a = { error: s };
+  } finally {
+    try {
+      i && !i.done && (r = n.return) && r.call(n);
+    } finally {
+      if (a)
+        throw a.error;
+    }
+  }
+  return o;
+}
+function U(e, t, r) {
+  if (r || arguments.length === 2)
+    for (var n = 0, i = t.length, o; n < i; n++)
+      (o || !(n in t)) && (o || (o = Array.prototype.slice.call(t, 0, n)), o[n] = t[n]);
+  return e.concat(o || Array.prototype.slice.call(t));
+}
+function A(e) {
+  return this instanceof A ? (this.v = e, this) : new A(e);
+}
+function rr(e, t, r) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var n = r.apply(e, t || []), i, o = [];
+  return i = {}, a("next"), a("throw"), a("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function a(l) {
+    n[l] && (i[l] = function(d) {
+      return new Promise(function(_, p) {
+        o.push([l, d, _, p]) > 1 || s(l, d);
+      });
+    });
+  }
+  function s(l, d) {
+    try {
+      c(n[l](d));
+    } catch (_) {
+      y(o[0][3], _);
+    }
+  }
+  function c(l) {
+    l.value instanceof A ? Promise.resolve(l.value.v).then(u, f) : y(o[0][2], l);
+  }
+  function u(l) {
+    s("next", l);
+  }
+  function f(l) {
+    s("throw", l);
+  }
+  function y(l, d) {
+    l(d), o.shift(), o.length && s(o[0][0], o[0][1]);
+  }
+}
+function er(e) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var t = e[Symbol.asyncIterator], r;
+  return t ? t.call(e) : (e = typeof T == "function" ? T(e) : e[Symbol.iterator](), r = {}, n("next"), n("throw"), n("return"), r[Symbol.asyncIterator] = function() {
+    return this;
+  }, r);
+  function n(o) {
+    r[o] = e[o] && function(a) {
+      return new Promise(function(s, c) {
+        a = e[o](a), i(s, c, a.done, a.value);
+      });
+    };
+  }
+  function i(o, a, s, c) {
+    Promise.resolve(c).then(function(u) {
+      o({ value: u, done: s });
+    }, a);
+  }
+}
+function h(e) {
+  return typeof e == "function";
+}
+function tr(e) {
+  var t = function(n) {
+    Error.call(n), n.stack = new Error().stack;
+  }, r = e(t);
+  return r.prototype = Object.create(Error.prototype), r.prototype.constructor = r, r;
+}
+var O = tr(function(e) {
+  return function(r) {
+    e(this), this.message = r ? r.length + ` errors occurred during unsubscription:
+` + r.map(function(n, i) {
+      return i + 1 + ") " + n.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = r;
+  };
+});
+function D(e, t) {
+  if (e) {
+    var r = e.indexOf(t);
+    0 <= r && e.splice(r, 1);
+  }
+}
+var R = function() {
+  function e(t) {
+    this.initialTeardown = t, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var t, r, n, i, o;
+    if (!this.closed) {
+      this.closed = !0;
+      var a = this._parentage;
+      if (a)
+        if (this._parentage = null, Array.isArray(a))
+          try {
+            for (var s = T(a), c = s.next(); !c.done; c = s.next()) {
+              var u = c.value;
+              u.remove(this);
+            }
+          } catch (p) {
+            t = { error: p };
+          } finally {
+            try {
+              c && !c.done && (r = s.return) && r.call(s);
+            } finally {
+              if (t)
+                throw t.error;
+            }
+          }
+        else
+          a.remove(this);
+      var f = this.initialTeardown;
+      if (h(f))
+        try {
+          f();
+        } catch (p) {
+          o = p instanceof O ? p.errors : [p];
+        }
+      var y = this._finalizers;
+      if (y) {
+        this._finalizers = null;
+        try {
+          for (var l = T(y), d = l.next(); !d.done; d = l.next()) {
+            var _ = d.value;
+            try {
+              j(_);
+            } catch (p) {
+              o = o ?? [], p instanceof O ? o = U(U([], E(o)), E(p.errors)) : o.push(p);
+            }
+          }
+        } catch (p) {
+          n = { error: p };
+        } finally {
+          try {
+            d && !d.done && (i = l.return) && i.call(l);
+          } finally {
+            if (n)
+              throw n.error;
+          }
+        }
+      }
+      if (o)
+        throw new O(o);
+    }
+  }, e.prototype.add = function(t) {
+    var r;
+    if (t && t !== this)
+      if (this.closed)
+        j(t);
+      else {
+        if (t instanceof e) {
+          if (t.closed || t._hasParent(this))
+            return;
+          t._addParent(this);
+        }
+        (this._finalizers = (r = this._finalizers) !== null && r !== void 0 ? r : []).push(t);
+      }
+  }, e.prototype._hasParent = function(t) {
+    var r = this._parentage;
+    return r === t || Array.isArray(r) && r.includes(t);
+  }, e.prototype._addParent = function(t) {
+    var r = this._parentage;
+    this._parentage = Array.isArray(r) ? (r.push(t), r) : r ? [r, t] : t;
+  }, e.prototype._removeParent = function(t) {
+    var r = this._parentage;
+    r === t ? this._parentage = null : Array.isArray(r) && D(r, t);
+  }, e.prototype.remove = function(t) {
+    var r = this._finalizers;
+    r && D(r, t), t instanceof e && t._removeParent(this);
+  }, e.EMPTY = function() {
+    var t = new e();
+    return t.closed = !0, t;
+  }(), e;
+}();
+R.EMPTY;
+function $(e) {
+  return e instanceof R || e && "closed" in e && h(e.remove) && h(e.add) && h(e.unsubscribe);
+}
+function j(e) {
+  h(e) ? e() : e.unsubscribe();
+}
+var G = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: !1,
+  useDeprecatedNextContext: !1
+}, H = {
+  setTimeout: function(e, t) {
+    for (var r = [], n = 2; n < arguments.length; n++)
+      r[n - 2] = arguments[n];
+    var i = H.delegate;
+    return i != null && i.setTimeout ? i.setTimeout.apply(i, U([e, t], E(r))) : setTimeout.apply(void 0, U([e, t], E(r)));
+  },
+  clearTimeout: function(e) {
+    var t = H.delegate;
+    return ((t == null ? void 0 : t.clearTimeout) || clearTimeout)(e);
+  },
+  delegate: void 0
+};
+function Y(e) {
+  H.setTimeout(function() {
+    throw e;
+  });
+}
+function L() {
+}
+function nr(e) {
+  e();
+}
+var K = function(e) {
+  x(t, e);
+  function t(r) {
+    var n = e.call(this) || this;
+    return n.isStopped = !1, r ? (n.destination = r, $(r) && r.add(n)) : n.destination = ur, n;
+  }
+  return t.create = function(r, n, i) {
+    return new B(r, n, i);
+  }, t.prototype.next = function(r) {
+    this.isStopped || this._next(r);
+  }, t.prototype.error = function(r) {
+    this.isStopped || (this.isStopped = !0, this._error(r));
+  }, t.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, t.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+  }, t.prototype._next = function(r) {
+    this.destination.next(r);
+  }, t.prototype._error = function(r) {
+    try {
+      this.destination.error(r);
+    } finally {
+      this.unsubscribe();
+    }
+  }, t.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, t;
+}(R), or = Function.prototype.bind;
+function I(e, t) {
+  return or.call(e, t);
+}
+var ir = function() {
+  function e(t) {
+    this.partialObserver = t;
+  }
+  return e.prototype.next = function(t) {
+    var r = this.partialObserver;
+    if (r.next)
+      try {
+        r.next(t);
+      } catch (n) {
+        w(n);
+      }
+  }, e.prototype.error = function(t) {
+    var r = this.partialObserver;
+    if (r.error)
+      try {
+        r.error(t);
+      } catch (n) {
+        w(n);
+      }
+    else
+      w(t);
+  }, e.prototype.complete = function() {
+    var t = this.partialObserver;
+    if (t.complete)
+      try {
+        t.complete();
+      } catch (r) {
+        w(r);
+      }
+  }, e;
+}(), B = function(e) {
+  x(t, e);
+  function t(r, n, i) {
+    var o = e.call(this) || this, a;
+    if (h(r) || !r)
+      a = {
+        next: r ?? void 0,
+        error: n ?? void 0,
+        complete: i ?? void 0
+      };
+    else {
+      var s;
+      o && G.useDeprecatedNextContext ? (s = Object.create(r), s.unsubscribe = function() {
+        return o.unsubscribe();
+      }, a = {
+        next: r.next && I(r.next, s),
+        error: r.error && I(r.error, s),
+        complete: r.complete && I(r.complete, s)
+      }) : a = r;
+    }
+    return o.destination = new ir(a), o;
+  }
+  return t;
+}(K);
+function w(e) {
+  Y(e);
+}
+function ar(e) {
+  throw e;
+}
+var ur = {
+  closed: !0,
+  next: L,
+  error: ar,
+  complete: L
+};
+function sr(e, t, r, n, i) {
+  return new cr(e, t, r, n, i);
+}
+var cr = function(e) {
+  x(t, e);
+  function t(r, n, i, o, a, s) {
+    var c = e.call(this, r) || this;
+    return c.onFinalize = a, c.shouldUnsubscribe = s, c._next = n ? function(u) {
+      try {
+        n(u);
+      } catch (f) {
+        r.error(f);
+      }
+    } : e.prototype._next, c._error = o ? function(u) {
+      try {
+        o(u);
+      } catch (f) {
+        r.error(f);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._error, c._complete = i ? function() {
+      try {
+        i();
+      } catch (u) {
+        r.error(u);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._complete, c;
+  }
+  return t.prototype.unsubscribe = function() {
+    var r;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var n = this.closed;
+      e.prototype.unsubscribe.call(this), !n && ((r = this.onFinalize) === null || r === void 0 || r.call(this));
+    }
+  }, t;
+}(K), k = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function lr(e) {
+  return e;
+}
+function fr(e) {
+  return e.length === 0 ? lr : e.length === 1 ? e[0] : function(r) {
+    return e.reduce(function(n, i) {
+      return i(n);
+    }, r);
+  };
+}
+var m = function() {
+  function e(t) {
+    t && (this._subscribe = t);
+  }
+  return e.prototype.lift = function(t) {
+    var r = new e();
+    return r.source = this, r.operator = t, r;
+  }, e.prototype.subscribe = function(t, r, n) {
+    var i = this, o = pr(t) ? t : new B(t, r, n);
+    return nr(function() {
+      var a = i, s = a.operator, c = a.source;
+      o.add(s ? s.call(o, c) : c ? i._subscribe(o) : i._trySubscribe(o));
+    }), o;
+  }, e.prototype._trySubscribe = function(t) {
+    try {
+      return this._subscribe(t);
+    } catch (r) {
+      t.error(r);
+    }
+  }, e.prototype.forEach = function(t, r) {
+    var n = this;
+    return r = F(r), new r(function(i, o) {
+      var a = new B({
+        next: function(s) {
+          try {
+            t(s);
+          } catch (c) {
+            o(c), a.unsubscribe();
+          }
+        },
+        error: o,
+        complete: i
+      });
+      n.subscribe(a);
+    });
+  }, e.prototype._subscribe = function(t) {
+    var r;
+    return (r = this.source) === null || r === void 0 ? void 0 : r.subscribe(t);
+  }, e.prototype[k] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var t = [], r = 0; r < arguments.length; r++)
+      t[r] = arguments[r];
+    return fr(t)(this);
+  }, e.prototype.toPromise = function(t) {
+    var r = this;
+    return t = F(t), new t(function(n, i) {
+      var o;
+      r.subscribe(function(a) {
+        return o = a;
+      }, function(a) {
+        return i(a);
+      }, function() {
+        return n(o);
+      });
+    });
+  }, e.create = function(t) {
+    return new e(t);
+  }, e;
+}();
+function F(e) {
+  var t;
+  return (t = e ?? G.Promise) !== null && t !== void 0 ? t : Promise;
+}
+function hr(e) {
+  return e && h(e.next) && h(e.error) && h(e.complete);
+}
+function pr(e) {
+  return e && e instanceof K || hr(e) && $(e);
+}
+var yr = function(e) {
+  return e && typeof e.length == "number" && typeof e != "function";
+};
+function dr(e) {
+  return h(e == null ? void 0 : e.then);
+}
+function vr(e) {
+  return h(e[k]);
+}
+function br(e) {
+  return Symbol.asyncIterator && h(e == null ? void 0 : e[Symbol.asyncIterator]);
+}
+function mr(e) {
+  return new TypeError("You provided " + (e !== null && typeof e == "object" ? "an invalid object" : "'" + e + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function Ar() {
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var _r = Ar();
+function Sr(e) {
+  return h(e == null ? void 0 : e[_r]);
+}
+function gr(e) {
+  return rr(this, arguments, function() {
+    var r, n, i, o;
+    return M(this, function(a) {
+      switch (a.label) {
+        case 0:
+          r = e.getReader(), a.label = 1;
+        case 1:
+          a.trys.push([1, , 9, 10]), a.label = 2;
+        case 2:
+          return [4, A(r.read())];
+        case 3:
+          return n = a.sent(), i = n.value, o = n.done, o ? [4, A(void 0)] : [3, 5];
+        case 4:
+          return [2, a.sent()];
+        case 5:
+          return [4, A(i)];
+        case 6:
+          return [4, a.sent()];
+        case 7:
+          return a.sent(), [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          return r.releaseLock(), [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function Tr(e) {
+  return h(e == null ? void 0 : e.getReader);
+}
+function wr(e) {
+  if (e instanceof m)
+    return e;
+  if (e != null) {
+    if (vr(e))
+      return Pr(e);
+    if (yr(e))
+      return Er(e);
+    if (dr(e))
+      return Ur(e);
+    if (br(e))
+      return W(e);
+    if (Sr(e))
+      return Or(e);
+    if (Tr(e))
+      return Ir(e);
+  }
+  throw mr(e);
+}
+function Pr(e) {
+  return new m(function(t) {
+    var r = e[k]();
+    if (h(r.subscribe))
+      return r.subscribe(t);
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function Er(e) {
+  return new m(function(t) {
+    for (var r = 0; r < e.length && !t.closed; r++)
+      t.next(e[r]);
+    t.complete();
+  });
+}
+function Ur(e) {
+  return new m(function(t) {
+    e.then(function(r) {
+      t.closed || (t.next(r), t.complete());
+    }, function(r) {
+      return t.error(r);
+    }).then(null, Y);
+  });
+}
+function Or(e) {
+  return new m(function(t) {
+    var r, n;
+    try {
+      for (var i = T(e), o = i.next(); !o.done; o = i.next()) {
+        var a = o.value;
+        if (t.next(a), t.closed)
+          return;
+      }
+    } catch (s) {
+      r = { error: s };
+    } finally {
+      try {
+        o && !o.done && (n = i.return) && n.call(i);
+      } finally {
+        if (r)
+          throw r.error;
+      }
+    }
+    t.complete();
+  });
+}
+function W(e) {
+  return new m(function(t) {
+    Cr(e, t).catch(function(r) {
+      return t.error(r);
+    });
+  });
+}
+function Ir(e) {
+  return W(gr(e));
+}
+function Cr(e, t) {
+  var r, n, i, o;
+  return Z(this, void 0, void 0, function() {
+    var a, s;
+    return M(this, function(c) {
+      switch (c.label) {
+        case 0:
+          c.trys.push([0, 5, 6, 11]), r = er(e), c.label = 1;
+        case 1:
+          return [4, r.next()];
+        case 2:
+          if (n = c.sent(), !!n.done)
+            return [3, 4];
+          if (a = n.value, t.next(a), t.closed)
+            return [2];
+          c.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          return s = c.sent(), i = { error: s }, [3, 11];
+        case 6:
+          return c.trys.push([6, , 9, 10]), n && !n.done && (o = r.return) ? [4, o.call(r)] : [3, 8];
+        case 7:
+          c.sent(), c.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (i)
+            throw i.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          return t.complete(), [2];
+      }
+    });
+  });
+}
+function Hr(e, t) {
+  t === void 0 && (t = {});
+  var r = t.selector, n = X(t, ["selector"]);
+  return new m(function(i) {
+    var o = new AbortController(), a = o.signal, s = !0, c = n.signal;
+    if (c)
+      if (c.aborted)
+        o.abort();
+      else {
+        var u = function() {
+          a.aborted || o.abort();
+        };
+        c.addEventListener("abort", u), i.add(function() {
+          return c.removeEventListener("abort", u);
+        });
+      }
+    var f = P(P({}, n), { signal: a }), y = function(l) {
+      s = !1, i.error(l);
+    };
+    return fetch(e, f).then(function(l) {
+      r ? wr(r(l)).subscribe(sr(i, void 0, function() {
+        s = !1, i.complete();
+      }, y)) : (s = !1, i.next(l), i.complete());
+    }).catch(y), function() {
+      s && o.abort();
+    };
+  });
+}
+class Br extends V {
+  constructor() {
+    super();
+    b(this, "API_AUTH_BACK_URL");
+    b(this, "API_AUTH_BACK_USERNAME_AUTH");
+    b(this, "API_AUTH_BACK_PASSWORD_AUTH");
+    b(this, "API_AUTH_BACK_USER");
+    b(this, "API_AUTH_BACK_SCOPE");
+    b(this, "API_AUTH_BACK_PASSWORD");
+    b(this, "headers");
+    this.API_AUTH_BACK_URL = v.env.API_AUTH_BACK_URL, this.API_AUTH_BACK_USERNAME_AUTH = v.env.API_AUTH_BACK_USERNAME_AUTH, this.API_AUTH_BACK_PASSWORD_AUTH = v.env.API_AUTH_BACK_PASSWORD_AUTH, this.API_AUTH_BACK_USER = v.env.API_AUTH_BACK_USER, this.API_AUTH_BACK_SCOPE = v.env.API_AUTH_BACK_SCOPE, this.API_AUTH_BACK_PASSWORD = v.env.API_AUTH_BACK_PASSWORD;
+    const r = `${this.API_AUTH_BACK_USERNAME_AUTH}:${this.API_AUTH_BACK_PASSWORD_AUTH}`, n = z.from(r).toString("base64");
+    this.headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json;charset=UTF-8",
+      Authorization: `Basic ${n}`
+    };
+  }
+  get() {
+    return this.logDebug("get ServiceToken"), Hr(this.API_AUTH_BACK_URL, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify({
+        user: this.API_AUTH_BACK_USER,
+        scope: this.API_AUTH_BACK_SCOPE,
+        password: this.API_AUTH_BACK_PASSWORD
+      })
+    }).pipe(
+      S((r) => r.json()),
+      S((r) => {
+        var n;
+        return this.logDebug(
+          `ServiceToken <URL>: \x1B[33m ${this.API_AUTH_BACK_URL} \x1B[37m <HEADERS>: \x1B[33m ${JSON.stringify(this.headers)} \x1B[37m <BODY>: \x1B[33m ${JSON.stringify(r)} \x1B[37m`
+        ), g(((n = r == null ? void 0 : r.data) == null ? void 0 : n.Token) || "");
+      }),
+      q((r) => (this.logError(`ServiceToken ${r}`), g("")))
+    );
+  }
+}
+class jr extends Q {
+  constructor() {
+    super();
+    b(this, "headers");
+    this.headers = {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    };
+  }
+  addTokenBackend(r) {
+    return this.logDebug("addTokenBackend CustomHeader", JSON.stringify(r)), new Br().get().pipe(
+      S((n) => g({ ...r, Authorization: `Bearer ${n}` }))
+    );
+  }
+  temporaryCognitoHeader(r) {
+    const n = {
+      Accesstoken: v.env.COGNITO_ACCESS_TOKEN,
+      Refreshtoken: v.env.COGNITO_REFRESH_TOKEN,
+      Idtoken: v.env.COGNITO_TOKEN_ID,
+      Username: v.env.COGNITO_USER_NAME
+    };
+    return g({
+      ...r,
+      ...n
+    });
+  }
+  getHeaders() {
+    return this.logDebug("getHeaders CustomHeader"), g({
+      ...this.headers
+    }).pipe(
+      S((r) => this.addTokenBackend(r)),
+      S((r) => this.temporaryCognitoHeader(r))
+    );
+  }
+}
+export {
+  jr as C,
+  Br as S,
+  Hr as f
+};