@solibo/solibo-sdk 1.0.36 → 1.0.38

package/ktor-ktor-client-auth.mjs

@@ -0,0 +1,1491 @@
+import {
+  CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl,
+  Unit_instance28fytmsmm6r23 as Unit_instance,
+  protoOf180f3jzyo7rfj as protoOf,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  VOID3gxj6tk5isa35 as VOID,
+  ArrayList_init_$Create$1jemgvhi5v0js as ArrayList_init_$Create$,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  emptyList1g2z5xcrvp2zy as emptyList,
+  toList3jhuyej2anx2q as toList,
+  KtMutableMap1kqeifoi36kpz as KtMutableMap,
+  getKClass3t8tygqu4lcxf as getKClass,
+  arrayOf1akklvh2at202 as arrayOf,
+  createKType31ecntyyaay3k as createKType,
+  createInvariantKTypeProjection3h5364czc0a8w as createInvariantKTypeProjection,
+  PrimitiveClasses_getInstance6p7zmos9nw3c as PrimitiveClasses_getInstance,
+  LinkedHashMap_init_$Create$3t495nfs82xn as LinkedHashMap_init_$Create$,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  ArrayList_init_$Create$3ivpeip4ouddx as ArrayList_init_$Create$_0,
+  flatten2dh4kibw1u0qq as flatten,
+  to2cs3ny02qtbcb as to,
+  first28gmhyvs4kf06 as first,
+  toString1pkumu07cwy4m as toString,
+  get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED,
+  HashSet_init_$Create$1rwei9nybb2jn as HashSet_init_$Create$,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  Unitkvevlwgzwiuc as Unit,
+  KtList3hktaavzmj137 as KtList,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  get6d5x931vk0s as get,
+  fold36i9psb7d5v48 as fold,
+  minusKeyyqanvso9aovh as minusKey,
+  plusolev77jfy5r9 as plus,
+  Element2gr7ezmxqaln7 as Element,
+  isInterface3d6p8outrmvmk as isInterface,
+  equals2au1ep9vhcato as equals,
+  IllegalStateException_init_$Create$2429fvs1h56dm as IllegalStateException_init_$Create$,
+} from './kotlin-kotlin-stdlib.mjs';
+import {
+  HttpResponse1532ob1hsse1y as HttpResponse,
+  Send_instance3smuuitxedznj as Send_instance,
+  OnRequestContext1tmu5b6bhlblg as OnRequestContext,
+  HttpRequestBuilder15f2nnx9sjuv1 as HttpRequestBuilder,
+  Sender1wtdgti85uk42 as Sender,
+  createClientPluginjwpvufjows5r as createClientPlugin,
+  headers24pki7ce1busg as headers,
+} from './ktor-ktor-client-core.mjs';
+import {
+  Companion_getInstance3047yo46wk0eo as Companion_getInstance,
+  parseAuthorizationHeaders2lhfb863nha8y as parseAuthorizationHeaders,
+  Parameterized3dskncivxbfxt as Parameterized,
+} from './ktor-ktor-http.mjs';
+import { atomic$int$11d5swdyn6j0pu as atomic$int$1 } from './kotlinx-atomicfu.mjs';
+import {
+  ConcurrentMapxp8jrjtp6gef as ConcurrentMap,
+  TypeInfo2nbxsuf4v8os2 as TypeInfo,
+  AttributeKey3aq8ytwgx54f7 as AttributeKey,
+  get_isTraceEnabled82xibuu04nxp as get_isTraceEnabled,
+  KtorSimpleLogger1xdphsp5l4e48 as KtorSimpleLogger,
+} from './ktor-ktor-utils.mjs';
+import {
+  CoroutineScopefcb5f5dwqcas as CoroutineScope,
+  Mutex16li1l0asjv17 as Mutex,
+  NonCancellable_getInstance307ceodv53u86 as NonCancellable_getInstance,
+  withContext3dkm8s4upl4ld as withContext,
+  launch1c91vkjzdi9sd as launch,
+  GlobalScope_instance1goye8260az8c as GlobalScope_instance,
+} from './kotlinx-coroutines-core.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+initMetadataForLambda(AuthConfig$isUnauthorizedResponse$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForClass(AuthConfig, 'AuthConfig', AuthConfig);
+initMetadataForClass(AtomicCounter, 'AtomicCounter', AtomicCounter);
+initMetadataForLambda(Auth$lambda$slambda, CoroutineImpl, VOID, [3]);
+initMetadataForLambda(Auth$lambda$slambda_1, CoroutineImpl, VOID, [2]);
+initMetadataForCoroutine($invoke$refreshTokenIfNeededCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($invoke$executeWithNewTokenCOROUTINE$, CoroutineImpl);
+function sendWithoutRequest(request) {
+  return this.nna();
+}
+function addRequestHeaders$default(request, authHeader, $completion, $super) {
+  authHeader = authHeader === VOID ? null : authHeader;
+  return $super === VOID ? this.mna(request, authHeader, $completion) : $super.mna.call(this, request, authHeader, $completion);
+}
+function refreshToken(response, $completion) {
+  return true;
+}
+initMetadataForInterface(AuthProvider, 'AuthProvider', VOID, VOID, VOID, [2, 1]);
+initMetadataForCompanion(Companion);
+initMetadataForClass(SetTokenContext, 'SetTokenContext', SetTokenContext, VOID, [Element]);
+initMetadataForLambda(AuthTokenHolder$setToken$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForLambda(AuthTokenHolder$clearToken$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForCoroutine($loadTokenCOROUTINE$, CoroutineImpl);
+initMetadataForClass(AuthTokenHolder, 'AuthTokenHolder', VOID, VOID, VOID, [0, 2]);
+initMetadataForLambda(BearerAuthConfig$refreshTokens$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForLambda(BearerAuthConfig$loadTokens$slambda, CoroutineImpl, VOID, [0]);
+initMetadataForClass(BearerAuthConfig, 'BearerAuthConfig', BearerAuthConfig);
+initMetadataForClass(BearerTokens, 'BearerTokens');
+initMetadataForClass(RefreshTokensParams, 'RefreshTokensParams');
+initMetadataForLambda(BearerAuthProvider$refreshToken$slambda, CoroutineImpl, VOID, [0]);
+initMetadataForCoroutine($addRequestHeadersCOROUTINE$, CoroutineImpl);
+initMetadataForCoroutine($refreshTokenCOROUTINE$, CoroutineImpl);
+initMetadataForClass(BearerAuthProvider, 'BearerAuthProvider', VOID, VOID, [AuthProvider], [2, 1]);
+//endregion
+function get_LOGGER() {
+  _init_properties_Auth_kt__9ob1dk();
+  return LOGGER;
+}
+var LOGGER;
+function get_AuthCircuitBreaker() {
+  _init_properties_Auth_kt__9ob1dk();
+  return AuthCircuitBreaker;
+}
+var AuthCircuitBreaker;
+function get_Auth() {
+  _init_properties_Auth_kt__9ob1dk();
+  return Auth;
+}
+var Auth;
+function get_AuthProvidersKey() {
+  _init_properties_Auth_kt__9ob1dk();
+  return AuthProvidersKey;
+}
+var AuthProvidersKey;
+function AuthConfig$isUnauthorizedResponse$slambda(resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(AuthConfig$isUnauthorizedResponse$slambda).tn7 = function (it, $completion) {
+  var tmp = this.v4j(it, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(AuthConfig$isUnauthorizedResponse$slambda).ca = function (p1, $completion) {
+  return this.tn7(p1 instanceof HttpResponse ? p1 : THROW_CCE(), $completion);
+};
+protoOf(AuthConfig$isUnauthorizedResponse$slambda).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      if (tmp === 0) {
+        this.j9_1 = 1;
+        return this.sn7_1.v3p().equals(Companion_getInstance().l3l_1);
+      } else if (tmp === 1) {
+        throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(AuthConfig$isUnauthorizedResponse$slambda).v4j = function (it, completion) {
+  var i = new AuthConfig$isUnauthorizedResponse$slambda(completion);
+  i.sn7_1 = it;
+  return i;
+};
+function AuthConfig$isUnauthorizedResponse$slambda_0(resultContinuation) {
+  var i = new AuthConfig$isUnauthorizedResponse$slambda(resultContinuation);
+  var l = function (it, $completion) {
+    return i.tn7(it, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function AuthConfig() {
+  var tmp = this;
+  // Inline function 'kotlin.collections.mutableListOf' call
+  tmp.un7_1 = ArrayList_init_$Create$();
+  var tmp_0 = this;
+  tmp_0.vn7_1 = AuthConfig$isUnauthorizedResponse$slambda_0(null);
+}
+function AtomicCounter() {
+  this.wn7_1 = atomic$int$1(0);
+}
+function get_authProviders(_this__u8e3s4) {
+  _init_properties_Auth_kt__9ob1dk();
+  var tmp0_elvis_lhs = _this__u8e3s4.j48_1.j32(get_AuthProvidersKey());
+  return tmp0_elvis_lhs == null ? emptyList() : tmp0_elvis_lhs;
+}
+function AuthConfig$_init_$ref_ms3pb9() {
+  var l = function () {
+    return new AuthConfig();
+  };
+  l.callableName = '<init>';
+  return l;
+}
+function Auth$lambda($this$createClientPlugin) {
+  _init_properties_Auth_kt__9ob1dk();
+  var providers = toList($this$createClientPlugin.v4i_1.un7_1);
+  $this$createClientPlugin.u4i_1.j48_1.l32(get_AuthProvidersKey(), providers);
+  var tokenVersions = new ConcurrentMap();
+  // Inline function 'io.ktor.util.AttributeKey' call
+  var name = 'ProviderVersionAttributeKey';
+  // Inline function 'io.ktor.util.reflect.typeInfo' call
+  var tmp = getKClass(KtMutableMap);
+  // Inline function 'io.ktor.util.reflect.typeOfOrNull' call
+  var tmp_0;
+  try {
+    tmp_0 = createKType(getKClass(KtMutableMap), arrayOf([createInvariantKTypeProjection(createKType(getKClass(AuthProvider), arrayOf([]), false)), createInvariantKTypeProjection(createKType(PrimitiveClasses_getInstance().hc(), arrayOf([]), false))]), false);
+  } catch ($p) {
+    var tmp_1;
+    if ($p instanceof Error) {
+      var _unused_var__etf5q3 = $p;
+      tmp_1 = null;
+    } else {
+      throw $p;
+    }
+    tmp_0 = tmp_1;
+  }
+  var tmp$ret$0 = tmp_0;
+  var tmp$ret$1 = new TypeInfo(tmp, tmp$ret$0);
+  var tokenVersionsAttributeKey = new AttributeKey(name, tmp$ret$1);
+  $this$createClientPlugin.v4x(Auth$lambda$slambda_0(providers, tokenVersions, tokenVersionsAttributeKey, null));
+  var tmp_2 = Send_instance;
+  $this$createClientPlugin.y4i(tmp_2, Auth$lambda$slambda_2($this$createClientPlugin, providers, tokenVersions, tokenVersionsAttributeKey, null));
+  return Unit_instance;
+}
+function Auth$lambda$refreshTokenIfNeeded$lambda() {
+  _init_properties_Auth_kt__9ob1dk();
+  return new AtomicCounter();
+}
+function Auth$lambda$refreshTokenIfNeeded$lambda_0() {
+  _init_properties_Auth_kt__9ob1dk();
+  // Inline function 'kotlin.collections.mutableMapOf' call
+  return LinkedHashMap_init_$Create$();
+}
+function invoke$findProvider(call, candidateProviders) {
+  var headerValues = call.f49().v3j().n36('WWW-Authenticate');
+  var tmp;
+  if (headerValues == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(headerValues, 10));
+    var _iterator__ex2g4s = headerValues.t();
+    while (_iterator__ex2g4s.u()) {
+      var item = _iterator__ex2g4s.v();
+      var tmp$ret$0 = parseAuthorizationHeaders(item);
+      destination.e1(tmp$ret$0);
+    }
+    tmp = destination;
+  }
+  var tmp1_safe_receiver = tmp;
+  var tmp2_elvis_lhs = tmp1_safe_receiver == null ? null : flatten(tmp1_safe_receiver);
+  var authHeaders = tmp2_elvis_lhs == null ? emptyList() : tmp2_elvis_lhs;
+  var tmp_0;
+  if (candidateProviders.g1() === 1) {
+    var provider = first(candidateProviders);
+    var tmp$ret$4;
+    $l$block: {
+      // Inline function 'kotlin.collections.firstOrNull' call
+      var _iterator__ex2g4s_0 = authHeaders.t();
+      while (_iterator__ex2g4s_0.u()) {
+        var element = _iterator__ex2g4s_0.v();
+        if (provider.xn7(element)) {
+          tmp$ret$4 = element;
+          break $l$block;
+        }
+      }
+      tmp$ret$4 = null;
+    }
+    var header = tmp$ret$4;
+    tmp_0 = to(provider, header);
+  } else if (authHeaders.r()) {
+    // Inline function 'io.ktor.util.logging.trace' call
+    var this_0 = get_LOGGER();
+    if (get_isTraceEnabled(this_0)) {
+      var tmp$ret$5 = 'Unauthorized response ' + call.o4b().y4b().toString() + ' has no or empty "WWW-Authenticate" header. ' + 'Can not add or refresh token';
+      this_0.z3b(tmp$ret$5);
+    }
+    tmp_0 = null;
+  } else {
+    var tmp$ret$13;
+    $l$block_1: {
+      // Inline function 'kotlin.collections.firstNotNullOfOrNull' call
+      var _iterator__ex2g4s_1 = authHeaders.t();
+      while (_iterator__ex2g4s_1.u()) {
+        var element_0 = _iterator__ex2g4s_1.v();
+        // Inline function 'kotlin.collections.find' call
+        var tmp$ret$8;
+        $l$block_0: {
+          // Inline function 'kotlin.collections.firstOrNull' call
+          var _iterator__ex2g4s_2 = candidateProviders.t();
+          while (_iterator__ex2g4s_2.u()) {
+            var element_1 = _iterator__ex2g4s_2.v();
+            if (element_1.xn7(element_0)) {
+              tmp$ret$8 = element_1;
+              break $l$block_0;
+            }
+          }
+          tmp$ret$8 = null;
+        }
+        var tmp0_safe_receiver = tmp$ret$8;
+        var tmp_1;
+        if (tmp0_safe_receiver == null) {
+          tmp_1 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          tmp_1 = to(tmp0_safe_receiver, element_0);
+        }
+        var result = tmp_1;
+        if (!(result == null)) {
+          tmp$ret$13 = result;
+          break $l$block_1;
+        }
+      }
+      tmp$ret$13 = null;
+    }
+    tmp_0 = tmp$ret$13;
+  }
+  return tmp_0;
+}
+function invoke$refreshTokenIfNeeded(tokenVersions, tokenVersionsAttributeKey, call, provider, request, $completion) {
+  var tmp = new $invoke$refreshTokenIfNeededCOROUTINE$(tokenVersions, tokenVersionsAttributeKey, call, provider, request, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+}
+function invoke$executeWithNewToken(_this__u8e3s4, call, provider, oldRequest, authHeader, $completion) {
+  var tmp = new $invoke$executeWithNewTokenCOROUTINE$(_this__u8e3s4, call, provider, oldRequest, authHeader, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+}
+function Auth$lambda$slambda$lambda() {
+  return new AtomicCounter();
+}
+function Auth$lambda$slambda$lambda_0() {
+  // Inline function 'kotlin.collections.mutableMapOf' call
+  return LinkedHashMap_init_$Create$();
+}
+function Auth$lambda$slambda($providers, $tokenVersions, $tokenVersionsAttributeKey, resultContinuation) {
+  this.jn9_1 = $providers;
+  this.kn9_1 = $tokenVersions;
+  this.ln9_1 = $tokenVersionsAttributeKey;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(Auth$lambda$slambda).j4y = function ($this$onRequest, request, _unused_var__etf5q3, $completion) {
+  var tmp = this.k4y($this$onRequest, request, _unused_var__etf5q3, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(Auth$lambda$slambda).l4y = function (p1, p2, p3, $completion) {
+  var tmp = p1 instanceof OnRequestContext ? p1 : THROW_CCE();
+  var tmp_0 = p2 instanceof HttpRequestBuilder ? p2 : THROW_CCE();
+  return this.j4y(tmp, tmp_0, !(p3 == null) ? p3 : THROW_CCE(), $completion);
+};
+protoOf(Auth$lambda$slambda).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 4;
+          var tmp0 = this.jn9_1;
+          var destination = ArrayList_init_$Create$();
+          var _iterator__ex2g4s = tmp0.t();
+          while (_iterator__ex2g4s.u()) {
+            var element = _iterator__ex2g4s.v();
+            if (element.qn9(this.nn9_1)) {
+              destination.e1(element);
+            }
+          }
+
+          this.pn9_1 = destination.t();
+          this.i9_1 = 1;
+          continue $sm;
+        case 1:
+          if (!this.pn9_1.u()) {
+            this.i9_1 = 3;
+            continue $sm;
+          }
+
+          var element_0 = this.pn9_1.v();
+          var this_0 = get_LOGGER();
+          if (get_isTraceEnabled(this_0)) {
+            this_0.z3b('Adding auth headers for ' + this.nn9_1.f4a_1.toString() + ' from provider ' + toString(element_0));
+          }
+
+          var tokenVersion = this.kn9_1.q3b(element_0, Auth$lambda$slambda$lambda);
+          var requestTokenVersions = this.nn9_1.k4a_1.o32(this.ln9_1, Auth$lambda$slambda$lambda_0);
+          var value = tokenVersion.wn7_1.kotlinx$atomicfu$value;
+          requestTokenVersions.c3(element_0, value);
+          this.i9_1 = 2;
+          suspendResult = element_0.rn9(this.nn9_1, VOID, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          this.i9_1 = 1;
+          continue $sm;
+        case 3:
+          return Unit_instance;
+        case 4:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 4) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(Auth$lambda$slambda).k4y = function ($this$onRequest, request, _unused_var__etf5q3, completion) {
+  var i = new Auth$lambda$slambda(this.jn9_1, this.kn9_1, this.ln9_1, completion);
+  i.mn9_1 = $this$onRequest;
+  i.nn9_1 = request;
+  i.on9_1 = _unused_var__etf5q3;
+  return i;
+};
+function Auth$lambda$slambda_0($providers, $tokenVersions, $tokenVersionsAttributeKey, resultContinuation) {
+  var i = new Auth$lambda$slambda($providers, $tokenVersions, $tokenVersionsAttributeKey, resultContinuation);
+  var l = function ($this$onRequest, request, _unused_var__etf5q3, $completion) {
+    return i.j4y($this$onRequest, request, _unused_var__etf5q3, $completion);
+  };
+  l.$arity = 3;
+  return l;
+}
+function Auth$lambda$slambda_1($this_createClientPlugin, $providers, $tokenVersions, $tokenVersionsAttributeKey, resultContinuation) {
+  this.ana_1 = $this_createClientPlugin;
+  this.bna_1 = $providers;
+  this.cna_1 = $tokenVersions;
+  this.dna_1 = $tokenVersionsAttributeKey;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(Auth$lambda$slambda_1).x4p = function ($this$on, originalRequest, $completion) {
+  var tmp = this.y4p($this$on, originalRequest, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(Auth$lambda$slambda_1).da = function (p1, p2, $completion) {
+  var tmp = p1 instanceof Sender ? p1 : THROW_CCE();
+  return this.x4p(tmp, p2 instanceof HttpRequestBuilder ? p2 : THROW_CCE(), $completion);
+};
+protoOf(Auth$lambda$slambda_1).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 10;
+          this.i9_1 = 1;
+          suspendResult = this.ena_1.b4q(this.fna_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.kna_1 = suspendResult;
+          this.i9_1 = 2;
+          suspendResult = this.ana_1.v4i_1.vn7_1(this.kna_1.f49(), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          if (!suspendResult) {
+            return this.kna_1;
+          } else {
+            this.i9_1 = 3;
+            continue $sm;
+          }
+
+        case 3:
+          if (this.kna_1.o4b().p4b().k32(get_AuthCircuitBreaker()))
+            return this.kna_1;
+          this.gna_1 = this.kna_1;
+          this.jna_1 = HashSet_init_$Create$(this.bna_1);
+          this.i9_1 = 4;
+          continue $sm;
+        case 4:
+          this.i9_1 = 5;
+          suspendResult = this.ana_1.v4i_1.vn7_1(this.gna_1.f49(), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 5:
+          if (!suspendResult) {
+            this.i9_1 = 9;
+            continue $sm;
+          }
+
+          var this_0 = get_LOGGER();
+          if (get_isTraceEnabled(this_0)) {
+            this_0.z3b('Unauthorized response for ' + this.gna_1.o4b().y4b().toString());
+          }
+
+          var tmp0_elvis_lhs = invoke$findProvider(this.gna_1, this.jna_1);
+          var tmp_0;
+          if (tmp0_elvis_lhs == null) {
+            this.ena_1;
+            var this_1 = get_LOGGER();
+            if (get_isTraceEnabled(this_1)) {
+              this_1.z3b('Can not find auth provider for ' + this.gna_1.o4b().y4b().toString());
+            }
+            return this.gna_1;
+          } else {
+            tmp_0 = tmp0_elvis_lhs;
+          }
+
+          var _destruct__k2r9zo = tmp_0;
+          this.ina_1 = _destruct__k2r9zo.xg();
+          this.hna_1 = _destruct__k2r9zo.yg();
+          var this_2 = get_LOGGER();
+          if (get_isTraceEnabled(this_2)) {
+            this_2.z3b('Using provider ' + toString(this.ina_1) + ' for ' + this.gna_1.o4b().y4b().toString());
+          }
+
+          this.jna_1.j3(this.ina_1);
+          this.i9_1 = 6;
+          suspendResult = invoke$refreshTokenIfNeeded(this.cna_1, this.dna_1, this.gna_1, this.ina_1, this.fna_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 6:
+          if (!suspendResult) {
+            return this.gna_1;
+          } else {
+            this.i9_1 = 7;
+            continue $sm;
+          }
+
+        case 7:
+          this.i9_1 = 8;
+          suspendResult = invoke$executeWithNewToken(this.ena_1, this.gna_1, this.ina_1, this.fna_1, this.hna_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 8:
+          this.gna_1 = suspendResult;
+          this.i9_1 = 4;
+          continue $sm;
+        case 9:
+          return this.gna_1;
+        case 10:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 10) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(Auth$lambda$slambda_1).y4p = function ($this$on, originalRequest, completion) {
+  var i = new Auth$lambda$slambda_1(this.ana_1, this.bna_1, this.cna_1, this.dna_1, completion);
+  i.ena_1 = $this$on;
+  i.fna_1 = originalRequest;
+  return i;
+};
+function Auth$lambda$slambda_2($this_createClientPlugin, $providers, $tokenVersions, $tokenVersionsAttributeKey, resultContinuation) {
+  var i = new Auth$lambda$slambda_1($this_createClientPlugin, $providers, $tokenVersions, $tokenVersionsAttributeKey, resultContinuation);
+  var l = function ($this$on, originalRequest, $completion) {
+    return i.x4p($this$on, originalRequest, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+function $invoke$refreshTokenIfNeededCOROUTINE$(tokenVersions, tokenVersionsAttributeKey, call, provider, request, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.gn8_1 = tokenVersions;
+  this.hn8_1 = tokenVersionsAttributeKey;
+  this.in8_1 = call;
+  this.jn8_1 = provider;
+  this.kn8_1 = request;
+}
+protoOf($invoke$refreshTokenIfNeededCOROUTINE$).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 4;
+          var tmp_0 = this;
+          tmp_0.ln8_1 = this.gn8_1.q3b(this.jn8_1, Auth$lambda$refreshTokenIfNeeded$lambda);
+          var tmp_1 = this;
+          tmp_1.mn8_1 = this.kn8_1.k4a_1.o32(this.hn8_1, Auth$lambda$refreshTokenIfNeeded$lambda_0);
+          var requestTokenVersion = this.mn8_1.z2(this.jn8_1);
+          if (!(requestTokenVersion == null) && requestTokenVersion >= this.ln8_1.wn7_1.kotlinx$atomicfu$value) {
+            var this_0 = get_LOGGER();
+            if (get_isTraceEnabled(this_0)) {
+              this_0.z3b('Refreshing token for ' + this.in8_1.o4b().y4b().toString());
+            }
+            this.i9_1 = 1;
+            suspendResult = this.jn8_1.lna(this.in8_1.f49(), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.i9_1 = 3;
+            continue $sm;
+          }
+
+        case 1:
+          if (!suspendResult) {
+            var this_1 = get_LOGGER();
+            if (get_isTraceEnabled(this_1)) {
+              this_1.z3b('Refreshing token failed for ' + this.in8_1.o4b().y4b().toString());
+            }
+            return false;
+          } else {
+            var tmp0 = this.mn8_1;
+            var tmp2 = this.jn8_1;
+            var value = this.ln8_1.wn7_1.atomicfu$incrementAndGet();
+            tmp0.c3(tmp2, value);
+            this.i9_1 = 2;
+            continue $sm;
+          }
+
+        case 2:
+          this.i9_1 = 3;
+          continue $sm;
+        case 3:
+          return true;
+        case 4:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 4) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+function $invoke$executeWithNewTokenCOROUTINE$(_this__u8e3s4, call, provider, oldRequest, authHeader, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.vn8_1 = _this__u8e3s4;
+  this.wn8_1 = call;
+  this.xn8_1 = provider;
+  this.yn8_1 = oldRequest;
+  this.zn8_1 = authHeader;
+}
+protoOf($invoke$executeWithNewTokenCOROUTINE$).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 3;
+          this.an9_1 = new HttpRequestBuilder();
+          this.an9_1.k4g(this.yn8_1);
+          this.i9_1 = 1;
+          suspendResult = this.xn8_1.mna(this.an9_1, this.zn8_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.an9_1.k4a_1.l32(get_AuthCircuitBreaker(), Unit_instance);
+          var this_0 = get_LOGGER();
+          if (get_isTraceEnabled(this_0)) {
+            this_0.z3b('Sending new request to ' + this.wn8_1.o4b().y4b().toString());
+          }
+
+          this.i9_1 = 2;
+          suspendResult = this.vn8_1.b4q(this.an9_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          return suspendResult;
+        case 3:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 3) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+var properties_initialized_Auth_kt_7p5u22;
+function _init_properties_Auth_kt__9ob1dk() {
+  if (!properties_initialized_Auth_kt_7p5u22) {
+    properties_initialized_Auth_kt_7p5u22 = true;
+    LOGGER = KtorSimpleLogger('io.ktor.client.plugins.auth.Auth');
+    // Inline function 'io.ktor.util.AttributeKey' call
+    var name = 'auth-request';
+    // Inline function 'io.ktor.util.reflect.typeInfo' call
+    var tmp = getKClass(Unit);
+    // Inline function 'io.ktor.util.reflect.typeOfOrNull' call
+    var tmp_0;
+    try {
+      tmp_0 = createKType(getKClass(Unit), arrayOf([]), false);
+    } catch ($p) {
+      var tmp_1;
+      if ($p instanceof Error) {
+        var _unused_var__etf5q3 = $p;
+        tmp_1 = null;
+      } else {
+        throw $p;
+      }
+      tmp_0 = tmp_1;
+    }
+    var tmp$ret$0 = tmp_0;
+    var tmp$ret$1 = new TypeInfo(tmp, tmp$ret$0);
+    AuthCircuitBreaker = new AttributeKey(name, tmp$ret$1);
+    var tmp_2 = AuthConfig$_init_$ref_ms3pb9();
+    Auth = createClientPlugin('Auth', tmp_2, Auth$lambda);
+    // Inline function 'io.ktor.util.AttributeKey' call
+    var name_0 = 'AuthProviders';
+    // Inline function 'io.ktor.util.reflect.typeInfo' call
+    var tmp_3 = getKClass(KtList);
+    // Inline function 'io.ktor.util.reflect.typeOfOrNull' call
+    var tmp_4;
+    try {
+      tmp_4 = createKType(getKClass(KtList), arrayOf([createInvariantKTypeProjection(createKType(getKClass(AuthProvider), arrayOf([]), false))]), false);
+    } catch ($p) {
+      var tmp_5;
+      if ($p instanceof Error) {
+        var _unused_var__etf5q3_0 = $p;
+        tmp_5 = null;
+      } else {
+        throw $p;
+      }
+      tmp_4 = tmp_5;
+    }
+    var tmp$ret$0_0 = tmp_4;
+    var tmp$ret$1_0 = new TypeInfo(tmp_3, tmp$ret$0_0);
+    AuthProvidersKey = new AttributeKey(name_0, tmp$ret$1_0);
+  }
+}
+function AuthProvider() {
+}
+function Companion() {
+}
+var Companion_instance;
+function Companion_getInstance_0() {
+  return Companion_instance;
+}
+function SetTokenContext() {
+}
+protoOf(SetTokenContext).m1 = function () {
+  return Companion_instance;
+};
+function AuthTokenHolder$setToken$slambda(this$0, $prevValue, $lockedByLoad, $block, resultContinuation) {
+  this.wna_1 = this$0;
+  this.xna_1 = $prevValue;
+  this.yna_1 = $lockedByLoad;
+  this.zna_1 = $block;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(AuthTokenHolder$setToken$slambda).enb = function ($this$withContext, $completion) {
+  var tmp = this.e30($this$withContext, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(AuthTokenHolder$setToken$slambda).ca = function (p1, $completion) {
+  return this.enb((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(AuthTokenHolder$setToken$slambda).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 7;
+          this.cnb_1 = this.wna_1.jnb_1;
+          this.bnb_1 = null;
+          this.i9_1 = 1;
+          suspendResult = this.cnb_1.m2h(this.bnb_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.dnb_1 = Unit_instance;
+          this.i9_1 = 2;
+          continue $sm;
+        case 2:
+          this.j9_1 = 6;
+          if (equals(this.xna_1, this.wna_1.hnb_1) || this.yna_1) {
+            this.i9_1 = 3;
+            suspendResult = this.zna_1(this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.i9_1 = 4;
+            continue $sm;
+          }
+
+        case 3:
+          var ARGUMENT = suspendResult;
+          this.wna_1.hnb_1 = ARGUMENT;
+          this.i9_1 = 4;
+          continue $sm;
+        case 4:
+          this.dnb_1 = this.wna_1.hnb_1;
+          this.j9_1 = 7;
+          this.i9_1 = 5;
+          continue $sm;
+        case 5:
+          var tmp_0 = this.dnb_1;
+          this.j9_1 = 7;
+          this.cnb_1.n2h(this.bnb_1);
+          return tmp_0;
+        case 6:
+          this.j9_1 = 7;
+          var t = this.l9_1;
+          this.cnb_1.n2h(this.bnb_1);
+          throw t;
+        case 7:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 7) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(AuthTokenHolder$setToken$slambda).e30 = function ($this$withContext, completion) {
+  var i = new AuthTokenHolder$setToken$slambda(this.wna_1, this.xna_1, this.yna_1, this.zna_1, completion);
+  i.anb_1 = $this$withContext;
+  return i;
+};
+function AuthTokenHolder$setToken$slambda_0(this$0, $prevValue, $lockedByLoad, $block, resultContinuation) {
+  var i = new AuthTokenHolder$setToken$slambda(this$0, $prevValue, $lockedByLoad, $block, resultContinuation);
+  var l = function ($this$withContext, $completion) {
+    return i.enb($this$withContext, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function AuthTokenHolder$clearToken$slambda(this$0, resultContinuation) {
+  this.tnb_1 = this$0;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(AuthTokenHolder$clearToken$slambda).d30 = function ($this$launch, $completion) {
+  var tmp = this.e30($this$launch, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(AuthTokenHolder$clearToken$slambda).ca = function (p1, $completion) {
+  return this.d30((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(AuthTokenHolder$clearToken$slambda).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 2;
+          this.wnb_1 = this.tnb_1.jnb_1;
+          this.vnb_1 = null;
+          this.i9_1 = 1;
+          suspendResult = this.wnb_1.m2h(this.vnb_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          l$ret$1: do {
+            var tmp_0;
+            try {
+              this.tnb_1.hnb_1 = null;
+              break l$ret$1;
+            } catch ($p) {
+              var tmp_1;
+              var t = $p;
+              this.wnb_1.n2h(this.vnb_1);
+              throw t;
+            }
+          }
+           while (false);
+          this.wnb_1.n2h(this.vnb_1);
+          return Unit_instance;
+        case 2:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 2) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(AuthTokenHolder$clearToken$slambda).e30 = function ($this$launch, completion) {
+  var i = new AuthTokenHolder$clearToken$slambda(this.tnb_1, completion);
+  i.unb_1 = $this$launch;
+  return i;
+};
+function AuthTokenHolder$clearToken$slambda_0(this$0, resultContinuation) {
+  var i = new AuthTokenHolder$clearToken$slambda(this$0, resultContinuation);
+  var l = function ($this$launch, $completion) {
+    return i.d30($this$launch, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $loadTokenCOROUTINE$(_this__u8e3s4, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.fnc_1 = _this__u8e3s4;
+}
+protoOf($loadTokenCOROUTINE$).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 14;
+          if (!this.fnc_1.gnb_1) {
+            this.i9_1 = 13;
+            suspendResult = this.fnc_1.fnb_1(this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.i9_1 = 1;
+            continue $sm;
+          }
+
+        case 1:
+          if (!(this.fnc_1.hnb_1 == null))
+            return this.fnc_1.hnb_1;
+          this.knc_1 = this.fnc_1.hnb_1;
+          if (!(this.o9().v9(Companion_instance) == null)) {
+            this.i9_1 = 11;
+            suspendResult = this.fnc_1.fnb_1(this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.inc_1 = this.fnc_1.jnb_1;
+            this.hnc_1 = null;
+            this.i9_1 = 2;
+            suspendResult = this.inc_1.m2h(this.hnc_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          }
+
+        case 2:
+          this.jnc_1 = Unit_instance;
+          this.i9_1 = 3;
+          continue $sm;
+        case 3:
+          this.j9_1 = 10;
+          this.fnc_1.inb_1 = true;
+          this.i9_1 = 4;
+          continue $sm;
+        case 4:
+          this.j9_1 = 9;
+          if (equals(this.knc_1, this.fnc_1.hnb_1)) {
+            this.i9_1 = 5;
+            suspendResult = this.fnc_1.fnb_1(this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.i9_1 = 6;
+            continue $sm;
+          }
+
+        case 5:
+          var ARGUMENT = suspendResult;
+          this.fnc_1.hnb_1 = ARGUMENT;
+          this.i9_1 = 6;
+          continue $sm;
+        case 6:
+          this.i9_1 = 7;
+          continue $sm;
+        case 7:
+          this.j9_1 = 10;
+          this.fnc_1.inb_1 = false;
+          this.jnc_1 = this.fnc_1.hnb_1;
+          this.j9_1 = 14;
+          this.i9_1 = 8;
+          continue $sm;
+        case 8:
+          var tmp_0 = this.jnc_1;
+          this.j9_1 = 14;
+          this.inc_1.n2h(this.hnc_1);
+          this.gnc_1 = tmp_0;
+          this.i9_1 = 12;
+          continue $sm;
+        case 9:
+          this.j9_1 = 10;
+          var t = this.l9_1;
+          this.fnc_1.inb_1 = false;
+          throw t;
+        case 10:
+          this.j9_1 = 14;
+          var t_0 = this.l9_1;
+          this.inc_1.n2h(this.hnc_1);
+          throw t_0;
+        case 11:
+          var ARGUMENT_0 = suspendResult;
+          this.fnc_1.hnb_1 = ARGUMENT_0;
+          this.gnc_1 = this.fnc_1.hnb_1;
+          this.i9_1 = 12;
+          continue $sm;
+        case 12:
+          return this.gnc_1;
+        case 13:
+          return suspendResult;
+        case 14:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 14) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+function AuthTokenHolder(loadTokens, cacheTokens) {
+  cacheTokens = cacheTokens === VOID ? true : cacheTokens;
+  this.fnb_1 = loadTokens;
+  this.gnb_1 = cacheTokens;
+  this.hnb_1 = null;
+  this.inb_1 = false;
+  this.jnb_1 = Mutex();
+  this.knb_1 = new SetTokenContext();
+}
+protoOf(AuthTokenHolder).lnc = function ($completion) {
+  var tmp = new $loadTokenCOROUTINE$(this, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(AuthTokenHolder).mnc = function (nonCancellable, block, $completion) {
+  var prevValue = this.hnb_1;
+  var lockedByLoad = this.inb_1;
+  var tmp;
+  if (nonCancellable) {
+    // Inline function 'kotlin.js.getCoroutineContext' call
+    tmp = $completion.o9().qj(NonCancellable_getInstance()).qj(this.knb_1);
+  } else {
+    // Inline function 'kotlin.js.getCoroutineContext' call
+    tmp = $completion.o9().qj(this.knb_1);
+  }
+  var context = tmp;
+  return withContext(context, AuthTokenHolder$setToken$slambda_0(this, prevValue, lockedByLoad, block, null), $completion);
+};
+protoOf(AuthTokenHolder).nnc = function (coroutineScope) {
+  if (this.jnb_1.l2h()) {
+    this.hnb_1 = null;
+    this.jnb_1.o2h();
+  } else {
+    launch(coroutineScope, VOID, VOID, AuthTokenHolder$clearToken$slambda_0(this, null));
+  }
+};
+protoOf(AuthTokenHolder).onc = function (coroutineScope, $super) {
+  coroutineScope = coroutineScope === VOID ? GlobalScope_instance : coroutineScope;
+  var tmp;
+  if ($super === VOID) {
+    this.nnc(coroutineScope);
+    tmp = Unit_instance;
+  } else {
+    tmp = $super.nnc.call(this, coroutineScope);
+  }
+  return tmp;
+};
+function bearer(_this__u8e3s4, block) {
+  // Inline function 'kotlin.apply' call
+  var this_0 = new BearerAuthConfig();
+  block(this_0);
+  // Inline function 'kotlin.with' call
+  _this__u8e3s4.un7_1.e1(new BearerAuthProvider(this_0.pnc_1, this_0.qnc_1, this_0.rnc_1, this_0.snc_1, this_0.tnc_1, this_0.unc_1));
+}
+function BearerAuthConfig$refreshTokens$slambda(resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(BearerAuthConfig$refreshTokens$slambda).fnd = function (_this__u8e3s4, $completion) {
+  var tmp = this.gnd(_this__u8e3s4, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(BearerAuthConfig$refreshTokens$slambda).ca = function (p1, $completion) {
+  return this.fnd(p1 instanceof RefreshTokensParams ? p1 : THROW_CCE(), $completion);
+};
+protoOf(BearerAuthConfig$refreshTokens$slambda).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      if (tmp === 0) {
+        this.j9_1 = 1;
+        return null;
+      } else if (tmp === 1) {
+        throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(BearerAuthConfig$refreshTokens$slambda).gnd = function (_this__u8e3s4, completion) {
+  var i = new BearerAuthConfig$refreshTokens$slambda(completion);
+  i.dnd_1 = _this__u8e3s4;
+  return i;
+};
+function BearerAuthConfig$refreshTokens$slambda_0(resultContinuation) {
+  var i = new BearerAuthConfig$refreshTokens$slambda(resultContinuation);
+  var l = function (_this__u8e3s4, $completion) {
+    return i.fnd(_this__u8e3s4, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function BearerAuthConfig$loadTokens$slambda(resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(BearerAuthConfig$loadTokens$slambda).pnd = function ($completion) {
+  var tmp = this.qnd($completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(BearerAuthConfig$loadTokens$slambda).za = function ($completion) {
+  return this.pnd($completion);
+};
+protoOf(BearerAuthConfig$loadTokens$slambda).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      if (tmp === 0) {
+        this.j9_1 = 1;
+        return null;
+      } else if (tmp === 1) {
+        throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(BearerAuthConfig$loadTokens$slambda).qnd = function (completion) {
+  return new BearerAuthConfig$loadTokens$slambda(completion);
+};
+function BearerAuthConfig$loadTokens$slambda_0(resultContinuation) {
+  var i = new BearerAuthConfig$loadTokens$slambda(resultContinuation);
+  var l = function ($completion) {
+    return i.pnd($completion);
+  };
+  l.$arity = 0;
+  return l;
+}
+function BearerAuthConfig$sendWithoutRequest$lambda(it) {
+  return true;
+}
+function BearerAuthConfig() {
+  var tmp = this;
+  tmp.pnc_1 = BearerAuthConfig$refreshTokens$slambda_0(null);
+  var tmp_0 = this;
+  tmp_0.qnc_1 = BearerAuthConfig$loadTokens$slambda_0(null);
+  var tmp_1 = this;
+  tmp_1.rnc_1 = BearerAuthConfig$sendWithoutRequest$lambda;
+  this.snc_1 = null;
+  this.tnc_1 = true;
+  this.unc_1 = false;
+}
+protoOf(BearerAuthConfig).rnd = function (block) {
+  this.pnc_1 = block;
+};
+protoOf(BearerAuthConfig).snd = function (block) {
+  this.qnc_1 = block;
+};
+function BearerTokens(accessToken, refreshToken) {
+  this.tnd_1 = accessToken;
+  this.und_1 = refreshToken;
+}
+function RefreshTokensParams(client, response, oldTokens) {
+  this.vnd_1 = client;
+  this.wnd_1 = response;
+  this.xnd_1 = oldTokens;
+}
+function BearerAuthProvider$_init_$lambda_lcdiwf(it) {
+  return true;
+}
+function BearerAuthProvider$addRequestHeaders$lambda($token, $request) {
+  return function ($this$headers) {
+    var tokenValue = 'Bearer ' + $token.tnd_1;
+    var tmp;
+    if ($this$headers.i36('Authorization')) {
+      $this$headers.x36('Authorization');
+      tmp = Unit_instance;
+    }
+    var tmp_0;
+    if (!$request.k4a_1.k32(get_AuthCircuitBreaker())) {
+      $this$headers.j36('Authorization', tokenValue);
+      tmp_0 = Unit_instance;
+    }
+    return Unit_instance;
+  };
+}
+function BearerAuthProvider$refreshToken$slambda(this$0, $response, resultContinuation) {
+  this.gne_1 = this$0;
+  this.hne_1 = $response;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(BearerAuthProvider$refreshToken$slambda).pnd = function ($completion) {
+  var tmp = this.qnd($completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(BearerAuthProvider$refreshToken$slambda).za = function ($completion) {
+  return this.pnd($completion);
+};
+protoOf(BearerAuthProvider$refreshToken$slambda).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 3;
+          this.ine_1 = this.gne_1.kne_1;
+          this.jne_1 = this.hne_1.w4b().a49_1;
+          this.i9_1 = 1;
+          suspendResult = this.gne_1.one_1.lnc(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var ARGUMENT = suspendResult;
+          var ARGUMENT_0 = new RefreshTokensParams(this.jne_1, this.hne_1, ARGUMENT);
+          this.i9_1 = 2;
+          suspendResult = this.ine_1(ARGUMENT_0, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          return suspendResult;
+        case 3:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 3) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(BearerAuthProvider$refreshToken$slambda).qnd = function (completion) {
+  return new BearerAuthProvider$refreshToken$slambda(this.gne_1, this.hne_1, completion);
+};
+function BearerAuthProvider$refreshToken$slambda_0(this$0, $response, resultContinuation) {
+  var i = new BearerAuthProvider$refreshToken$slambda(this$0, $response, resultContinuation);
+  var l = function ($completion) {
+    return i.pnd($completion);
+  };
+  l.$arity = 0;
+  return l;
+}
+function $addRequestHeadersCOROUTINE$(_this__u8e3s4, request, authHeader, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.xne_1 = _this__u8e3s4;
+  this.yne_1 = request;
+  this.zne_1 = authHeader;
+}
+protoOf($addRequestHeadersCOROUTINE$).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 2;
+          this.i9_1 = 1;
+          suspendResult = this.xne_1.one_1.lnc(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var tmp0_elvis_lhs = suspendResult;
+          var tmp_0;
+          if (tmp0_elvis_lhs == null) {
+            return Unit_instance;
+          } else {
+            tmp_0 = tmp0_elvis_lhs;
+          }
+
+          var token = tmp_0;
+          headers(this.yne_1, BearerAuthProvider$addRequestHeaders$lambda(token, this.yne_1));
+          return Unit_instance;
+        case 2:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 2) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+function $refreshTokenCOROUTINE$(_this__u8e3s4, response, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.inf_1 = _this__u8e3s4;
+  this.jnf_1 = response;
+}
+protoOf($refreshTokenCOROUTINE$).q9 = function () {
+  var suspendResult = this.k9_1;
+  $sm: do
+    try {
+      var tmp = this.i9_1;
+      switch (tmp) {
+        case 0:
+          this.j9_1 = 2;
+          this.i9_1 = 1;
+          suspendResult = this.inf_1.one_1.mnc(this.inf_1.nne_1, BearerAuthProvider$refreshToken$slambda_0(this.inf_1, this.jnf_1, null), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var newToken = suspendResult;
+          return !(newToken == null);
+        case 2:
+          throw this.l9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.j9_1 === 2) {
+        throw e;
+      } else {
+        this.i9_1 = this.j9_1;
+        this.l9_1 = e;
+      }
+    }
+   while (true);
+};
+function BearerAuthProvider(refreshTokens, loadTokens, sendWithoutRequestCallback, realm, cacheTokens, nonCancellableRefresh) {
+  var tmp;
+  if (sendWithoutRequestCallback === VOID) {
+    tmp = BearerAuthProvider$_init_$lambda_lcdiwf;
+  } else {
+    tmp = sendWithoutRequestCallback;
+  }
+  sendWithoutRequestCallback = tmp;
+  cacheTokens = cacheTokens === VOID ? true : cacheTokens;
+  nonCancellableRefresh = nonCancellableRefresh === VOID ? false : nonCancellableRefresh;
+  this.kne_1 = refreshTokens;
+  this.lne_1 = sendWithoutRequestCallback;
+  this.mne_1 = realm;
+  this.nne_1 = nonCancellableRefresh;
+  this.one_1 = new AuthTokenHolder(loadTokens, cacheTokens);
+}
+protoOf(BearerAuthProvider).nna = function () {
+  var message = 'Deprecated';
+  throw IllegalStateException_init_$Create$(toString(message));
+};
+protoOf(BearerAuthProvider).qn9 = function (request) {
+  return this.lne_1(request);
+};
+protoOf(BearerAuthProvider).xn7 = function (auth) {
+  if (!(auth.l3p_1 === 'Bearer')) {
+    get_LOGGER().z3b('Bearer Auth Provider is not applicable for ' + auth.toString());
+    return false;
+  }
+  var tmp;
+  if (this.mne_1 == null) {
+    tmp = true;
+  } else {
+    if (!(auth instanceof Parameterized)) {
+      tmp = false;
+    } else {
+      tmp = auth.m3e('realm') == this.mne_1;
+    }
+  }
+  var isSameRealm = tmp;
+  if (!isSameRealm) {
+    get_LOGGER().z3b('Bearer Auth Provider is not applicable for this realm');
+  }
+  return isSameRealm;
+};
+protoOf(BearerAuthProvider).mna = function (request, authHeader, $completion) {
+  var tmp = new $addRequestHeadersCOROUTINE$(this, request, authHeader, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(BearerAuthProvider).lna = function (response, $completion) {
+  var tmp = new $refreshTokenCOROUTINE$(this, response, $completion);
+  tmp.k9_1 = Unit_instance;
+  tmp.l9_1 = null;
+  return tmp.q9();
+};
+protoOf(BearerAuthProvider).knf = function () {
+  this.one_1.onc();
+};
+//region block: post-declaration
+protoOf(SetTokenContext).v9 = get;
+protoOf(SetTokenContext).pj = fold;
+protoOf(SetTokenContext).oj = minusKey;
+protoOf(SetTokenContext).qj = plus;
+protoOf(BearerAuthProvider).rn9 = addRequestHeaders$default;
+//endregion
+//region block: init
+Companion_instance = new Companion();
+//endregion
+//region block: exports
+export {
+  BearerAuthProvider as BearerAuthProvider3dlezm3ux8npz,
+  BearerTokens as BearerTokens7h29bip6m1pf,
+  RefreshTokensParams as RefreshTokensParams3vv92jq8a1mg3,
+  bearer as bearer3b1oi44ec3xsb,
+  get_Auth as get_Auth3auwb1dqcwarr,
+  get_authProviders as get_authProviders394nbziurer3k,
+};
+//endregion
+
+//# sourceMappingURL=ktor-ktor-client-auth.mjs.map