mp-front-cli 2.0.0-canary.0 → 2.0.0-canary.3

package/dist/service-token-DceocCHP.js

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