@attocash/commons-js 5.0.0

package/ktor-ktor-utils/io/ktor/util/internal/LockFreeLinkedList.mjs

@@ -0,0 +1,100 @@
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CONDITION_FALSE;
+var ALREADY_REMOVED;
+var LIST_EMPTY;
+var REMOVE_PREPARED;
+var NO_DECISION;
+var SymbolClass;
+function Symbol() {
+  if (SymbolClass === VOID) {
+    class $ {
+      constructor(symbol) {
+        this.l3u_1 = symbol;
+      }
+      toString() {
+        return this.l3u_1;
+      }
+    }
+    initMetadataForClass($, 'Symbol');
+    SymbolClass = $;
+  }
+  return SymbolClass;
+}
+var LockFreeLinkedListNodeClass;
+function LockFreeLinkedListNode() {
+  if (LockFreeLinkedListNodeClass === VOID) {
+    class $ {
+      c2d() {
+        // Inline function 'kotlinx.atomicfu.loop' call
+        var this_0 = this.m3u_1;
+        while (true) {
+          var next = this_0.kotlinx$atomicfu$value;
+          if (!(next instanceof OpDescriptor()))
+            return next;
+          next.n3u(this);
+        }
+      }
+      o3u() {
+        return unwrap(this.c2d());
+      }
+    }
+    initMetadataForClass($, 'LockFreeLinkedListNode');
+    LockFreeLinkedListNodeClass = $;
+  }
+  return LockFreeLinkedListNodeClass;
+}
+var RemovedClass;
+function Removed() {
+  if (RemovedClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'Removed');
+    RemovedClass = $;
+  }
+  return RemovedClass;
+}
+var OpDescriptorClass;
+function OpDescriptor() {
+  if (OpDescriptorClass === VOID) {
+    class $ {}
+    initMetadataForClass($, 'OpDescriptor');
+    OpDescriptorClass = $;
+  }
+  return OpDescriptorClass;
+}
+function unwrap(_this__u8e3s4) {
+  _init_properties_LockFreeLinkedList_kt__wekxce();
+  var tmp0_safe_receiver = _this__u8e3s4 instanceof Removed() ? _this__u8e3s4 : null;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p3u_1;
+  var tmp;
+  if (tmp1_elvis_lhs == null) {
+    tmp = _this__u8e3s4 instanceof LockFreeLinkedListNode() ? _this__u8e3s4 : THROW_CCE();
+  } else {
+    tmp = tmp1_elvis_lhs;
+  }
+  return tmp;
+}
+var properties_initialized_LockFreeLinkedList_kt_lnmdgw;
+function _init_properties_LockFreeLinkedList_kt__wekxce() {
+  if (!properties_initialized_LockFreeLinkedList_kt_lnmdgw) {
+    properties_initialized_LockFreeLinkedList_kt_lnmdgw = true;
+    CONDITION_FALSE = new (Symbol())('CONDITION_FALSE');
+    ALREADY_REMOVED = new (Symbol())('ALREADY_REMOVED');
+    LIST_EMPTY = new (Symbol())('LIST_EMPTY');
+    REMOVE_PREPARED = new (Symbol())('REMOVE_PREPARED');
+    NO_DECISION = new (Symbol())('NO_DECISION');
+  }
+}
+//region block: exports
+export {
+  LockFreeLinkedListNode as LockFreeLinkedListNode1f5fxflchw0ko,
+};
+//endregion
+
+//# sourceMappingURL=LockFreeLinkedList.mjs.map

package/ktor-ktor-utils/io/ktor/util/internal/LockFreeLinkedList.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-utils/common/src/io/ktor/util/internal/LockFreeLinkedList.kt","../../../../../../../../../../../../opt/buildAgent/work/711ef0d9c7c28b00/atomicfu/src/commonMain/kotlin/kotlinx/atomicfu/AtomicFU.common.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["symbol","toString","<get-next>","<get-nextNode>","unwrap","<this>","<init properties LockFreeLinkedList.kt>"],"mappings":";;;;;;;;;;;;;;;;;kBAyDqBA,M;QAAA,mB;;cACjBC,CAAAA,EAAkC;A,QAAM,OAAN,IAAM,CAAN,K;MAAK,C;;;;;;;;;;;SAiJnCC,CAAAA,EAAM;A;qBACF,I,CAAA,K;eCnDD,I,EAAM;A,qBACF,M,CAAA,sB;UDmDK,sC;YAAuB,OAAO,I;UAClC,IAAK,KAAQ,IAAR,C;QCnDjB,C;MDqDI,C;SAGsBC,CAAAA,EAAQ;A,QAAa,OAAR,OAAL,UAAK,C;MAAO,C;;;;;;;;;;;;;;;;;;;;;;;;;eAwlBlDC,CACaC,aADbD,EACkC;A;MAAC,8E;MAAD,iBAAoB,oCAAnB,kBAAmB,M;;EAApB,2B;UAA2B,a,uCAAA,a;;UAA3B,c;;EAAuC,U;AAAD,C;;uDA5yBxEE,CAAAA,E;;;qCA0B2C,iB;qCAGA,iB;gCAGL,Y;qCAEI,iB;iCA8CJ,a;;C;;;;;"}

package/ktor-ktor-utils/io/ktor/util/logging/KtorSimpleLoggerJs.mjs

@@ -0,0 +1,137 @@
+import { PlatformUtils_getInstance350nj2wi6ds9r as PlatformUtils_getInstance } from '../PlatformUtils.mjs';
+import {
+  Companion_instance2oawqq9qiaris as Companion_instance,
+  _Result___init__impl__xyqfz83hut4nr3dfvi3 as _Result___init__impl__xyqfz8,
+  createFailure8paxfkfa5dc7 as createFailure,
+  _Result___get_value__impl__bjfvqg2ei4op8d4d2m as _Result___get_value__impl__bjfvqg,
+  _Result___get_isFailure__impl__jpirivrr0d11rbi6gb as _Result___get_isFailure__impl__jpiriv,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/Result.mjs';
+import {
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import {
+  get_entries3rhsgvbgx7tis as get_entries,
+  LogLevel_INFO_getInstance3hkfl5alteyab as LogLevel_INFO_getInstance,
+  LogLevel_TRACE_getInstanceoetpm2i6d0wa as LogLevel_TRACE_getInstance,
+  LogLevel_WARN_getInstance2n4u8k0gol84p as LogLevel_WARN_getInstance,
+  LogLevel_DEBUG_getInstance3ffzvcje6l6kj as LogLevel_DEBUG_getInstance,
+} from './LoggerJs.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function KtorSimpleLogger(name) {
+  return new (KtorSimpleLogger$1())();
+}
+function getKtorLogLevel() {
+  return process.env.KTOR_LOG_LEVEL;
+}
+var KtorSimpleLogger$1Class;
+function KtorSimpleLogger$1() {
+  if (KtorSimpleLogger$1Class === VOID) {
+    class $ {
+      constructor() {
+        var tmp = this;
+        var tmp_0;
+        switch (PlatformUtils_getInstance().k3s_1 || PlatformUtils_getInstance().j3s_1) {
+          case true:
+            // Inline function 'kotlin.runCatching' call
+
+            var tmp_1;
+            try {
+              // Inline function 'kotlin.Companion.success' call
+              var value = getKtorLogLevel();
+              tmp_1 = _Result___init__impl__xyqfz8(value);
+            } catch ($p) {
+              var tmp_2;
+              if ($p instanceof Error) {
+                var e = $p;
+                // Inline function 'kotlin.Companion.failure' call
+                tmp_2 = _Result___init__impl__xyqfz8(createFailure(e));
+              } else {
+                throw $p;
+              }
+              tmp_1 = tmp_2;
+            }
+
+            // Inline function 'kotlin.Result.getOrNull' call
+
+            var this_0 = tmp_1;
+            var tmp_3;
+            if (_Result___get_isFailure__impl__jpiriv(this_0)) {
+              tmp_3 = null;
+            } else {
+              var tmp_4 = _Result___get_value__impl__bjfvqg(this_0);
+              tmp_3 = (tmp_4 == null ? true : !(tmp_4 == null)) ? tmp_4 : THROW_CCE();
+            }
+
+            var tmp1_safe_receiver = tmp_3;
+            var tmp_5;
+            if (tmp1_safe_receiver == null) {
+              tmp_5 = null;
+            } else {
+              // Inline function 'kotlin.let' call
+              var tmp0 = get_entries();
+              var tmp$ret$6;
+              $l$block: {
+                // Inline function 'kotlin.collections.firstOrNull' call
+                var _iterator__ex2g4s = tmp0.d1();
+                while (_iterator__ex2g4s.e1()) {
+                  var element = _iterator__ex2g4s.f1();
+                  if (element.g3_1 === tmp1_safe_receiver) {
+                    tmp$ret$6 = element;
+                    break $l$block;
+                  }
+                }
+                tmp$ret$6 = null;
+              }
+              tmp_5 = tmp$ret$6;
+            }
+
+            var tmp2_elvis_lhs = tmp_5;
+            tmp_0 = tmp2_elvis_lhs == null ? LogLevel_INFO_getInstance() : tmp2_elvis_lhs;
+            break;
+          case false:
+            tmp_0 = LogLevel_TRACE_getInstance();
+            break;
+          default:
+            noWhenBranchMatchedException();
+            break;
+        }
+        tmp.o3x_1 = tmp_0;
+      }
+      p3x() {
+        return this.o3x_1;
+      }
+      q3x(message) {
+        if (this.o3x_1.k3(LogLevel_WARN_getInstance()) > 0)
+          return Unit_instance;
+        console.warn(message);
+      }
+      r3x(message, cause) {
+        if (this.o3x_1.k3(LogLevel_DEBUG_getInstance()) > 0)
+          return Unit_instance;
+        console.debug('DEBUG: ' + message + ', cause: ' + cause.toString());
+      }
+      s3x(message) {
+        if (this.o3x_1.k3(LogLevel_TRACE_getInstance()) > 0)
+          return Unit_instance;
+        console.debug('TRACE: ' + message);
+      }
+    }
+    initMetadataForClass($);
+    KtorSimpleLogger$1Class = $;
+  }
+  return KtorSimpleLogger$1Class;
+}
+//region block: exports
+export {
+  KtorSimpleLogger as KtorSimpleLogger1xdphsp5l4e48,
+};
+//endregion
+
+//# sourceMappingURL=KtorSimpleLoggerJs.mjs.map

package/ktor-ktor-utils/io/ktor/util/logging/KtorSimpleLoggerJs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-utils/jsAndWasmShared/src/io/ktor/util/logging/KtorSimpleLoggerJs.kt","src/kotlin/util/Result.kt","common/src/generated/_Collections.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["KtorSimpleLogger","name","getKtorLogLevel","e","element","<get-level>","warn","message","debug","cause","trace"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;yBAUAA,CACmCC,IADnCD,EAC2D;A,EA4D1D,mC;AAAD,C;wBA/DAE,CAAAA,EAAyC;A,EAAgC,OAA7B,OAA6B,CAArB,GAAqB,CAAhC,c;AAA+B,C;;;;;;kBAKrC,I;;QAAA,oCAAoB,KAApB,gCAA6C,KAA7C,C;eAC3B,I;;;;YC6IG,I;;0BD7ImB,iB;sBC8ElB,6BAAO,KAAP,C;;;;oBAiECC,M;;wBAxDD,6BAAO,cAyDI,CAzDJ,CAAP,C;;;;;;;;;yBAsDD,K;;YAxGC,kD;sBAAa,I;;0BACL,yC;kEAAA,K;;;gBDrCP,qBCmCL,K;;YDlCM,+B;sBAAA,I;;;yBAAmC,a;;;;oBEsR7B,6B;uBAAA,sB,EAAM;A,sBAAjBC,UAAW,sB;kBAAU,IAAU,OFtR+B,CAAG,IAAH,KAFvD,kBEwRc,C;oBAAoB,YAAO,O;;;gBAAM,C;gBAC3D,YAAO,I;;sBFvR8C,S;;;gBAFzC,sB;oBAAA,yBAGQ,2BAHR,iB;;eAKR,K;oBAAkB,4B;;;YANS,8B;;;QAAA,iB;;SAA/BC,CAAAA,EAAA;A,QAAA,iB;MAA2B,C;SAmB3BC,CAAkBC,OAAlBD,EAAmC;A,QAC3B,kBAAiB,2BAAjB,M;UAAuB,oB;QAC3B,OAAQ,MAAK,OAAL,C;MACZ,C;SAsBAE,CAAmBD,O,EAAiBE,KAApCD,EAAsD;A,QAC9C,kBAAiB,4BAAjB,M;UAAwB,oB;QAC5B,OAAQ,OAAO,SAAP,GAAe,OAAf,GAAsB,WAAtB,GAAgC,KAAhC,Y;MACZ,C;SAEAE,CAAmBH,OAAnBG,EAAoC;A,QAC5B,kBAAiB,4BAAjB,M;UAAwB,oB;QAC5B,OAAQ,OAAO,SAAP,GAAe,OAAf,C;MACZ,C;;;;;;;;;;;"}

package/ktor-ktor-utils/io/ktor/util/logging/LoggerJs.mjs

@@ -0,0 +1,84 @@
+import { enumEntries20mr21zbe3az4 as enumEntries } from '../../../../../kotlin-kotlin-stdlib/kotlin/enums/EnumEntries.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { Enum3alwj03lh1n41 as Enum } from '../../../../../kotlin-kotlin-stdlib/kotlin/Enum.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var LogLevel_TRACE_instance;
+var LogLevel_DEBUG_instance;
+var LogLevel_INFO_instance;
+var LogLevel_WARN_instance;
+var LogLevel_ERROR_instance;
+var LogLevel_NONE_instance;
+function values() {
+  return [LogLevel_TRACE_getInstance(), LogLevel_DEBUG_getInstance(), LogLevel_INFO_getInstance(), LogLevel_WARN_getInstance(), LogLevel_ERROR_getInstance(), LogLevel_NONE_getInstance()];
+}
+function get_entries() {
+  if ($ENTRIES == null)
+    $ENTRIES = enumEntries(values());
+  return $ENTRIES;
+}
+var LogLevel_entriesInitialized;
+function LogLevel_initEntries() {
+  if (LogLevel_entriesInitialized)
+    return Unit_instance;
+  LogLevel_entriesInitialized = true;
+  LogLevel_TRACE_instance = new (LogLevel())('TRACE', 0);
+  LogLevel_DEBUG_instance = new (LogLevel())('DEBUG', 1);
+  LogLevel_INFO_instance = new (LogLevel())('INFO', 2);
+  LogLevel_WARN_instance = new (LogLevel())('WARN', 3);
+  LogLevel_ERROR_instance = new (LogLevel())('ERROR', 4);
+  LogLevel_NONE_instance = new (LogLevel())('NONE', 5);
+}
+var $ENTRIES;
+var LogLevelClass;
+function LogLevel() {
+  if (LogLevelClass === VOID) {
+    class $ extends Enum() {}
+    initMetadataForClass($, 'LogLevel');
+    LogLevelClass = $;
+  }
+  return LogLevelClass;
+}
+function get_isTraceEnabled(_this__u8e3s4) {
+  return _this__u8e3s4.p3x().k3(LogLevel_TRACE_getInstance()) <= 0;
+}
+function LogLevel_TRACE_getInstance() {
+  LogLevel_initEntries();
+  return LogLevel_TRACE_instance;
+}
+function LogLevel_DEBUG_getInstance() {
+  LogLevel_initEntries();
+  return LogLevel_DEBUG_instance;
+}
+function LogLevel_INFO_getInstance() {
+  LogLevel_initEntries();
+  return LogLevel_INFO_instance;
+}
+function LogLevel_WARN_getInstance() {
+  LogLevel_initEntries();
+  return LogLevel_WARN_instance;
+}
+function LogLevel_ERROR_getInstance() {
+  LogLevel_initEntries();
+  return LogLevel_ERROR_instance;
+}
+function LogLevel_NONE_getInstance() {
+  LogLevel_initEntries();
+  return LogLevel_NONE_instance;
+}
+//region block: exports
+export {
+  LogLevel_DEBUG_getInstance as LogLevel_DEBUG_getInstance3ffzvcje6l6kj,
+  LogLevel_INFO_getInstance as LogLevel_INFO_getInstance3hkfl5alteyab,
+  LogLevel_TRACE_getInstance as LogLevel_TRACE_getInstanceoetpm2i6d0wa,
+  LogLevel_WARN_getInstance as LogLevel_WARN_getInstance2n4u8k0gol84p,
+  get_entries as get_entries3rhsgvbgx7tis,
+  get_isTraceEnabled as get_isTraceEnabled82xibuu04nxp,
+};
+//endregion
+
+//# sourceMappingURL=LoggerJs.mjs.map

package/ktor-ktor-utils/io/ktor/util/logging/LoggerJs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-utils/jsAndWasmShared/src/io/ktor/util/logging/LoggerJs.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["values","<get-entries>","<get-isTraceEnabled>","<this>"],"mappings":";;;;;;;;;;;;;;;eAMAA,CAAAA,E;;C;oBAAAC,CAAAA,E;;;;C;;;;;;6CANA,O,EAAA,C;6CAAA,O,EAAA,C;4CAAA,M,EAAA,C;4CAAA,M,EAAA,C;6CAAA,O,EAAA,C;4CAAA,M,EAAA,C;;;;;;;;;;;;2BA8BiDC,CAA/BC,aAA+BD,EAAQ;A,EAAuB,OAAvB,uBAAkB,4BAAlB,M;AAAsB,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/ktor-ktor-utils/io/ktor/util/network/NetworkAddressJs.mjs

@@ -0,0 +1,16 @@
+//region block: pre-declaration
+//endregion
+function get_hostname(_this__u8e3s4) {
+  return _this__u8e3s4.t3x_1;
+}
+function get_port(_this__u8e3s4) {
+  return _this__u8e3s4.u3x_1;
+}
+//region block: exports
+export {
+  get_hostname as get_hostname2refc5bxsg8ma,
+  get_port as get_port2dtziv0g8lem0,
+};
+//endregion
+
+//# sourceMappingURL=NetworkAddressJs.mjs.map

package/ktor-ktor-utils/io/ktor/util/network/NetworkAddressJs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-utils/jsAndWasmShared/src/io/ktor/util/network/NetworkAddressJs.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-hostname>","<this>","<get-port>"],"mappings":";;qBA4BIA,CADcC,aACdD,EAAQ;A,EAAQ,OAAR,aAAQ,CAAR,K;AAAO,C;iBAgBfE,CADcD,aACdC,EAAQ;A,EAAI,OAAJ,aAAI,CAAJ,K;AAAG,C;;;;;"}

package/ktor-ktor-utils/io/ktor/util/pipeline/DebugPipelineContext.mjs

@@ -0,0 +1,145 @@
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import {
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { PipelineContext34fsb0mycu471 as PipelineContext } from './PipelineContext.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function proceedLoop($this, $completion) {
+  var tmp = new ($proceedLoopCOROUTINE$())($this, $completion);
+  tmp.cc_1 = Unit_instance;
+  tmp.dc_1 = null;
+  return tmp.ic();
+}
+var $proceedLoopCOROUTINE$Class;
+function $proceedLoopCOROUTINE$() {
+  if ($proceedLoopCOROUTINE$Class === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(_this__u8e3s4, resultContinuation) {
+        super(resultContinuation);
+        this.y3u_1 = _this__u8e3s4;
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 6;
+                this.ac_1 = 1;
+                continue $sm;
+              case 1:
+                this.z3u_1 = this.y3u_1.g3v_1;
+                if (this.z3u_1 === -1) {
+                  this.ac_1 = 5;
+                  continue $sm;
+                } else {
+                  this.ac_1 = 2;
+                  continue $sm;
+                }
+
+              case 2:
+                this.a3v_1 = this.y3u_1.d3v_1;
+                if (this.z3u_1 >= this.a3v_1.i1()) {
+                  this.y3u_1.h3v();
+                  this.ac_1 = 5;
+                  continue $sm;
+                } else {
+                  this.ac_1 = 3;
+                  continue $sm;
+                }
+
+              case 3:
+                this.b3v_1 = this.a3v_1.j1(this.z3u_1);
+                this.y3u_1.g3v_1 = this.z3u_1 + 1 | 0;
+                this.ac_1 = 4;
+                suspendResult = this.b3v_1(this.y3u_1, this.y3u_1.f3v_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 4:
+                this.ac_1 = 1;
+                continue $sm;
+              case 5:
+                return this.y3u_1.f3v_1;
+              case 6:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 6) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+    }
+    initMetadataForCoroutine($);
+    $proceedLoopCOROUTINE$Class = $;
+  }
+  return $proceedLoopCOROUTINE$Class;
+}
+var DebugPipelineContextClass;
+function DebugPipelineContext() {
+  if (DebugPipelineContextClass === VOID) {
+    class $ extends PipelineContext() {
+      constructor(context, interceptors, subject, coroutineContext) {
+        super(context);
+        this.d3v_1 = interceptors;
+        this.e3v_1 = coroutineContext;
+        this.f3v_1 = subject;
+        this.g3v_1 = 0;
+      }
+      s1x() {
+        return this.e3v_1;
+      }
+      i3v() {
+        return this.f3v_1;
+      }
+      h3v() {
+        this.g3v_1 = -1;
+      }
+      j3v(subject, $completion) {
+        this.f3v_1 = subject;
+        return this.k3v($completion);
+      }
+      k3v($completion) {
+        var index = this.g3v_1;
+        if (index < 0)
+          return this.f3v_1;
+        if (index >= this.d3v_1.i1()) {
+          this.h3v();
+          return this.f3v_1;
+        }
+        return proceedLoop(this, $completion);
+      }
+      l3v(initial, $completion) {
+        this.g3v_1 = 0;
+        this.f3v_1 = initial;
+        return this.k3v($completion);
+      }
+    }
+    initMetadataForClass($, 'DebugPipelineContext', VOID, VOID, VOID, [1, 0]);
+    DebugPipelineContextClass = $;
+  }
+  return DebugPipelineContextClass;
+}
+//region block: exports
+export {
+  DebugPipelineContext as DebugPipelineContext2zfnr2i0vcihk,
+};
+//endregion
+
+//# sourceMappingURL=DebugPipelineContext.mjs.map

package/ktor-ktor-utils/io/ktor/util/pipeline/DebugPipelineContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-utils/common/src/io/ktor/util/pipeline/DebugPipelineContext.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["proceedLoop","$completion","doResume","context","interceptors","subject","coroutineContext","<get-coroutineContext>","<get-subject>","finish","proceedWith","proceed","index","execute","initial"],"mappings":";;;;;;;;;;;;;oBAiEIA,CAAA,K,EAAAC,WAAAD,EAA4C;A;;;;AAiB5C,C;;;;;kBAjBA,a,EAAA,kB;;;;QAAAE,CAAAA,EAAA;A;;UAAA,I;;;;;;;;gBAEQ,kBAAY,KAAZ,CAAY,K;gBACR,mBAAS,EAAT,C;;;;;;;;;gBAGJ,kBAAmB,KAAnB,CAAmB,K;gBACf,kBAAsB,KAAb,KAAa,KAAtB,C;kBACA,gB;;;;;;;;;gBAGJ,aAAyB,mBAAa,KAAb,C;gBACpB,KAAL,KAAK,SAAQ,aAAQ,CAAhB,I;;gCACc,KAAnB,KAAmB,MAAO,KAAP,OAAa,KAAb,CAAa,KAAb,O;;;;;;;;;;4BAGhB,K,CAAA,K;;;;;;;;;;;;;;MACX,C;;;;;;;;;;;kBAjEAC,O,EACAC,Y,EACAC,O,EACAC,gB;cACoC,O;QAHpC,yB;QAEA,6B;QAKiC,oB;QAEb,c;;SAPpBC,CAAAA,EAAA;A,QAAA,iB;MAA8C,C;SAK9CC,CAAAA,EAAA;A,QAAA,iB;MAA6B,C;SAO7BC,CAAAA,EAAsB;A,QAClB,aAAQ,E;MACZ,C;SAKAC,CAAiCL,O,EAAjCJ,WAAAS,EAA8D;A,QAC1D,IAAK,SAAU,O;QACf,OAAO,qB;MACX,C;SAKAC,CAAAV,WAAAU,EAAyC;A,YACrCC,QAAY,IAAZA,CAAY,K;QACR,YAAQ,CAAR,C;UAAW,OAAO,IAAP,CAAO,K;QAElB,aAAS,IAAa,CAAb,KAAa,KAAtB,C,CAA4B;A,UAC5B,U;UACA,OAAO,IAAP,CAAO,K;QACX,C;QAEA,OAAO,8B;MACX,C;SAEAC,CAA6BC,O,EAA7Bb,WAAAY,EAA0D;A,QACtD,aAAQ,C;QACR,aAAU,O;QACV,OAAO,qB;MACX,C;;;;;;;;;;;"}

package/ktor-ktor-utils/io/ktor/util/pipeline/PhaseContent.mjs

@@ -0,0 +1,120 @@
+import { toMutableList20rdgwi7d3cwi as toMutableList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  createThis2j2avj17cvnv2 as createThis,
+  toString1pkumu07cwy4m as toString,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { KtMutableList1beimitadwkna as KtMutableList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/Collections.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function copiedInterceptors($this) {
+  return toMutableList($this.o3v_1);
+}
+function copyInterceptors($this) {
+  $this.o3v_1 = copiedInterceptors($this);
+  $this.p3v_1 = false;
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        var tmp = this;
+        // Inline function 'kotlin.collections.mutableListOf' call
+        tmp.q3v_1 = ArrayList().l1();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+var PhaseContentClass;
+function PhaseContent() {
+  if (PhaseContentClass === VOID) {
+    class $ {
+      static r3v(phase, relation, interceptors) {
+        Companion_getInstance();
+        var $this = createThis(this);
+        $this.m3v_1 = phase;
+        $this.n3v_1 = relation;
+        $this.o3v_1 = interceptors;
+        $this.p3v_1 = true;
+        return $this;
+      }
+      static s3v(phase, relation) {
+        Companion_getInstance();
+        var tmp = Companion_getInstance().q3v_1;
+        var $this = this.r3v(phase, relation, isInterface(tmp, KtMutableList()) ? tmp : THROW_CCE());
+        // Inline function 'kotlin.check' call
+        if (!Companion_getInstance().q3v_1.j()) {
+          var message = 'The shared empty array list has been modified';
+          throw IllegalStateException().o4(toString(message));
+        }
+        return $this;
+      }
+      t3v() {
+        return this.o3v_1.j();
+      }
+      i1() {
+        return this.o3v_1.i1();
+      }
+      u3v(interceptor) {
+        if (this.p3v_1) {
+          copyInterceptors(this);
+        }
+        this.o3v_1.m(interceptor);
+      }
+      v3v(destination) {
+        var interceptors = this.o3v_1;
+        if (destination instanceof ArrayList()) {
+          destination.r7(destination.i1() + interceptors.i1() | 0);
+        }
+        var inductionVariable = 0;
+        var last = interceptors.i1();
+        if (inductionVariable < last)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            destination.m(interceptors.j1(index));
+          }
+           while (inductionVariable < last);
+      }
+      w3v() {
+        this.p3v_1 = true;
+        return this.o3v_1;
+      }
+      toString() {
+        return 'Phase `' + this.m3v_1.x3v_1 + '`, ' + this.i1() + ' handlers';
+      }
+    }
+    initMetadataForClass($, 'PhaseContent');
+    PhaseContentClass = $;
+  }
+  return PhaseContentClass;
+}
+//region block: exports
+export {
+  PhaseContent as PhaseContent20yhla4zqpd2q,
+};
+//endregion
+
+//# sourceMappingURL=PhaseContent.mjs.map

package/ktor-ktor-utils/io/ktor/util/pipeline/PhaseContent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../../../../../mnt/agent/work/8d547b974a7be21f/ktor-utils/common/src/io/ktor/util/pipeline/PhaseContent.kt","src/kotlin/collections/Collections.kt","src/kotlin/util/Preconditions.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["copiedInterceptors","copyInterceptors","phase","relation","interceptors","message","<get-isEmpty>","<get-size>","addInterceptor","interceptor","addTo","destination","index","sharedInterceptors","toString"],"mappings":";;;;;;;;;;;;;;;;;;;;2BAkEIA,CAAA,KAAAA,EAAqF;A,EAA4B,OAAf,cAAb,KAAa,CAAb,KAAa,C;AAAc,C;yBAIhHC,CAAA,KAAAA,EAA+B;A,EAC3B,cAAe,yB;EACf,cAAS,K;AACb,C;;;;;;;kBAG6C,I;;QAAA,YC6BO,gB;;;;;;;;;;;;;;;;;;iBDlGpDC,K,EACAC,Q,EACAC,Y;QAHJ,uB;;QACI,mB;QACA,sB;QACA,0B;QAWsB,kB;;;iBANlBF,K,EACAC,Q;QATR,uB;0CAU8B,K;6BAAjB,K,EAAO,Q,sCAAU,G;;QEiFtB,KFhFsB,wBAAhB,KAAgB,IEgFtB,C,CAAQ;A,cACRE,UFjFmC,+C;UEkFnC,iCAAoC,SAAR,OAAQ,CAApC,C;QACJ,C;;;SF9EqBC,CAAAA,EAAQ;A,QAAsB,OAAtB,IAAa,CAAb,KAAa,I;MAAQ,C;QACpCC,CAAAA,EAAQ;A,QAAiB,OAAjB,IAAa,CAAb,KAAa,K;MAAG,C;SAEtCC,CAAmBC,WAAnBD,EAAqE;A,QAC7D,e,CAAQ;A,UACR,sB;QACJ,C;QAEA,IAAa,CAAb,KAAa,GAAI,WAAJ,C;MACjB,C;SAEAE,CAAUC,WAAVD,EAAyE;A,YACrEN,eAAmB,IAAnBA,CAAmB,K;QAEf,uC,CAA0B;A,UAC1B,WAAY,IAAe,WAAY,KAAZ,GAAmB,YAAa,KAA/C,K;QAChB,C;YAEc,qB;YAAqB,OAAb,YAAa,K;QAAnC,wBAAc,IAAd,C;aAAA;A,gBAAKQ,QAAS,iB;YAAA,6C;YACV,WAAY,GAAI,gBAAa,KAAb,CAAJ,C;;UADhB,4BAAc,IAAd,C;MAGJ,C;SAkBAC,CAAAA,EAA2E;A,QACvE,aAAS,I;QACT,OAAO,IAAP,CAAO,K;MACX,C;cAIAC,CAAAA,EAAkC;A,QAAuC,OAAtC,SAAsC,GAA7B,IAA6B,CAA7B,KAA6B,CAAvB,KAAuB,GAAlB,KAAkB,GAAd,SAAc,GAAV,W;MAAS,C;;;;;;;;;;;"}