@continuous-excellence/coupling-cli 0.0.0

package/kotlin/ktor-ktor-client-core/io/ktor/client/plugins/HttpRequestRetry.mjs

@@ -0,0 +1,728 @@
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { delay2673xnmlkmidc as delay } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Delay.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import {
+  Unit_instance28fytmsmm6r23 as Unit_instance,
+  Unitkvevlwgzwiuc as Unit,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { Default_getInstance1yflkybdrpcz6 as Default_getInstance } from '../../../../../kotlin-kotlin-stdlib/kotlin/random/Random.mjs';
+import { Long2qws0ah9gnpki as Long } from '../../../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
+import {
+  equalsLong28bsrfhwvd686 as equalsLong,
+  fromInt1lka3ktyu79a4 as fromInt,
+  multiply18i3gv3wlmcjg as multiply,
+  compare2uud5j30pw5xc as compare,
+  toNumberlmbpvqo27r53 as toNumber,
+  numberToLong345n6tb1n1i71 as numberToLong,
+  add85si75olwt6n as add,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/internal/boxedLong/boxedLong.mjs';
+import { suspendOrReturn49pspzlx5djv as suspendOrReturn } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { CancellationException3b36o9qz53rgr as CancellationException } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/cancellation/CancellationException.mjs';
+import { HttpHeaders_getInstance1z5nmwg0t7mku as HttpHeaders_getInstance } from '../../../../../ktor-ktor-http/io/ktor/http/HttpHeaders.mjs';
+import { toLongOrNullutqivezb0wx1 as toLongOrNull } from '../../../../../kotlin-kotlin-stdlib/kotlin/text/StringNumberConversions.mjs';
+import { throwUninitializedPropertyAccessException14fok093f3k3t as throwUninitializedPropertyAccessException } from '../../../../../kotlin-kotlin-stdlib/kotlin/internal/ThrowHelpers.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import {
+  Companion_instance25ullnynvxd0w as Companion_instance,
+  _Result___init__impl__xyqfz83a5421h46yeyh as _Result___init__impl__xyqfz8,
+  createFailure8paxfkfa5dc7 as createFailure,
+  Result__exceptionOrNull_impl_p6xea91su3v1n6nioxn as Result__exceptionOrNull_impl_p6xea9,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/Result.mjs';
+import { canceldn4b3cdqcfny as cancel } from '../../../../../ktor-ktor-io/io/ktor/utils/io/ByteReadChannel.mjs';
+import { get_isSaved1yor47kvbhumv as get_isSaved } from './SaveBody.mjs';
+import { unwrapCancellationException1zvbmufui4i9c as unwrapCancellationException } from '../utils/ExceptionUtils.nonJvm.mjs';
+import {
+  ConnectTimeoutException35w4gpuoa1015 as ConnectTimeoutException,
+  SocketTimeoutException2zstjwq2yf3s9 as SocketTimeoutException,
+} from '../network/sockets/TimeoutExceptions.nonJvm.mjs';
+import { HttpRequestTimeoutException19335ch7q7rkf as HttpRequestTimeoutException } from './HttpTimeout.mjs';
+import {
+  Send_instance3smuuitxedznj as Send_instance,
+  Sender1wtdgti85uk42 as Sender,
+} from './api/CommonHooks.mjs';
+import { CompletableJob1w6swnu15iclo as CompletableJob } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CompletableJob.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import {
+  HttpRequestBuilder15f2nnx9sjuv1 as HttpRequestBuilder,
+  HttpRequest3fsc4149kgwfg as HttpRequest,
+} from '../request/HttpRequest.mjs';
+import { OnRequestContext1tmu5b6bhlblg as OnRequestContext } from './api/KtorCallContexts.mjs';
+import { KtorSimpleLogger1xdphsp5l4e48 as KtorSimpleLogger } from '../../../../../ktor-ktor-utils/io/ktor/util/logging/KtorSimpleLoggerJs.mjs';
+import { EventDefinition1fymk8xrdelhn as EventDefinition } from '../../../../../ktor-ktor-events/io/ktor/events/Events.mjs';
+import { createClientPluginjwpvufjows5r as createClientPlugin } from './api/CreatePluginUtils.mjs';
+import { PrimitiveClasses_getInstance6p7zmos9nw3c as PrimitiveClasses_getInstance } from '../../../../../kotlin-kotlin-stdlib/kotlin/reflect/js/internal/primitives.mjs';
+import { arrayOf1akklvh2at202 as arrayOf } from '../../../../../kotlin-kotlin-stdlib/kotlin/Library.mjs';
+import {
+  createKType31ecntyyaay3k as createKType,
+  createInvariantKTypeProjection3h5364czc0a8w as createInvariantKTypeProjection,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/reflect/js/internal/KTypeHelpers.mjs';
+import { TypeInfo2nbxsuf4v8os2 as TypeInfo } from '../../../../../ktor-ktor-utils/io/ktor/util/reflect/Type.mjs';
+import { AttributeKey3aq8ytwgx54f7 as AttributeKey } from '../../../../../ktor-ktor-utils/io/ktor/util/Attributes.mjs';
+import { getKClass3t8tygqu4lcxf as getKClass } from '../../../../../kotlin-kotlin-stdlib/kotlin/reflect/js/internal/reflection.mjs';
+import { HttpResponse1532ob1hsse1y as HttpResponse } from '../statement/HttpResponse.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_LOGGER() {
+  _init_properties_HttpRequestRetry_kt__h4xjtt();
+  return LOGGER;
+}
+var LOGGER;
+function get_HttpRequestRetryEvent() {
+  _init_properties_HttpRequestRetry_kt__h4xjtt();
+  return HttpRequestRetryEvent;
+}
+var HttpRequestRetryEvent;
+function get_HttpRequestRetry() {
+  _init_properties_HttpRequestRetry_kt__h4xjtt();
+  return HttpRequestRetry;
+}
+var HttpRequestRetry;
+function get_MaxRetriesPerRequestAttributeKey() {
+  _init_properties_HttpRequestRetry_kt__h4xjtt();
+  return MaxRetriesPerRequestAttributeKey;
+}
+var MaxRetriesPerRequestAttributeKey;
+function get_ShouldRetryPerRequestAttributeKey() {
+  _init_properties_HttpRequestRetry_kt__h4xjtt();
+  return ShouldRetryPerRequestAttributeKey;
+}
+var ShouldRetryPerRequestAttributeKey;
+function get_ShouldRetryOnExceptionPerRequestAttributeKey() {
+  _init_properties_HttpRequestRetry_kt__h4xjtt();
+  return ShouldRetryOnExceptionPerRequestAttributeKey;
+}
+var ShouldRetryOnExceptionPerRequestAttributeKey;
+function get_ModifyRequestPerRequestAttributeKey() {
+  _init_properties_HttpRequestRetry_kt__h4xjtt();
+  return ModifyRequestPerRequestAttributeKey;
+}
+var ModifyRequestPerRequestAttributeKey;
+function get_RetryDelayPerRequestAttributeKey() {
+  _init_properties_HttpRequestRetry_kt__h4xjtt();
+  return RetryDelayPerRequestAttributeKey;
+}
+var RetryDelayPerRequestAttributeKey;
+var HttpRetryEventDataClass;
+function HttpRetryEventData() {
+  if (HttpRetryEventDataClass === VOID) {
+    class $ {
+      constructor(request, retryCount, response, cause) {
+        this.a3m_1 = request;
+        this.b3m_1 = retryCount;
+        this.c3m_1 = response;
+        this.d3m_1 = cause;
+      }
+    }
+    initMetadataForClass($, 'HttpRetryEventData');
+    HttpRetryEventDataClass = $;
+  }
+  return HttpRetryEventDataClass;
+}
+function *_generator_invoke__zhh2q8($this, it, $completion) {
+  var tmp = delay(it, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return Unit_instance;
+}
+function randomMs($this, randomizationMs) {
+  return equalsLong(randomizationMs, new (Long())(0, 0)) ? new (Long())(0, 0) : Default_getInstance().kp(randomizationMs);
+}
+var HttpRequestRetryConfig$delay$slambdaClass;
+function HttpRequestRetryConfig$delay$slambda() {
+  if (HttpRequestRetryConfig$delay$slambdaClass === VOID) {
+    class $ {
+      e3m(it, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8.bind(VOID, this, it), $completion);
+      }
+      de(p1, $completion) {
+        return this.e3m(p1 instanceof Long() ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    HttpRequestRetryConfig$delay$slambdaClass = $;
+  }
+  return HttpRequestRetryConfig$delay$slambdaClass;
+}
+function HttpRequestRetryConfig$delay$slambda_0() {
+  var i = new (HttpRequestRetryConfig$delay$slambda())();
+  var l = (it, $completion) => i.e3m(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+function HttpRequestRetryConfig$modifyRequest$lambda(_this__u8e3s4, it) {
+  return Unit_instance;
+}
+function HttpRequestRetryConfig$retryOnException$lambda($retryOnTimeout) {
+  return ($this$retryOnExceptionIf, _unused_var__etf5q3, cause) => {
+    var tmp;
+    if (isTimeoutException(cause)) {
+      tmp = $retryOnTimeout;
+    } else {
+      if (cause instanceof CancellationException()) {
+        tmp = false;
+      } else {
+        tmp = true;
+      }
+    }
+    return tmp;
+  };
+}
+function HttpRequestRetryConfig$retryOnServerErrors$lambda($this$retryIf, _unused_var__etf5q3, response) {
+  // Inline function 'kotlin.let' call
+  var it = response.s31().u2y_1;
+  return 500 <= it ? it <= 599 : false;
+}
+function HttpRequestRetryConfig$delayMillis$lambda($respectRetryAfterHeader, $block) {
+  return (_this__u8e3s4, it) => {
+    var tmp;
+    if ($respectRetryAfterHeader) {
+      var tmp0_safe_receiver = _this__u8e3s4.g3m_1;
+      var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.y2v();
+      var tmp2_safe_receiver = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.gi(HttpHeaders_getInstance().k2t_1);
+      var tmp3_safe_receiver = tmp2_safe_receiver == null ? null : toLongOrNull(tmp2_safe_receiver);
+      var tmp_0;
+      if (tmp3_safe_receiver == null) {
+        tmp_0 = null;
+      } else {
+        // Inline function 'kotlin.Long.times' call
+        tmp_0 = multiply(tmp3_safe_receiver, fromInt(1000));
+      }
+      var retryAfter = tmp_0;
+      var tmp0 = $block(_this__u8e3s4, it);
+      // Inline function 'kotlin.comparisons.maxOf' call
+      var b = retryAfter == null ? new (Long())(0, 0) : retryAfter;
+      tmp = compare(tmp0, b) >= 0 ? tmp0 : b;
+    } else {
+      tmp = $block(_this__u8e3s4, it);
+    }
+    return tmp;
+  };
+}
+function HttpRequestRetryConfig$exponentialDelay$lambda($base, $baseDelayMs, $maxDelayMs, this$0, $randomizationMs) {
+  return ($this$delayMillis, retry) => {
+    var tmp0 = $base;
+    // Inline function 'kotlin.math.pow' call
+    var n = retry - 1 | 0;
+    var tmp$ret$0 = Math.pow(tmp0, n);
+    var tmp0_0 = numberToLong(tmp$ret$0 * toNumber($baseDelayMs));
+    // Inline function 'kotlin.comparisons.minOf' call
+    var b = $maxDelayMs;
+    var delay = compare(tmp0_0, b) <= 0 ? tmp0_0 : b;
+    return add(delay, randomMs(this$0, $randomizationMs));
+  };
+}
+var HttpRequestRetryConfigClass;
+function HttpRequestRetryConfig() {
+  if (HttpRequestRetryConfigClass === VOID) {
+    class $ {
+      constructor() {
+        var tmp = this;
+        tmp.l3m_1 = HttpRequestRetryConfig$delay$slambda_0();
+        var tmp_0 = this;
+        tmp_0.m3m_1 = HttpRequestRetryConfig$modifyRequest$lambda;
+        this.n3m_1 = 0;
+        this.o3m(3);
+        this.p3m();
+      }
+      q3m() {
+        var tmp = this.i3m_1;
+        if (!(tmp == null))
+          return tmp;
+        else {
+          throwUninitializedPropertyAccessException('shouldRetry');
+        }
+      }
+      r3m() {
+        var tmp = this.j3m_1;
+        if (!(tmp == null))
+          return tmp;
+        else {
+          throwUninitializedPropertyAccessException('shouldRetryOnException');
+        }
+      }
+      s3m() {
+        var tmp = this.k3m_1;
+        if (!(tmp == null))
+          return tmp;
+        else {
+          throwUninitializedPropertyAccessException('delayMillis');
+        }
+      }
+      t3m(maxRetries, block) {
+        if (!(maxRetries === -1))
+          this.n3m_1 = maxRetries;
+        this.i3m_1 = block;
+      }
+      u3m(maxRetries, block) {
+        if (!(maxRetries === -1))
+          this.n3m_1 = maxRetries;
+        this.j3m_1 = block;
+      }
+      v3m(maxRetries, retryOnTimeout) {
+        this.u3m(maxRetries, HttpRequestRetryConfig$retryOnException$lambda(retryOnTimeout));
+      }
+      w3m(maxRetries, retryOnTimeout, $super) {
+        maxRetries = maxRetries === VOID ? -1 : maxRetries;
+        retryOnTimeout = retryOnTimeout === VOID ? false : retryOnTimeout;
+        var tmp;
+        if ($super === VOID) {
+          this.v3m(maxRetries, retryOnTimeout);
+          tmp = Unit_instance;
+        } else {
+          tmp = $super.v3m.call(this, maxRetries, retryOnTimeout);
+        }
+        return tmp;
+      }
+      x3m(maxRetries) {
+        this.t3m(maxRetries, HttpRequestRetryConfig$retryOnServerErrors$lambda);
+      }
+      o3m(maxRetries) {
+        this.x3m(maxRetries);
+        this.w3m(maxRetries);
+      }
+      y3m(respectRetryAfterHeader, block) {
+        var tmp = this;
+        tmp.k3m_1 = HttpRequestRetryConfig$delayMillis$lambda(respectRetryAfterHeader, block);
+      }
+      z3m(base, baseDelayMs, maxDelayMs, randomizationMs, respectRetryAfterHeader) {
+        // Inline function 'kotlin.check' call
+        if (!(base > 0)) {
+          throw IllegalStateException().o('Check failed.');
+        }
+        // Inline function 'kotlin.check' call
+        if (!(compare(baseDelayMs, new (Long())(0, 0)) > 0)) {
+          throw IllegalStateException().o('Check failed.');
+        }
+        // Inline function 'kotlin.check' call
+        if (!(compare(maxDelayMs, new (Long())(0, 0)) > 0)) {
+          throw IllegalStateException().o('Check failed.');
+        }
+        // Inline function 'kotlin.check' call
+        if (!(compare(randomizationMs, new (Long())(0, 0)) >= 0)) {
+          throw IllegalStateException().o('Check failed.');
+        }
+        this.y3m(respectRetryAfterHeader, HttpRequestRetryConfig$exponentialDelay$lambda(base, baseDelayMs, maxDelayMs, this, randomizationMs));
+      }
+      p3m(base, baseDelayMs, maxDelayMs, randomizationMs, respectRetryAfterHeader, $super) {
+        base = base === VOID ? 2.0 : base;
+        baseDelayMs = baseDelayMs === VOID ? new (Long())(1000, 0) : baseDelayMs;
+        maxDelayMs = maxDelayMs === VOID ? new (Long())(60000, 0) : maxDelayMs;
+        randomizationMs = randomizationMs === VOID ? new (Long())(1000, 0) : randomizationMs;
+        respectRetryAfterHeader = respectRetryAfterHeader === VOID ? true : respectRetryAfterHeader;
+        var tmp;
+        if ($super === VOID) {
+          this.z3m(base, baseDelayMs, maxDelayMs, randomizationMs, respectRetryAfterHeader);
+          tmp = Unit_instance;
+        } else {
+          tmp = $super.z3m.call(this, base, baseDelayMs, maxDelayMs, randomizationMs, respectRetryAfterHeader);
+        }
+        return tmp;
+      }
+    }
+    initMetadataForClass($, 'HttpRequestRetryConfig', HttpRequestRetryConfig);
+    HttpRequestRetryConfigClass = $;
+  }
+  return HttpRequestRetryConfigClass;
+}
+var HttpRetryShouldRetryContextClass;
+function HttpRetryShouldRetryContext() {
+  if (HttpRetryShouldRetryContextClass === VOID) {
+    class $ {
+      constructor(retryCount) {
+        this.a3n_1 = retryCount;
+      }
+    }
+    initMetadataForClass($, 'HttpRetryShouldRetryContext');
+    HttpRetryShouldRetryContextClass = $;
+  }
+  return HttpRetryShouldRetryContextClass;
+}
+var HttpRetryDelayContextClass;
+function HttpRetryDelayContext() {
+  if (HttpRetryDelayContextClass === VOID) {
+    class $ {
+      constructor(request, response, cause) {
+        this.f3m_1 = request;
+        this.g3m_1 = response;
+        this.h3m_1 = cause;
+      }
+    }
+    initMetadataForClass($, 'HttpRetryDelayContext');
+    HttpRetryDelayContextClass = $;
+  }
+  return HttpRetryDelayContextClass;
+}
+var HttpRetryModifyRequestContextClass;
+function HttpRetryModifyRequestContext() {
+  if (HttpRetryModifyRequestContextClass === VOID) {
+    class $ {
+      constructor(request, response, cause, retryCount) {
+        this.b3n_1 = request;
+        this.c3n_1 = response;
+        this.d3n_1 = cause;
+        this.e3n_1 = retryCount;
+      }
+    }
+    initMetadataForClass($, 'HttpRetryModifyRequestContext');
+    HttpRetryModifyRequestContextClass = $;
+  }
+  return HttpRetryModifyRequestContextClass;
+}
+function *_generator_throwOnInvalidResponseBody__kuiszx(_this__u8e3s4, $completion) {
+  var tmp;
+  if (get_isSaved(_this__u8e3s4)) {
+    // Inline function 'kotlin.run' call
+    var $this$run = _this__u8e3s4.b3e();
+    var tmp_0;
+    try {
+      var tmp_1 = $this$run.h1t(VOID, $completion);
+      if (tmp_1 === get_COROUTINE_SUSPENDED())
+        tmp_1 = yield tmp_1;
+      tmp_0 = tmp_1;
+    }finally {
+      // Inline function 'kotlin.runCatching' call
+      var tmp_2;
+      try {
+        cancel($this$run);
+        // Inline function 'kotlin.Companion.success' call
+        tmp_2 = _Result___init__impl__xyqfz8(Unit_instance);
+      } catch ($p) {
+        var tmp_3;
+        if ($p instanceof Error) {
+          var e = $p;
+          // Inline function 'kotlin.Companion.failure' call
+          tmp_3 = _Result___init__impl__xyqfz8(createFailure(e));
+        } else {
+          throw $p;
+        }
+        tmp_2 = tmp_3;
+      }
+      // Inline function 'kotlin.onFailure' call
+      var this_0 = tmp_2;
+      var tmp0_safe_receiver = Result__exceptionOrNull_impl_p6xea9(this_0);
+      if (tmp0_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        get_LOGGER().b2o('Failed to close response body channel', tmp0_safe_receiver);
+      }
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+}
+function throwOnInvalidResponseBody(_this__u8e3s4, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_throwOnInvalidResponseBody__kuiszx.bind(VOID, _this__u8e3s4), $completion);
+}
+function isTimeoutException(_this__u8e3s4) {
+  _init_properties_HttpRequestRetry_kt__h4xjtt();
+  var exception = unwrapCancellationException(_this__u8e3s4);
+  var tmp;
+  var tmp_0;
+  if (exception instanceof HttpRequestTimeoutException()) {
+    tmp_0 = true;
+  } else {
+    tmp_0 = exception instanceof ConnectTimeoutException();
+  }
+  if (tmp_0) {
+    tmp = true;
+  } else {
+    tmp = exception instanceof SocketTimeoutException();
+  }
+  return tmp;
+}
+function HttpRequestRetryConfig$_init_$ref_mqbboi() {
+  var l = () => new (HttpRequestRetryConfig())();
+  l.callableName = '<init>';
+  return l;
+}
+function HttpRequestRetry$lambda($this$createClientPlugin) {
+  _init_properties_HttpRequestRetry_kt__h4xjtt();
+  var shouldRetry = $this$createClientPlugin.a3i_1.q3m();
+  var shouldRetryOnException = $this$createClientPlugin.a3i_1.r3m();
+  var delayMillis = $this$createClientPlugin.a3i_1.s3m();
+  var delay = $this$createClientPlugin.a3i_1.l3m_1;
+  var maxRetries = $this$createClientPlugin.a3i_1.n3m_1;
+  var modifyRequest = $this$createClientPlugin.a3i_1.m3m_1;
+  $this$createClientPlugin.f3n(HttpRequestRetry$lambda$slambda_0(maxRetries));
+  var tmp = Send_instance;
+  $this$createClientPlugin.d3i(tmp, HttpRequestRetry$lambda$slambda_2(shouldRetry, shouldRetryOnException, maxRetries, delayMillis, modifyRequest, $this$createClientPlugin, delay));
+  return Unit_instance;
+}
+function HttpRequestRetry$lambda$prepareRequest$lambda($subRequest) {
+  return (cause) => {
+    var tmp = $subRequest.v3b_1;
+    var subRequestJob = isInterface(tmp, CompletableJob()) ? tmp : THROW_CCE();
+    if (cause == null) {
+      subRequestJob.r13();
+    } else {
+      subRequestJob.q13(cause);
+    }
+    return Unit_instance;
+  };
+}
+function invoke$shouldRetry(retryCount, maxRetries, shouldRetry, call) {
+  return retryCount < maxRetries && shouldRetry(new (HttpRetryShouldRetryContext())(retryCount + 1 | 0), call.l3d(), call.o3b());
+}
+function invoke$shouldRetryOnException(retryCount, maxRetries, shouldRetry, subRequest, cause) {
+  return retryCount < maxRetries && shouldRetry(new (HttpRetryShouldRetryContext())(retryCount + 1 | 0), subRequest, cause);
+}
+function invoke$prepareRequest(request) {
+  var subRequest = (new (HttpRequestBuilder())()).g3n(request);
+  var tmp = request.v3b_1;
+  tmp.lx(HttpRequestRetry$lambda$prepareRequest$lambda(subRequest));
+  return subRequest;
+}
+var HttpRequestRetry$lambda$slambdaClass;
+function HttpRequestRetry$lambda$slambda() {
+  if (HttpRequestRetry$lambda$slambdaClass === VOID) {
+    class $ {
+      constructor($maxRetries) {
+        this.h3n_1 = $maxRetries;
+      }
+      i3n($this$onRequest, request, _unused_var__etf5q3, $completion) {
+        var tmp0_elvis_lhs = request.w3b_1.p2h(get_MaxRetriesPerRequestAttributeKey());
+        var maxRetriesValue = tmp0_elvis_lhs == null ? this.h3n_1 : tmp0_elvis_lhs;
+        request.w3b_1.r2h(get_MaxRetriesPerRequestAttributeKey(), maxRetriesValue);
+        return Unit_instance;
+      }
+      j3n(p1, p2, p3, $completion) {
+        var tmp = p1 instanceof OnRequestContext() ? p1 : THROW_CCE();
+        var tmp_0 = p2 instanceof HttpRequestBuilder() ? p2 : THROW_CCE();
+        return this.i3n(tmp, tmp_0, !(p3 == null) ? p3 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [3]);
+    HttpRequestRetry$lambda$slambdaClass = $;
+  }
+  return HttpRequestRetry$lambda$slambdaClass;
+}
+function HttpRequestRetry$lambda$slambda_0($maxRetries) {
+  var i = new (HttpRequestRetry$lambda$slambda())($maxRetries);
+  var l = ($this$onRequest, request, _unused_var__etf5q3, $completion) => i.i3n($this$onRequest, request, _unused_var__etf5q3, $completion);
+  l.$arity = 3;
+  return l;
+}
+function *_generator_invoke__zhh2q8_0($this, $this$on, request, $completion) {
+  var retryCount = 0;
+  var tmp0_elvis_lhs = request.w3b_1.p2h(get_ShouldRetryPerRequestAttributeKey());
+  var shouldRetry = tmp0_elvis_lhs == null ? $this.k3n_1 : tmp0_elvis_lhs;
+  var tmp1_elvis_lhs = request.w3b_1.p2h(get_ShouldRetryOnExceptionPerRequestAttributeKey());
+  var shouldRetryOnException = tmp1_elvis_lhs == null ? $this.l3n_1 : tmp1_elvis_lhs;
+  var tmp2_elvis_lhs = request.w3b_1.p2h(get_MaxRetriesPerRequestAttributeKey());
+  var maxRetries = tmp2_elvis_lhs == null ? $this.m3n_1 : tmp2_elvis_lhs;
+  var tmp3_elvis_lhs = request.w3b_1.p2h(get_RetryDelayPerRequestAttributeKey());
+  var delayMillis = tmp3_elvis_lhs == null ? $this.n3n_1 : tmp3_elvis_lhs;
+  var tmp4_elvis_lhs = request.w3b_1.p2h(get_ModifyRequestPerRequestAttributeKey());
+  var modifyRequest = tmp4_elvis_lhs == null ? $this.o3n_1 : tmp4_elvis_lhs;
+  var call;
+  var lastRetryData = null;
+  $l$loop: while (true) {
+    var subRequest = invoke$prepareRequest(request);
+    var tmp;
+    try {
+      if (!(lastRetryData == null)) {
+        var modifyRequestContext = new (HttpRetryModifyRequestContext())(request, lastRetryData.c3m_1, lastRetryData.d3m_1, lastRetryData.b3m_1);
+        modifyRequest(modifyRequestContext, subRequest);
+      }
+      var tmp_0 = $this$on.r3k(subRequest, $completion);
+      if (tmp_0 === get_COROUTINE_SUSPENDED())
+        tmp_0 = yield tmp_0;
+      call = tmp_0;
+      if (!invoke$shouldRetry(retryCount, maxRetries, shouldRetry, call)) {
+        var tmp_1 = throwOnInvalidResponseBody(call.o3b(), $completion);
+        if (tmp_1 === get_COROUTINE_SUSPENDED())
+          tmp_1 = yield tmp_1;
+        break $l$loop;
+      }
+      retryCount = retryCount + 1 | 0;
+      tmp = new (HttpRetryEventData())(subRequest, retryCount, call.o3b(), null);
+    } catch ($p) {
+      var tmp_2;
+      if ($p instanceof Error) {
+        var cause = $p;
+        if (!invoke$shouldRetryOnException(retryCount, maxRetries, shouldRetryOnException, subRequest, cause)) {
+          throw cause;
+        }
+        retryCount = retryCount + 1 | 0;
+        tmp_2 = new (HttpRetryEventData())(subRequest, retryCount, null, cause);
+      } else {
+        throw $p;
+      }
+      tmp = tmp_2;
+    }
+    var retryData = tmp;
+    lastRetryData = retryData;
+    $this.p3n_1.z3h_1.g3b_1.e2o(get_HttpRequestRetryEvent(), lastRetryData);
+    var delayContext = new (HttpRetryDelayContext())(lastRetryData.a3m_1, lastRetryData.c3m_1, lastRetryData.d3m_1);
+    var tmp_3 = $this.q3n_1(delayMillis(delayContext, retryCount), $completion);
+    if (tmp_3 === get_COROUTINE_SUSPENDED())
+      tmp_3 = yield tmp_3;
+    get_LOGGER().c2o('Retrying request ' + request.r3b_1.toString() + ' attempt: ' + retryCount);
+  }
+  return call;
+}
+var HttpRequestRetry$lambda$slambdaClass_0;
+function HttpRequestRetry$lambda$slambda_1() {
+  if (HttpRequestRetry$lambda$slambdaClass_0 === VOID) {
+    class $ {
+      constructor($shouldRetry, $shouldRetryOnException, $maxRetries, $delayMillis, $modifyRequest, $this_createClientPlugin, $delay) {
+        this.k3n_1 = $shouldRetry;
+        this.l3n_1 = $shouldRetryOnException;
+        this.m3n_1 = $maxRetries;
+        this.n3n_1 = $delayMillis;
+        this.o3n_1 = $modifyRequest;
+        this.p3n_1 = $this_createClientPlugin;
+        this.q3n_1 = $delay;
+      }
+      t3k($this$on, request, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8_0.bind(VOID, this, $this$on, request), $completion);
+      }
+      ee(p1, p2, $completion) {
+        var tmp = p1 instanceof Sender() ? p1 : THROW_CCE();
+        return this.t3k(tmp, p2 instanceof HttpRequestBuilder() ? p2 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [2]);
+    HttpRequestRetry$lambda$slambdaClass_0 = $;
+  }
+  return HttpRequestRetry$lambda$slambdaClass_0;
+}
+function HttpRequestRetry$lambda$slambda_2($shouldRetry, $shouldRetryOnException, $maxRetries, $delayMillis, $modifyRequest, $this_createClientPlugin, $delay) {
+  var i = new (HttpRequestRetry$lambda$slambda_1())($shouldRetry, $shouldRetryOnException, $maxRetries, $delayMillis, $modifyRequest, $this_createClientPlugin, $delay);
+  var l = ($this$on, request, $completion) => i.t3k($this$on, request, $completion);
+  l.$arity = 2;
+  return l;
+}
+var properties_initialized_HttpRequestRetry_kt_jcpv6l;
+function _init_properties_HttpRequestRetry_kt__h4xjtt() {
+  if (!properties_initialized_HttpRequestRetry_kt_jcpv6l) {
+    properties_initialized_HttpRequestRetry_kt_jcpv6l = true;
+    LOGGER = KtorSimpleLogger('io.ktor.client.plugins.HttpRequestRetry');
+    HttpRequestRetryEvent = new (EventDefinition())();
+    var tmp = HttpRequestRetryConfig$_init_$ref_mqbboi();
+    HttpRequestRetry = createClientPlugin('RetryFeature', tmp, HttpRequestRetry$lambda);
+    // Inline function 'io.ktor.util.AttributeKey' call
+    var name = 'MaxRetriesPerRequestAttributeKey';
+    // Inline function 'io.ktor.util.reflect.typeInfo' call
+    var tmp_0 = PrimitiveClasses_getInstance().hg();
+    // Inline function 'io.ktor.util.reflect.typeOfOrNull' call
+    var tmp_1;
+    try {
+      tmp_1 = createKType(PrimitiveClasses_getInstance().hg(), arrayOf([]), false);
+    } catch ($p) {
+      var tmp_2;
+      if ($p instanceof Error) {
+        var _unused_var__etf5q3 = $p;
+        tmp_2 = null;
+      } else {
+        throw $p;
+      }
+      tmp_1 = tmp_2;
+    }
+    var tmp$ret$0 = tmp_1;
+    var tmp$ret$1 = new (TypeInfo())(tmp_0, tmp$ret$0);
+    MaxRetriesPerRequestAttributeKey = new (AttributeKey())(name, tmp$ret$1);
+    // Inline function 'io.ktor.util.AttributeKey' call
+    var name_0 = 'ShouldRetryPerRequestAttributeKey';
+    // Inline function 'io.ktor.util.reflect.typeInfo' call
+    var tmp_3 = PrimitiveClasses_getInstance().functionClass(3);
+    // Inline function 'io.ktor.util.reflect.typeOfOrNull' call
+    var tmp_4;
+    try {
+      tmp_4 = createKType(PrimitiveClasses_getInstance().functionClass(3), arrayOf([createInvariantKTypeProjection(createKType(getKClass(HttpRetryShouldRetryContext()), arrayOf([]), false)), createInvariantKTypeProjection(createKType(getKClass(HttpRequest()), arrayOf([]), false)), createInvariantKTypeProjection(createKType(getKClass(HttpResponse()), arrayOf([]), false)), createInvariantKTypeProjection(createKType(PrimitiveClasses_getInstance().eg(), 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);
+    ShouldRetryPerRequestAttributeKey = new (AttributeKey())(name_0, tmp$ret$1_0);
+    // Inline function 'io.ktor.util.AttributeKey' call
+    var name_1 = 'ShouldRetryOnExceptionPerRequestAttributeKey';
+    // Inline function 'io.ktor.util.reflect.typeInfo' call
+    var tmp_6 = PrimitiveClasses_getInstance().functionClass(3);
+    // Inline function 'io.ktor.util.reflect.typeOfOrNull' call
+    var tmp_7;
+    try {
+      tmp_7 = createKType(PrimitiveClasses_getInstance().functionClass(3), arrayOf([createInvariantKTypeProjection(createKType(getKClass(HttpRetryShouldRetryContext()), arrayOf([]), false)), createInvariantKTypeProjection(createKType(getKClass(HttpRequestBuilder()), arrayOf([]), false)), createInvariantKTypeProjection(createKType(PrimitiveClasses_getInstance().ng(), arrayOf([]), false)), createInvariantKTypeProjection(createKType(PrimitiveClasses_getInstance().eg(), arrayOf([]), false))]), false);
+    } catch ($p) {
+      var tmp_8;
+      if ($p instanceof Error) {
+        var _unused_var__etf5q3_1 = $p;
+        tmp_8 = null;
+      } else {
+        throw $p;
+      }
+      tmp_7 = tmp_8;
+    }
+    var tmp$ret$0_1 = tmp_7;
+    var tmp$ret$1_1 = new (TypeInfo())(tmp_6, tmp$ret$0_1);
+    ShouldRetryOnExceptionPerRequestAttributeKey = new (AttributeKey())(name_1, tmp$ret$1_1);
+    // Inline function 'io.ktor.util.AttributeKey' call
+    var name_2 = 'ModifyRequestPerRequestAttributeKey';
+    // Inline function 'io.ktor.util.reflect.typeInfo' call
+    var tmp_9 = PrimitiveClasses_getInstance().functionClass(2);
+    // Inline function 'io.ktor.util.reflect.typeOfOrNull' call
+    var tmp_10;
+    try {
+      tmp_10 = createKType(PrimitiveClasses_getInstance().functionClass(2), arrayOf([createInvariantKTypeProjection(createKType(getKClass(HttpRetryModifyRequestContext()), arrayOf([]), false)), createInvariantKTypeProjection(createKType(getKClass(HttpRequestBuilder()), arrayOf([]), false)), createInvariantKTypeProjection(createKType(getKClass(Unit()), arrayOf([]), false))]), false);
+    } catch ($p) {
+      var tmp_11;
+      if ($p instanceof Error) {
+        var _unused_var__etf5q3_2 = $p;
+        tmp_11 = null;
+      } else {
+        throw $p;
+      }
+      tmp_10 = tmp_11;
+    }
+    var tmp$ret$0_2 = tmp_10;
+    var tmp$ret$1_2 = new (TypeInfo())(tmp_9, tmp$ret$0_2);
+    ModifyRequestPerRequestAttributeKey = new (AttributeKey())(name_2, tmp$ret$1_2);
+    // Inline function 'io.ktor.util.AttributeKey' call
+    var name_3 = 'RetryDelayPerRequestAttributeKey';
+    // Inline function 'io.ktor.util.reflect.typeInfo' call
+    var tmp_12 = PrimitiveClasses_getInstance().functionClass(2);
+    // Inline function 'io.ktor.util.reflect.typeOfOrNull' call
+    var tmp_13;
+    try {
+      tmp_13 = createKType(PrimitiveClasses_getInstance().functionClass(2), arrayOf([createInvariantKTypeProjection(createKType(getKClass(HttpRetryDelayContext()), arrayOf([]), false)), createInvariantKTypeProjection(createKType(PrimitiveClasses_getInstance().hg(), arrayOf([]), false)), createInvariantKTypeProjection(createKType(getKClass(Long()), arrayOf([]), false))]), false);
+    } catch ($p) {
+      var tmp_14;
+      if ($p instanceof Error) {
+        var _unused_var__etf5q3_3 = $p;
+        tmp_14 = null;
+      } else {
+        throw $p;
+      }
+      tmp_13 = tmp_14;
+    }
+    var tmp$ret$0_3 = tmp_13;
+    var tmp$ret$1_3 = new (TypeInfo())(tmp_12, tmp$ret$0_3);
+    RetryDelayPerRequestAttributeKey = new (AttributeKey())(name_3, tmp$ret$1_3);
+  }
+}
+//region block: exports
+export {
+  get_HttpRequestRetry as get_HttpRequestRetry3m7x7jck45t4l,
+  get_MaxRetriesPerRequestAttributeKey as get_MaxRetriesPerRequestAttributeKey13gphm9kuo852,
+};
+//endregion
+
+//# sourceMappingURL=HttpRequestRetry.mjs.map