@continuous-excellence/coupling-cli 0.0.0

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

@@ -0,0 +1,100 @@
+import { Unit_instance28fytmsmm6r23 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';
+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 LockFreeLinkedListNodeClass;
+function LockFreeLinkedListNode() {
+  if (LockFreeLinkedListNodeClass === VOID) {
+    class $ {
+      m1a() {
+        // Inline function 'kotlinx.atomicfu.loop' call
+        var this_0 = this.m2l_1;
+        while (true) {
+          var next = this_0.kotlinx$atomicfu$value;
+          if (!(next instanceof OpDescriptor()))
+            return next;
+          next.n2l(this);
+        }
+      }
+      o2l() {
+        return unwrap(this.m1a());
+      }
+    }
+    initMetadataForClass($, 'LockFreeLinkedListNode');
+    LockFreeLinkedListNodeClass = $;
+  }
+  return LockFreeLinkedListNodeClass;
+}
+var SymbolClass;
+function Symbol() {
+  if (SymbolClass === VOID) {
+    class $ {
+      constructor(symbol) {
+        this.p2l_1 = symbol;
+      }
+      toString() {
+        return this.p2l_1;
+      }
+    }
+    initMetadataForClass($, 'Symbol');
+    SymbolClass = $;
+  }
+  return SymbolClass;
+}
+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.q2l_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/kotlin/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","../../../../../../../.gradle/daemon/9.3.0/Z:/BuildAgent/work/711ef0d9c7c28b00/atomicfu/src/commonMain/kotlin/kotlinx/atomicfu/AtomicFU.common.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-next>","<get-nextNode>","symbol","toString","unwrap","<this>","<init properties LockFreeLinkedList.kt>"],"mappings":";;;;;;;;;;;;;;;;;SA2MQA,CAAAA,EAAM;A;qBACF,I,CAAA,K;eClDD,I,EAAM;A,qBACF,M,CAAA,sB;UDkDK,sC;YAAuB,OAAO,I;UAClC,IAAK,KAAQ,IAAR,C;QClDjB,C;MDoDI,C;SAGsBC,CAAAA,EAAQ;A,QAAa,OAAR,OAAL,UAAK,C;MAAO,C;;;;;;;;;;;kBA1J7BC,M;QAAA,mB;;cACRC,CAAAA,EAAyB;A,QAAM,OAAN,IAAM,CAAN,K;MAAK,C;;;;;;;;;;;;;;;;;;;;;;;;;eAkvBlCC,CAAIC,aAAJD,EAAyB;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/kotlin/ktor-ktor-utils/io/ktor/util/logging/KtorSimpleLoggerJs.mjs

@@ -0,0 +1,137 @@
+import { PlatformUtils_getInstanceitqdjrwn2jrm as PlatformUtils_getInstance } from '../PlatformUtils.mjs';
+import {
+  Companion_instance25ullnynvxd0w as Companion_instance,
+  _Result___init__impl__xyqfz83a5421h46yeyh as _Result___init__impl__xyqfz8,
+  createFailure8paxfkfa5dc7 as createFailure,
+  _Result___get_value__impl__bjfvqg3630bgmytqwyb as _Result___get_value__impl__bjfvqg,
+  _Result___get_isFailure__impl__jpiriv131ia60azkd5j 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_getInstance3fa26e1a2kc6y as LogLevel_INFO_getInstance,
+  LogLevel_TRACE_getInstance2qth0831zdkey as LogLevel_TRACE_getInstance,
+  LogLevel_WARN_getInstance20933b9gjza43 as LogLevel_WARN_getInstance,
+  LogLevel_DEBUG_getInstance1eu4zbwkgucl1 as LogLevel_DEBUG_getInstance,
+} from './LoggerJs.mjs';
+import { Unit_instance28fytmsmm6r23 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 ? process.env.KTOR_LOG_LEVEL : null;
+}
+var KtorSimpleLogger$1Class;
+function KtorSimpleLogger$1() {
+  if (KtorSimpleLogger$1Class === VOID) {
+    class $ {
+      constructor() {
+        var tmp = this;
+        var tmp_0;
+        switch (PlatformUtils_getInstance().k2j_1 || PlatformUtils_getInstance().j2j_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.q1();
+                while (_iterator__ex2g4s.r1()) {
+                  var element = _iterator__ex2g4s.s1();
+                  if (element.w1_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.y2n_1 = tmp_0;
+      }
+      z2n() {
+        return this.y2n_1;
+      }
+      a2o(message) {
+        if (this.y2n_1.z4(LogLevel_WARN_getInstance()) > 0)
+          return Unit_instance;
+        console.warn(message);
+      }
+      b2o(message, cause) {
+        if (this.y2n_1.z4(LogLevel_DEBUG_getInstance()) > 0)
+          return Unit_instance;
+        console.debug('DEBUG: ' + message + ', cause: ' + cause.toString());
+      }
+      c2o(message) {
+        if (this.y2n_1.z4(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/kotlin/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","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-utils/io/ktor/util/logging/src/kotlin/util/Result.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-utils/io/ktor/util/logging/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":";;;;;;;;;;;;;;;;;;;;;;;;;;yBAWcA,CAAqBC,IAArBD,EAA6C;A,EA4D1D,mC;AAAD,C;wBA/DQE,CAAAA,EAAiC;A,EAAiD,OAA9C,OAAH,GAAa,OAAb,CAAqB,GAArB,CAAyB,cAAzB,GAA0C,I;AAAM,C;;;;;;kBAKtD,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;;;;oBEuR7B,6B;uBAAA,sB,EAAM;A,sBAAjBC,UAAW,sB;kBAAU,IAAU,OFvR+B,CAAG,IAAH,KAFvD,kBEyRc,C;oBAAoB,YAAO,O;;;gBAAM,C;gBAC3D,YAAO,I;;sBFxR8C,S;;;gBAFzC,sB;oBAAA,yBAGQ,2BAHR,iB;;eAKR,K;oBAAkB,4B;;;YANS,8B;;;QAAA,iB;;SAAtBC,CAAAA,EAAA;A,QAAA,iB;MAAkB,C;SAmBlBC,CAASC,OAATD,EAA0B;A,QAC3B,kBAAiB,2BAAjB,M;UAAuB,oB;QAC3B,OAAQ,MAAK,OAAL,C;MACZ,C;SAsBSE,CAAUD,O,EAAiBE,KAA3BD,EAA6C;A,QAC9C,kBAAiB,4BAAjB,M;UAAwB,oB;QAC5B,OAAQ,OAAO,SAAP,GAAe,OAAf,GAAsB,WAAtB,GAAgC,KAAhC,Y;MACZ,C;SAESE,CAAUH,OAAVG,EAA2B;A,QAC5B,kBAAiB,4BAAjB,M;UAAwB,oB;QAC5B,OAAQ,OAAO,SAAP,GAAe,OAAf,C;MACZ,C;;;;;;;;;;;"}

package/kotlin/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_instance28fytmsmm6r23 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
+function get_isTraceEnabled(_this__u8e3s4) {
+  return _this__u8e3s4.z2n().z4(LogLevel_TRACE_getInstance()) <= 0;
+}
+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 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_getInstance1eu4zbwkgucl1,
+  LogLevel_INFO_getInstance as LogLevel_INFO_getInstance3fa26e1a2kc6y,
+  LogLevel_TRACE_getInstance as LogLevel_TRACE_getInstance2qth0831zdkey,
+  LogLevel_WARN_getInstance as LogLevel_WARN_getInstance20933b9gjza43,
+  get_entries as get_entries3rhsgvbgx7tis,
+  get_isTraceEnabled as get_isTraceEnabled82xibuu04nxp,
+};
+//endregion
+
+//# sourceMappingURL=LoggerJs.mjs.map

package/kotlin/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":["<get-isTraceEnabled>","<this>","values","<get-entries>"],"mappings":";;;;;;;;;2BA8BiDA,CAA/BC,aAA+BD,EAAQ;A,EAAuB,OAAvB,uBAAkB,4BAAlB,M;AAAsB,C;;;;;;;eA9B/EE,CAAAA,E;;C;oBAAAC,CAAAA,E;;;;C;;;;;;6CAAA,O,EAAA,C;6CAAA,O,EAAA,C;4CAAA,M,EAAA,C;4CAAA,M,EAAA,C;6CAAA,O,EAAA,C;4CAAA,M,EAAA,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,84 @@
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { suspendOrReturn49pspzlx5djv as suspendOrReturn } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { PipelineContext34fsb0mycu471 as PipelineContext } from './PipelineContext.mjs';
+import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function *_generator_proceedLoop__sfimma($this, $completion) {
+  $l$loop_0: do {
+    var index = $this.v2l_1;
+    if (index === -1) {
+      break $l$loop_0;
+    }
+    var interceptors = $this.s2l_1;
+    if (index >= interceptors.v2()) {
+      $this.w2l();
+      break $l$loop_0;
+    }
+    var executeInterceptor = interceptors.u2(index);
+    $this.v2l_1 = index + 1 | 0;
+    var tmp = executeInterceptor($this, $this.u2l_1, $completion);
+    if (tmp === get_COROUTINE_SUSPENDED())
+      tmp = yield tmp;
+  }
+   while (true);
+  return $this.u2l_1;
+}
+function proceedLoop($this, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_proceedLoop__sfimma.bind(VOID, $this), $completion);
+}
+var DebugPipelineContextClass;
+function DebugPipelineContext() {
+  if (DebugPipelineContextClass === VOID) {
+    class $ extends PipelineContext() {
+      constructor(context, interceptors, subject, coroutineContext) {
+        super(context);
+        this.s2l_1 = interceptors;
+        this.t2l_1 = coroutineContext;
+        this.u2l_1 = subject;
+        this.v2l_1 = 0;
+      }
+      iw() {
+        return this.t2l_1;
+      }
+      x2l() {
+        return this.u2l_1;
+      }
+      w2l() {
+        this.v2l_1 = -1;
+      }
+      y2l(subject, $completion) {
+        this.u2l_1 = subject;
+        return this.z2l($completion);
+      }
+      z2l($completion) {
+        var index = this.v2l_1;
+        if (index < 0)
+          return this.u2l_1;
+        if (index >= this.s2l_1.v2()) {
+          this.w2l();
+          return this.u2l_1;
+        }
+        return proceedLoop(this, $completion);
+      }
+      a2m(initial, $completion) {
+        this.v2l_1 = 0;
+        this.u2l_1 = initial;
+        return this.z2l($completion);
+      }
+    }
+    initMetadataForClass($, 'DebugPipelineContext', VOID, VOID, VOID, [1, 0]);
+    DebugPipelineContextClass = $;
+  }
+  return DebugPipelineContextClass;
+}
+//region block: exports
+export {
+  DebugPipelineContext as DebugPipelineContext2zfnr2i0vcihk,
+};
+//endregion
+
+//# sourceMappingURL=DebugPipelineContext.mjs.map

package/kotlin/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":["<generator-proceedLoop>","$completion","index","interceptors","executeInterceptor","proceedLoop","context","subject","coroutineContext","<get-coroutineContext>","<get-subject>","finish","proceedWith","proceed","execute","initial"],"mappings":";;;;;;;;;wCAiEoBA,CAAA,K,EAAAC,WAAAD,EAA4B;A,gBACrC;A,QACCE,QAAY,KAAZA,CAAY,K;IACR,cAAS,EAAT,C,CAAa;A,MACb,e;IACJ,C;QACAC,eAAmB,KAAnBA,CAAmB,K;IACf,aAAS,YAAa,KAAtB,C,CAA4B;A,MAC5B,W;MACA,e;IACJ,C;QACAC,qBAAyB,gBAAa,KAAb,C;IACzB,KAAK,SAAQ,QAAQ,CAAhB,I;QACc,MAAnB,kBAAmB,CAAO,KAAP,EAAa,KAAb,CAAa,KAAb,c;;;;EACd,a;EAET,OAAO,KAAP,CAAO,K;AACX,C;oBAjBgBC,CAAA,K,EAAAJ,WAAAI,E;;C;;;;;kBAhDhBC,O,EACQH,Y,EACRI,O,EACSC,gB;cAC2B,O;QAHpC,yB;QAEA,6B;QAKiC,oB;QAEb,c;;QAPXC,CAAAA,EAAA;A,QAAA,iB;MAAqC,C;SAKrCC,CAAAA,EAAA;A,QAAA,iB;MAAoB,C;SAOpBC,CAAAA,EAAa;A,QAClB,aAAQ,E;MACZ,C;SAKiBC,CAAgBL,O,EAAhBN,WAAAW,EAA6C;A,QAC1D,IAAK,SAAU,O;QAEnB,OADW,qB;MACX,C;SAKiBC,CAAAZ,WAAAY,EAAwB;A,YACrCX,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;QAGJ,OADW,8B;MACX,C;SAEiBY,CAAYC,O,EAAZd,WAAAa,EAAyC;A,QACtD,aAAQ,C;QACR,aAAU,O;QAEd,OADW,qB;MACX,C;;;;;;;;;;;"}

package/kotlin/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_instance28fytmsmm6r23 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.d2m_1);
+}
+function copyInterceptors($this) {
+  $this.d2m_1 = copiedInterceptors($this);
+  $this.e2m_1 = false;
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        var tmp = this;
+        // Inline function 'kotlin.collections.mutableListOf' call
+        tmp.f2m_1 = ArrayList().n2();
+      }
+    }
+    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 g2m(phase, relation, interceptors) {
+        Companion_getInstance();
+        var $this = createThis(this);
+        $this.b2m_1 = phase;
+        $this.c2m_1 = relation;
+        $this.d2m_1 = interceptors;
+        $this.e2m_1 = true;
+        return $this;
+      }
+      static h2m(phase, relation) {
+        Companion_getInstance();
+        var tmp = Companion_getInstance().f2m_1;
+        var $this = this.g2m(phase, relation, isInterface(tmp, KtMutableList()) ? tmp : THROW_CCE());
+        // Inline function 'kotlin.check' call
+        if (!Companion_getInstance().f2m_1.o1()) {
+          var message = 'The shared empty array list has been modified';
+          throw IllegalStateException().o(toString(message));
+        }
+        return $this;
+      }
+      i2m() {
+        return this.d2m_1.o1();
+      }
+      v2() {
+        return this.d2m_1.v2();
+      }
+      j2m(interceptor) {
+        if (this.e2m_1) {
+          copyInterceptors(this);
+        }
+        this.d2m_1.t2(interceptor);
+      }
+      k2m(destination) {
+        var interceptors = this.d2m_1;
+        if (destination instanceof ArrayList()) {
+          destination.m8(destination.v2() + interceptors.v2() | 0);
+        }
+        var inductionVariable = 0;
+        var last = interceptors.v2();
+        if (inductionVariable < last)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            destination.t2(interceptors.u2(index));
+          }
+           while (inductionVariable < last);
+      }
+      l2m() {
+        this.e2m_1 = true;
+        return this.d2m_1;
+      }
+      toString() {
+        return 'Phase `' + this.b2m_1.m2m_1 + '`, ' + this.v2() + ' handlers';
+      }
+    }
+    initMetadataForClass($, 'PhaseContent');
+    PhaseContentClass = $;
+  }
+  return PhaseContentClass;
+}
+//region block: exports
+export {
+  PhaseContent as PhaseContent20yhla4zqpd2q,
+};
+//endregion
+
+//# sourceMappingURL=PhaseContent.mjs.map

package/kotlin/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","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-utils/io/ktor/util/pipeline/src/kotlin/collections/Collections.kt","../../../../../cli/build/compileSync/js/main/productionExecutable/kotlin/ktor-ktor-utils/io/ktor/util/pipeline/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":";;;;;;;;;;;;;;;;;;;;2BAkEYA,CAAA,KAAAA,EAA6E;A,EAA4B,OAAf,cAAb,KAAa,CAAb,KAAa,C;AAAc,C;yBAIxGC,CAAA,KAAAA,EAAuB;A,EAC3B,cAAe,yB;EACf,cAAS,K;AACb,C;;;;;;;kBAG6C,I;;QAAA,YC6BO,gB;;;;;;;;;;;;;;;;;;iBDlGpDC,K,EACAC,Q,EACQC,Y;QAHZ,uB;;QACI,mB;QACA,sB;QACA,0B;QAWsB,kB;;;iBANlBF,K,EACAC,Q;QATR,uB;0CAU8B,K;6BAAjB,K,EAAO,Q,sCAAU,G;;QEmFtB,KFlFsB,wBAAhB,KAAgB,KEkFtB,C,CAAQ;A,cACRE,UFnFmC,+C;UEoFnC,gCAAoC,SAAR,OAAQ,CAApC,C;QACJ,C;;;SFhFqBC,CAAAA,EAAQ;A,QAAsB,OAAtB,IAAa,CAAb,KAAa,K;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,IAAI,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,IAAI,gBAAa,KAAb,CAAJ,C;;UADhB,4BAAc,IAAd,C;MAGJ,C;SAkBAC,CAAAA,EAA2E;A,QACvE,aAAS,I;QACT,OAAO,IAAP,CAAO,K;MACX,C;cAISC,CAAAA,EAAyB;A,QAAuC,OAAtC,SAAsC,GAA7B,IAA6B,CAA7B,KAA6B,CAAvB,KAAuB,GAAlB,KAAkB,GAAd,SAAc,GAAV,W;MAAS,C;;;;;;;;;;;"}