@xiuper/mpp-core 0.0.2

package/ktor-ktor-network.js

@@ -0,0 +1,1399 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js', './ktor-ktor-io.js', './kotlinx-coroutines-core.js', './kotlinx-atomicfu.js', './kotlinx-io-kotlinx-io-core.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./ktor-ktor-io.js'), require('./kotlinx-coroutines-core.js'), require('./kotlinx-atomicfu.js'), require('./kotlinx-io-kotlinx-io-core.js'));
+  else {
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module 'ktor-ktor-network'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'ktor-ktor-network'.");
+    }
+    if (typeof globalThis['ktor-ktor-io'] === 'undefined') {
+      throw new Error("Error loading module 'ktor-ktor-network'. Its dependency 'ktor-ktor-io' was not found. Please, check whether 'ktor-ktor-io' is loaded prior to 'ktor-ktor-network'.");
+    }
+    if (typeof globalThis['kotlinx-coroutines-core'] === 'undefined') {
+      throw new Error("Error loading module 'ktor-ktor-network'. Its dependency 'kotlinx-coroutines-core' was not found. Please, check whether 'kotlinx-coroutines-core' is loaded prior to 'ktor-ktor-network'.");
+    }
+    if (typeof globalThis['kotlinx-atomicfu'] === 'undefined') {
+      throw new Error("Error loading module 'ktor-ktor-network'. Its dependency 'kotlinx-atomicfu' was not found. Please, check whether 'kotlinx-atomicfu' is loaded prior to 'ktor-ktor-network'.");
+    }
+    if (typeof globalThis['kotlinx-io-kotlinx-io-core'] === 'undefined') {
+      throw new Error("Error loading module 'ktor-ktor-network'. Its dependency 'kotlinx-io-kotlinx-io-core' was not found. Please, check whether 'kotlinx-io-kotlinx-io-core' is loaded prior to 'ktor-ktor-network'.");
+    }
+    globalThis['ktor-ktor-network'] = factory(typeof globalThis['ktor-ktor-network'] === 'undefined' ? {} : globalThis['ktor-ktor-network'], globalThis['kotlin-kotlin-stdlib'], globalThis['ktor-ktor-io'], globalThis['kotlinx-coroutines-core'], globalThis['kotlinx-atomicfu'], globalThis['kotlinx-io-kotlinx-io-core']);
+  }
+}(function (_, kotlin_kotlin, kotlin_io_ktor_ktor_io, kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core, kotlin_org_jetbrains_kotlinx_atomicfu, kotlin_org_jetbrains_kotlinx_kotlinx_io_core) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var protoOf = kotlin_kotlin.$_$.we;
+  var initMetadataForClass = kotlin_kotlin.$_$.ud;
+  var get_isCompleted = kotlin_io_ktor_ktor_io.$_$.m2;
+  var Unit_instance = kotlin_kotlin.$_$.h6;
+  var get_isCancelled = kotlin_io_ktor_ktor_io.$_$.l2;
+  var getCancellationException = kotlin_io_ktor_ktor_io.$_$.i2;
+  var addSuppressed = kotlin_kotlin.$_$.ml;
+  var CoroutineImpl = kotlin_kotlin.$_$.tc;
+  var THROW_CCE = kotlin_kotlin.$_$.zk;
+  var CoroutineScope = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.c2;
+  var isInterface = kotlin_kotlin.$_$.je;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.dc;
+  var cancel = kotlin_io_ktor_ktor_io.$_$.d2;
+  var initMetadataForLambda = kotlin_kotlin.$_$.zd;
+  var VOID = kotlin_kotlin.$_$.h;
+  var atomic$boolean$1 = kotlin_org_jetbrains_kotlinx_atomicfu.$_$.b;
+  var atomic$ref$1 = kotlin_org_jetbrains_kotlinx_atomicfu.$_$.d;
+  var Key_instance = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.x;
+  var Job = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.d2;
+  var CoroutineName = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.a2;
+  var launch = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.q2;
+  var IOException_init_$Create$ = kotlin_org_jetbrains_kotlinx_kotlinx_io_core.$_$.c;
+  var close = kotlin_io_ktor_ktor_io.$_$.g2;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.j2;
+  var attachJob = kotlin_io_ktor_ktor_io.$_$.c2;
+  var invokeOnCompletion = kotlin_io_ktor_ktor_io.$_$.j2;
+  var HashMap_init_$Create$ = kotlin_kotlin.$_$.w;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.vd;
+  var HashMap_init_$Create$_0 = kotlin_kotlin.$_$.x;
+  var ByteChannel = kotlin_io_ktor_ktor_io.$_$.t1;
+  var AutoCloseable = kotlin_kotlin.$_$.fk;
+  var initMetadataForInterface = kotlin_kotlin.$_$.yd;
+  var initMetadataForCoroutine = kotlin_kotlin.$_$.wd;
+  var _UByte___init__impl__g9hnc4 = kotlin_kotlin.$_$.x3;
+  var EmptyCoroutineContext_getInstance = kotlin_kotlin.$_$.i5;
+  var initMetadataForObject = kotlin_kotlin.$_$.ae;
+  var get_job = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.p2;
+  var cancel_0 = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.m2;
+  var Companion_instance = kotlin_kotlin.$_$.c6;
+  var createFailure = kotlin_kotlin.$_$.rl;
+  var _Result___init__impl__xyqfz8 = kotlin_kotlin.$_$.s3;
+  var IOException_init_$Create$_0 = kotlin_org_jetbrains_kotlinx_kotlinx_io_core.$_$.e;
+  var ensureNotNull = kotlin_kotlin.$_$.sl;
+  var Channel = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.z;
+  var SupervisorJob = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.f2;
+  var WriterScope = kotlin_io_ktor_ktor_io.$_$.b2;
+  var writeByteArray = kotlin_io_ktor_ktor_io.$_$.n;
+  var cancelConsumed = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.c1;
+  var ReaderScope = kotlin_io_ktor_ktor_io.$_$.a2;
+  var UnsafeBufferOperations_instance = kotlin_org_jetbrains_kotlinx_kotlinx_io_core.$_$.f;
+  var toString = kotlin_kotlin.$_$.af;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.e2;
+  var toLong = kotlin_kotlin.$_$.ye;
+  var CompletableDeferred = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.x1;
+  var Dispatchers_getInstance = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.v;
+  var writer = kotlin_io_ktor_ktor_io.$_$.r2;
+  var reader = kotlin_io_ktor_ktor_io.$_$.p2;
+  var intercepted = kotlin_kotlin.$_$.gc;
+  var CancellableContinuationImpl = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.u1;
+  var KProperty0 = kotlin_kotlin.$_$.sf;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.rd;
+  var _Result___get_value__impl__bjfvqg = kotlin_kotlin.$_$.w3;
+  var _Result___get_isFailure__impl__jpiriv = kotlin_kotlin.$_$.u3;
+  var noWhenBranchMatchedException = kotlin_kotlin.$_$.zl;
+  var lazy = kotlin_kotlin.$_$.yl;
+  var getStringHashCode = kotlin_kotlin.$_$.sd;
+  var objectCreate = kotlin_kotlin.$_$.ve;
+  var captureStack = kotlin_kotlin.$_$.dd;
+  var IOException = kotlin_org_jetbrains_kotlinx_kotlinx_io_core.$_$.k;
+  var IOException_init_$Init$ = kotlin_org_jetbrains_kotlinx_kotlinx_io_core.$_$.d;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForClass(SocketBuilder, 'SocketBuilder');
+  initMetadataForLambda(SocketBase$close$slambda, CoroutineImpl, VOID, [1]);
+  function dispose() {
+    try {
+      this.u4();
+    } catch ($p) {
+      if ($p instanceof Error) {
+        var ignore = $p;
+      } else {
+        throw $p;
+      }
+    }
+  }
+  initMetadataForInterface(ASocket, 'ASocket', VOID, VOID, [AutoCloseable]);
+  initMetadataForClass(SelectableBase, 'SelectableBase');
+  initMetadataForClass(SocketBase, 'SocketBase', VOID, SelectableBase, [ASocket, SelectableBase, CoroutineScope]);
+  initMetadataForClass(SocketOptions, 'SocketOptions');
+  initMetadataForClass(GeneralSocketOptions, 'GeneralSocketOptions', VOID, SocketOptions);
+  initMetadataForClass(AcceptorOptions, 'AcceptorOptions', VOID, SocketOptions);
+  initMetadataForClass(PeerSocketOptions, 'PeerSocketOptions', VOID, SocketOptions);
+  initMetadataForCompanion(Companion);
+  initMetadataForCoroutine($awaitClosedCOROUTINE$, CoroutineImpl);
+  initMetadataForClass(TcpSocketBuilder, 'TcpSocketBuilder', VOID, VOID, VOID, [3, 2]);
+  initMetadataForCompanion(Companion_0);
+  initMetadataForObject(NoopSelectorManager, 'NoopSelectorManager', VOID, VOID, [CoroutineScope, AutoCloseable], [2]);
+  initMetadataForClass(ServerSocketContext, 'ServerSocketContext');
+  initMetadataForClass(ServerSocketImpl, 'ServerSocketImpl', VOID, VOID, [ASocket], [0]);
+  initMetadataForClass(SocketContext, 'SocketContext');
+  initMetadataForLambda(SocketImpl$attachForReadingImpl$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForLambda(SocketImpl$attachForWritingImpl$slambda, CoroutineImpl, VOID, [1]);
+  initMetadataForClass(SocketImpl, 'SocketImpl', VOID, SocketBase, [SocketBase, ASocket, CoroutineScope]);
+  initMetadataForClass(SocketAddress, 'SocketAddress');
+  initMetadataForCompanion(Companion_1);
+  initMetadataForClass(UnixSocketAddress, 'UnixSocketAddress', VOID, SocketAddress);
+  initMetadataForClass(InetSocketAddress, 'InetSocketAddress', VOID, SocketAddress);
+  initMetadataForClass(SocketTimeoutException, 'SocketTimeoutException', VOID, IOException);
+  //endregion
+  function SocketBuilder(selector, options) {
+    this.ybh_1 = selector;
+    this.zbh_1 = options;
+  }
+  protoOf(SocketBuilder).abi = function () {
+    return new TcpSocketBuilder(this.ybh_1, this.zbh_1.fbi());
+  };
+  function aSocket(selector) {
+    return new SocketBuilder(selector, Companion_instance_0.gbi());
+  }
+  function checkChannels($this) {
+    var tmp;
+    var tmp_0;
+    if ($this.hbi_1.kotlinx$atomicfu$value) {
+      // Inline function 'io.ktor.network.sockets.SocketBase.completedOrNotStarted' call
+      // Inline function 'kotlin.let' call
+      var it = $this.jbi_1.kotlinx$atomicfu$value;
+      tmp_0 = it == null || get_isCompleted(it);
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      // Inline function 'io.ktor.network.sockets.SocketBase.completedOrNotStarted' call
+      // Inline function 'kotlin.let' call
+      var it_0 = $this.kbi_1.kotlinx$atomicfu$value;
+      tmp = it_0 == null || get_isCompleted(it_0);
+    } else {
+      tmp = false;
+    }
+    if (tmp) {
+      if (!$this.ibi_1.atomicfu$compareAndSet(false, true))
+        return Unit_instance;
+      // Inline function 'io.ktor.network.sockets.SocketBase.exception' call
+      var tmp0_safe_receiver = $this.jbi_1.kotlinx$atomicfu$value;
+      var tmp_1;
+      if (tmp0_safe_receiver == null) {
+        tmp_1 = null;
+      } else {
+        // Inline function 'kotlin.takeIf' call
+        var tmp_2;
+        if (get_isCancelled(tmp0_safe_receiver)) {
+          tmp_2 = tmp0_safe_receiver;
+        } else {
+          tmp_2 = null;
+        }
+        tmp_1 = tmp_2;
+      }
+      var tmp1_safe_receiver = tmp_1;
+      var tmp2_safe_receiver = tmp1_safe_receiver == null ? null : getCancellationException(tmp1_safe_receiver);
+      var e1 = tmp2_safe_receiver == null ? null : tmp2_safe_receiver.cause;
+      // Inline function 'io.ktor.network.sockets.SocketBase.exception' call
+      var tmp0_safe_receiver_0 = $this.kbi_1.kotlinx$atomicfu$value;
+      var tmp_3;
+      if (tmp0_safe_receiver_0 == null) {
+        tmp_3 = null;
+      } else {
+        // Inline function 'kotlin.takeIf' call
+        var tmp_4;
+        if (get_isCancelled(tmp0_safe_receiver_0)) {
+          tmp_4 = tmp0_safe_receiver_0;
+        } else {
+          tmp_4 = null;
+        }
+        tmp_3 = tmp_4;
+      }
+      var tmp1_safe_receiver_0 = tmp_3;
+      var tmp2_safe_receiver_0 = tmp1_safe_receiver_0 == null ? null : getCancellationException(tmp1_safe_receiver_0);
+      var e2 = tmp2_safe_receiver_0 == null ? null : tmp2_safe_receiver_0.cause;
+      var e3 = $this.nbi();
+      var combined = combine($this, combine($this, e1, e2), e3);
+      if (combined == null)
+        $this.obi().y24();
+      else
+        $this.obi().x24(combined);
+    }
+  }
+  function combine($this, e1, e2) {
+    var tmp;
+    if (e1 == null) {
+      tmp = e2;
+    } else if (e2 == null) {
+      tmp = e1;
+    } else if (e1 === e2) {
+      tmp = e1;
+    } else {
+      addSuppressed(e1, e2);
+      tmp = e1;
+    }
+    return tmp;
+  }
+  function SocketBase$channelCompletionHandler$lambda(this$0) {
+    return function (it) {
+      checkChannels(this$0);
+      return Unit_instance;
+    };
+  }
+  function SocketBase$close$slambda(this$0, resultContinuation) {
+    this.xbi_1 = this$0;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(SocketBase$close$slambda).x2q = function ($this$launch, $completion) {
+    var tmp = this.y2q($this$launch, $completion);
+    tmp.z9_1 = Unit_instance;
+    tmp.aa_1 = null;
+    return tmp.fa();
+  };
+  protoOf(SocketBase$close$slambda).ra = function (p1, $completion) {
+    return this.x2q((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(SocketBase$close$slambda).fa = function () {
+    var suspendResult = this.z9_1;
+    $sm: do
+      try {
+        var tmp = this.x9_1;
+        switch (tmp) {
+          case 0:
+            this.y9_1 = 3;
+            this.zbi_1 = this.xbi_1.jbi_1.kotlinx$atomicfu$value;
+            if (this.zbi_1 == null) {
+              this.abj_1 = null;
+              this.x9_1 = 2;
+              continue $sm;
+            } else {
+              this.x9_1 = 1;
+              suspendResult = this.zbi_1.o4i(this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            }
+
+          case 1:
+            var tmp_0 = this;
+            tmp_0.abj_1 = Unit_instance;
+            this.x9_1 = 2;
+            continue $sm;
+          case 2:
+            var tmp1_safe_receiver = this.xbi_1.kbi_1.kotlinx$atomicfu$value;
+            if (tmp1_safe_receiver == null)
+              null;
+            else {
+              cancel(tmp1_safe_receiver);
+            }
+
+            checkChannels(this.xbi_1);
+            return Unit_instance;
+          case 3:
+            throw this.aa_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.y9_1 === 3) {
+          throw e;
+        } else {
+          this.x9_1 = this.y9_1;
+          this.aa_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(SocketBase$close$slambda).y2q = function ($this$launch, completion) {
+    var i = new SocketBase$close$slambda(this.xbi_1, completion);
+    i.ybi_1 = $this$launch;
+    return i;
+  };
+  function SocketBase$close$slambda_0(this$0, resultContinuation) {
+    var i = new SocketBase$close$slambda(this$0, resultContinuation);
+    var l = function ($this$launch, $completion) {
+      return i.x2q($this$launch, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function SocketBase(parent) {
+    SelectableBase.call(this);
+    this.hbi_1 = atomic$boolean$1(false);
+    this.ibi_1 = atomic$boolean$1(false);
+    this.jbi_1 = atomic$ref$1(null);
+    this.kbi_1 = atomic$ref$1(null);
+    var tmp = this;
+    tmp.lbi_1 = SocketBase$channelCompletionHandler$lambda(this);
+    this.mbi_1 = Job(parent.ka(Key_instance));
+  }
+  protoOf(SocketBase).obi = function () {
+    return this.mbi_1;
+  };
+  protoOf(SocketBase).z1v = function () {
+    return this.obi();
+  };
+  protoOf(SocketBase).y1y = function () {
+    this.u4();
+  };
+  protoOf(SocketBase).u4 = function () {
+    if (!this.hbi_1.atomicfu$compareAndSet(false, true))
+      return Unit_instance;
+    var tmp = new CoroutineName('socket-close');
+    launch(this, tmp, VOID, SocketBase$close$slambda_0(this, null));
+  };
+  protoOf(SocketBase).bbj = function (channel) {
+    // Inline function 'io.ktor.network.sockets.SocketBase.attachFor' call
+    var ref = this.kbi_1;
+    if (this.hbi_1.kotlinx$atomicfu$value) {
+      var e = IOException_init_$Create$('Socket closed');
+      close(channel, e);
+      throw e;
+    }
+    var j = this.cbj(channel);
+    if (!ref.atomicfu$compareAndSet(null, j)) {
+      var e_0 = IllegalStateException_init_$Create$('reading' + ' channel has already been set');
+      cancel(j);
+      throw e_0;
+    }
+    if (this.hbi_1.kotlinx$atomicfu$value) {
+      var e_1 = IOException_init_$Create$('Socket closed');
+      cancel(j);
+      close(channel, e_1);
+      throw e_1;
+    }
+    attachJob(channel, j);
+    invokeOnCompletion(j, this.lbi_1);
+    return j;
+  };
+  protoOf(SocketBase).dbj = function (channel) {
+    // Inline function 'io.ktor.network.sockets.SocketBase.attachFor' call
+    var ref = this.jbi_1;
+    if (this.hbi_1.kotlinx$atomicfu$value) {
+      var e = IOException_init_$Create$('Socket closed');
+      close(channel, e);
+      throw e;
+    }
+    var j = this.ebj(channel);
+    if (!ref.atomicfu$compareAndSet(null, j)) {
+      var e_0 = IllegalStateException_init_$Create$('writing' + ' channel has already been set');
+      cancel(j);
+      throw e_0;
+    }
+    if (this.hbi_1.kotlinx$atomicfu$value) {
+      var e_1 = IOException_init_$Create$('Socket closed');
+      cancel(j);
+      close(channel, e_1);
+      throw e_1;
+    }
+    attachJob(channel, j);
+    invokeOnCompletion(j, this.lbi_1);
+    return j;
+  };
+  function GeneralSocketOptions(customOptions) {
+    SocketOptions.call(this, customOptions);
+  }
+  function AcceptorOptions(customOptions) {
+    SocketOptions.call(this, customOptions);
+    this.kbj_1 = 511;
+  }
+  function PeerSocketOptions(customOptions) {
+    SocketOptions.call(this, customOptions);
+    this.pbj_1 = -1;
+    this.qbj_1 = -1;
+  }
+  protoOf(PeerSocketOptions).fbj = function (from) {
+    protoOf(SocketOptions).fbj.call(this, from);
+    if (from instanceof PeerSocketOptions) {
+      this.pbj_1 = from.pbj_1;
+      this.qbj_1 = from.qbj_1;
+    }
+  };
+  function Companion() {
+  }
+  protoOf(Companion).gbi = function () {
+    return new GeneralSocketOptions(HashMap_init_$Create$());
+  };
+  var Companion_instance_0;
+  function Companion_getInstance() {
+    return Companion_instance_0;
+  }
+  function SocketOptions(customOptions) {
+    this.bbi_1 = customOptions;
+    this.cbi_1 = Companion_getInstance_0().sbj_1;
+    this.dbi_1 = false;
+    this.ebi_1 = false;
+  }
+  protoOf(SocketOptions).fbj = function (from) {
+    this.cbi_1 = from.cbi_1;
+    this.dbi_1 = from.dbi_1;
+    this.ebi_1 = from.ebi_1;
+  };
+  protoOf(SocketOptions).fbi = function () {
+    // Inline function 'kotlin.apply' call
+    var this_0 = new PeerSocketOptions(HashMap_init_$Create$_0(this.bbi_1));
+    this.fbj(this);
+    return this_0;
+  };
+  protoOf(SocketOptions).rbj = function () {
+    // Inline function 'kotlin.apply' call
+    var this_0 = new AcceptorOptions(HashMap_init_$Create$_0(this.bbi_1));
+    this_0.fbj(this);
+    return this_0;
+  };
+  function openReadChannel(_this__u8e3s4) {
+    // Inline function 'kotlin.also' call
+    var this_0 = new ByteChannel(false);
+    _this__u8e3s4.bbj(this_0);
+    return this_0;
+  }
+  function openWriteChannel(_this__u8e3s4, autoFlush) {
+    autoFlush = autoFlush === VOID ? false : autoFlush;
+    // Inline function 'kotlin.also' call
+    var this_0 = new ByteChannel(autoFlush);
+    _this__u8e3s4.dbj(this_0);
+    return this_0;
+  }
+  function awaitClosed(_this__u8e3s4, $completion) {
+    var tmp = new $awaitClosedCOROUTINE$(_this__u8e3s4, $completion);
+    tmp.z9_1 = Unit_instance;
+    tmp.aa_1 = null;
+    return tmp.fa();
+  }
+  function ASocket() {
+  }
+  function $awaitClosedCOROUTINE$(_this__u8e3s4, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.fbk_1 = _this__u8e3s4;
+  }
+  protoOf($awaitClosedCOROUTINE$).fa = function () {
+    var suspendResult = this.z9_1;
+    $sm: do
+      try {
+        var tmp = this.x9_1;
+        switch (tmp) {
+          case 0:
+            this.y9_1 = 2;
+            this.x9_1 = 1;
+            suspendResult = this.fbk_1.obi().g1x(this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            if (this.fbk_1.obi().w1w())
+              throw this.fbk_1.obi().z1w();
+            return Unit_instance;
+          case 2:
+            throw this.aa_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.y9_1 === 2) {
+          throw e;
+        } else {
+          this.x9_1 = this.y9_1;
+          this.aa_1 = e;
+        }
+      }
+     while (true);
+  };
+  function TcpSocketBuilder$bind$lambda(_this__u8e3s4) {
+    return Unit_instance;
+  }
+  function TcpSocketBuilder(selector, options) {
+    this.gbk_1 = selector;
+    this.hbk_1 = options;
+  }
+  protoOf(TcpSocketBuilder).ibk = function (hostname, port, configure, $completion) {
+    return this.jbk(new InetSocketAddress(hostname, port), configure, $completion);
+  };
+  protoOf(TcpSocketBuilder).jbk = function (localAddress, configure, $completion) {
+    // Inline function 'kotlin.apply' call
+    var this_0 = this.hbk_1.rbj();
+    configure(this_0);
+    return tcpBind(this.gbk_1, localAddress, this_0, $completion);
+  };
+  protoOf(TcpSocketBuilder).kbk = function (localAddress, configure, $completion, $super) {
+    localAddress = localAddress === VOID ? null : localAddress;
+    var tmp;
+    if (configure === VOID) {
+      tmp = TcpSocketBuilder$bind$lambda;
+    } else {
+      tmp = configure;
+    }
+    configure = tmp;
+    return $super === VOID ? this.jbk(localAddress, configure, $completion) : $super.jbk.call(this, localAddress, configure, $completion);
+  };
+  function _TypeOfService___init__impl__yslya3(value) {
+    return value;
+  }
+  function Companion_0() {
+    Companion_instance_1 = this;
+    this.sbj_1 = _TypeOfService___init__impl__yslya3(_UByte___init__impl__g9hnc4(0));
+    this.tbj_1 = _TypeOfService___init__impl__yslya3(_UByte___init__impl__g9hnc4(2));
+    this.ubj_1 = _TypeOfService___init__impl__yslya3(_UByte___init__impl__g9hnc4(4));
+    this.vbj_1 = _TypeOfService___init__impl__yslya3(_UByte___init__impl__g9hnc4(8));
+    this.wbj_1 = _TypeOfService___init__impl__yslya3(_UByte___init__impl__g9hnc4(16));
+  }
+  var Companion_instance_1;
+  function Companion_getInstance_0() {
+    if (Companion_instance_1 == null)
+      new Companion_0();
+    return Companion_instance_1;
+  }
+  function nodeNet() {
+    // Inline function 'kotlin.js.unsafeCast' call
+    return eval('require')('node:net');
+  }
+  function CreateServerOptions(block) {
+    return createObject(block);
+  }
+  function toJsError(_this__u8e3s4) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return _this__u8e3s4;
+  }
+  function toThrowable(_this__u8e3s4) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return _this__u8e3s4;
+  }
+  function toByteArray(_this__u8e3s4) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return new Int8Array(_this__u8e3s4);
+  }
+  function toJsBuffer(_this__u8e3s4, fromIndex, toIndex) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return _this__u8e3s4.subarray(fromIndex, toIndex);
+  }
+  function createObject(block) {
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.apply' call
+    var this_0 = {};
+    block(this_0);
+    return this_0;
+  }
+  function toSocketAddress(_this__u8e3s4) {
+    if (typeof _this__u8e3s4 === 'string') {
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      return new UnixSocketAddress(_this__u8e3s4);
+    }
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var info = _this__u8e3s4;
+    return new InetSocketAddress(info.address, info.port);
+  }
+  function ServerListenOptions(block) {
+    return createObject(block);
+  }
+  function SelectableBase() {
+  }
+  function SelectorManager(dispatcher) {
+    dispatcher = dispatcher === VOID ? EmptyCoroutineContext_getInstance() : dispatcher;
+    return NoopSelectorManager_instance;
+  }
+  function NoopSelectorManager() {
+  }
+  protoOf(NoopSelectorManager).z1v = function () {
+    return EmptyCoroutineContext_getInstance();
+  };
+  protoOf(NoopSelectorManager).u4 = function () {
+  };
+  var NoopSelectorManager_instance;
+  function NoopSelectorManager_getInstance() {
+    return NoopSelectorManager_instance;
+  }
+  function ServerSocketContext$initiate$lambda(this$0) {
+    return function (it) {
+      this$0.lbk_1.close();
+      this$0.obk_1.k1x();
+      this$0.nbk_1.y2i();
+      return Unit_instance;
+    };
+  }
+  function ServerSocketContext$initiate$lambda_0(this$0) {
+    return function (socket) {
+      var context = new SocketContext(socket, this$0.mbk_1, this$0.obk_1);
+      context.tbk(null);
+      this$0.nbk_1.n2i(context.ubk());
+      return Unit_instance;
+    };
+  }
+  function ServerSocketContext$initiate$lambda_1($cont, this$0) {
+    return function () {
+      var tmp;
+      if ($cont.a1w()) {
+        var tmp0 = $cont;
+        // Inline function 'kotlin.coroutines.resumeWithException' call
+        // Inline function 'kotlin.Companion.failure' call
+        var exception = IOException_init_$Create$('Failed to bind');
+        var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(exception));
+        tmp0.ia(tmp$ret$0);
+        tmp = Unit_instance;
+      } else {
+        cancel_0(get_job(this$0.obk_1), 'Server closed');
+        tmp = Unit_instance;
+      }
+      return Unit_instance;
+    };
+  }
+  function ServerSocketContext$initiate$lambda_2($cont, this$0) {
+    return function (error) {
+      var tmp;
+      if ($cont.a1w()) {
+        var tmp0 = $cont;
+        // Inline function 'kotlin.coroutines.resumeWithException' call
+        // Inline function 'kotlin.Companion.failure' call
+        var exception = IOException_init_$Create$_0('Failed to bind', toThrowable(error));
+        var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(exception));
+        tmp0.ia(tmp$ret$0);
+        tmp = Unit_instance;
+      } else {
+        cancel_0(get_job(this$0.obk_1), 'Server failed', toThrowable(error));
+        tmp = Unit_instance;
+      }
+      return Unit_instance;
+    };
+  }
+  function ServerSocketContext$initiate$lambda_3($cont, this$0) {
+    return function () {
+      var tmp0 = $cont;
+      // Inline function 'kotlin.coroutines.resume' call
+      // Inline function 'kotlin.Companion.success' call
+      var value = new ServerSocketImpl(toSocketAddress(ensureNotNull(this$0.lbk_1.address())), this$0.obk_1, this$0.nbk_1, this$0.lbk_1);
+      var tmp$ret$0 = _Result___init__impl__xyqfz8(value);
+      tmp0.ia(tmp$ret$0);
+      return Unit_instance;
+    };
+  }
+  function ServerSocketContext(server, localAddress, parentContext) {
+    this.lbk_1 = server;
+    this.mbk_1 = localAddress;
+    this.nbk_1 = Channel(2147483647);
+    this.obk_1 = SupervisorJob(parentContext);
+  }
+  protoOf(ServerSocketContext).vbk = function (cont) {
+    cont.c22(ServerSocketContext$initiate$lambda(this));
+    onConnection(this.lbk_1, ServerSocketContext$initiate$lambda_0(this));
+    onClose_0(this.lbk_1, ServerSocketContext$initiate$lambda_1(cont, this));
+    onError_0(this.lbk_1, ServerSocketContext$initiate$lambda_2(cont, this));
+    onListening(this.lbk_1, ServerSocketContext$initiate$lambda_3(cont, this));
+    this.lbk_1.listen(ServerListenOptions_0(this.mbk_1));
+  };
+  function ServerSocketImpl$lambda(this$0) {
+    return function (it) {
+      this$0.zbk_1.close();
+      this$0.ybk_1.y2i();
+      return Unit_instance;
+    };
+  }
+  function ServerSocketImpl(localAddress, socketContext, incoming, server) {
+    this.wbk_1 = localAddress;
+    this.xbk_1 = socketContext;
+    this.ybk_1 = incoming;
+    this.zbk_1 = server;
+    this.xbk_1.c1x(ServerSocketImpl$lambda(this));
+  }
+  protoOf(ServerSocketImpl).jb4 = function () {
+    return this.wbk_1;
+  };
+  protoOf(ServerSocketImpl).obi = function () {
+    return this.xbk_1;
+  };
+  protoOf(ServerSocketImpl).abl = function ($completion) {
+    return this.ybk_1.q2i($completion);
+  };
+  protoOf(ServerSocketImpl).bbl = function ($completion) {
+    return this.abl($completion);
+  };
+  protoOf(ServerSocketImpl).u4 = function () {
+    this.ybk_1.u2i(IOException_init_$Create$('Server socket closed'));
+    this.xbk_1.y24();
+  };
+  function SocketContext$initiate$lambda(this$0) {
+    return function (it) {
+      this$0.pbk_1.destroy(it == null ? null : toJsError(it));
+      this$0.sbk_1.k1x();
+      this$0.rbk_1.y2i();
+      return Unit_instance;
+    };
+  }
+  function SocketContext$initiate$lambda_0(this$0) {
+    return function (it) {
+      this$0.pbk_1.destroy(it == null ? null : toJsError(it));
+      return Unit_instance;
+    };
+  }
+  function SocketContext$initiate$lambda_1($connectCont, this$0) {
+    return function (error) {
+      var tmp0_safe_receiver = $connectCont;
+      var tmp;
+      if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.a1w()) === true) {
+        var tmp0 = $connectCont;
+        // Inline function 'kotlin.coroutines.resumeWithException' call
+        // Inline function 'kotlin.Companion.failure' call
+        var exception = IOException_init_$Create$_0('Failed to connect', toThrowable(error));
+        var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(exception));
+        tmp0.ia(tmp$ret$0);
+        tmp = Unit_instance;
+      } else {
+        cancel_0(get_job(this$0.sbk_1), 'Socket error', toThrowable(error));
+        tmp = Unit_instance;
+      }
+      return Unit_instance;
+    };
+  }
+  function SocketContext$initiate$lambda_2($connectCont, this$0) {
+    return function () {
+      var tmp0_safe_receiver = $connectCont;
+      var tmp;
+      if ((tmp0_safe_receiver == null ? null : tmp0_safe_receiver.a1w()) === true) {
+        var tmp0 = $connectCont;
+        // Inline function 'kotlin.coroutines.resumeWithException' call
+        // Inline function 'kotlin.Companion.failure' call
+        var exception = SocketTimeoutException_init_$Create$('timeout');
+        var tmp$ret$0 = _Result___init__impl__xyqfz8(createFailure(exception));
+        tmp0.ia(tmp$ret$0);
+        tmp = Unit_instance;
+      } else {
+        cancel_0(get_job(this$0.sbk_1), 'Socket timeout', SocketTimeoutException_init_$Create$('timeout'));
+        tmp = Unit_instance;
+      }
+      return Unit_instance;
+    };
+  }
+  function SocketContext$initiate$lambda_3(this$0) {
+    return function () {
+      this$0.rbk_1.w2i();
+      return Unit_instance;
+    };
+  }
+  function SocketContext$initiate$lambda_4(this$0) {
+    return function (it) {
+      cancel_0(get_job(this$0.sbk_1), 'Socket closed');
+      return Unit_instance;
+    };
+  }
+  function SocketContext$initiate$lambda_5(this$0) {
+    return function (data) {
+      this$0.rbk_1.n2i(data);
+      return Unit_instance;
+    };
+  }
+  function SocketContext$initiate$lambda_6($connectCont, this$0) {
+    return function () {
+      var tmp0 = $connectCont;
+      // Inline function 'kotlin.coroutines.resume' call
+      // Inline function 'kotlin.Companion.success' call
+      var value = this$0.ubk();
+      var tmp$ret$0 = _Result___init__impl__xyqfz8(value);
+      tmp0.ia(tmp$ret$0);
+      return Unit_instance;
+    };
+  }
+  function SocketContext(socket, address, parentContext) {
+    this.pbk_1 = socket;
+    this.qbk_1 = address;
+    this.rbk_1 = Channel(2147483647);
+    this.sbk_1 = Job(parentContext);
+  }
+  protoOf(SocketContext).tbk = function (connectCont) {
+    if (connectCont == null)
+      null;
+    else {
+      connectCont.c22(SocketContext$initiate$lambda(this));
+    }
+    this.sbk_1.c1x(SocketContext$initiate$lambda_0(this));
+    onError(this.pbk_1, SocketContext$initiate$lambda_1(connectCont, this));
+    onTimeout(this.pbk_1, SocketContext$initiate$lambda_2(connectCont, this));
+    onEnd(this.pbk_1, SocketContext$initiate$lambda_3(this));
+    onClose(this.pbk_1, SocketContext$initiate$lambda_4(this));
+    onData(this.pbk_1, SocketContext$initiate$lambda_5(this));
+    if (!(connectCont == null)) {
+      onConnect(this.pbk_1, SocketContext$initiate$lambda_6(connectCont, this));
+    }
+  };
+  protoOf(SocketContext).ubk = function () {
+    var tmp;
+    if (this.qbk_1 instanceof UnixSocketAddress) {
+      tmp = this.qbk_1;
+    } else {
+      tmp = new InetSocketAddress(this.pbk_1.localAddress, this.pbk_1.localPort);
+    }
+    var tmp_0 = tmp;
+    var tmp_1;
+    if (this.qbk_1 instanceof UnixSocketAddress) {
+      tmp_1 = this.qbk_1;
+    } else {
+      tmp_1 = new InetSocketAddress(this.pbk_1.remoteAddress, this.pbk_1.remotePort);
+    }
+    return new SocketImpl(tmp_0, tmp_1, this.sbk_1, this.rbk_1, this.pbk_1);
+  };
+  function SocketImpl$attachForWritingImpl$slambda$lambda($endCompleted) {
+    return function () {
+      $endCompleted.n24(Unit_instance);
+      return Unit_instance;
+    };
+  }
+  function SocketImpl$attachForReadingImpl$slambda(this$0, $channel, resultContinuation) {
+    this.kbl_1 = this$0;
+    this.lbl_1 = $channel;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(SocketImpl$attachForReadingImpl$slambda).y5w = function ($this$writer, $completion) {
+    var tmp = this.z5w($this$writer, $completion);
+    tmp.z9_1 = Unit_instance;
+    tmp.aa_1 = null;
+    return tmp.fa();
+  };
+  protoOf(SocketImpl$attachForReadingImpl$slambda).ra = function (p1, $completion) {
+    return this.y5w(p1 instanceof WriterScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(SocketImpl$attachForReadingImpl$slambda).fa = function () {
+    var suspendResult = this.z9_1;
+    $sm: do
+      try {
+        var tmp = this.x9_1;
+        switch (tmp) {
+          case 0:
+            this.y9_1 = 12;
+            var tmp_0 = this;
+            tmp_0.nbl_1 = this.kbl_1.jbm_1;
+            this.obl_1 = this.nbl_1;
+            var tmp_1 = this;
+            tmp_1.pbl_1 = this.obl_1;
+            this.x9_1 = 1;
+            continue $sm;
+          case 1:
+            this.rbl_1 = this.pbl_1;
+            this.sbl_1 = null;
+            this.x9_1 = 2;
+            continue $sm;
+          case 2:
+            this.x9_1 = 3;
+            continue $sm;
+          case 3:
+            this.y9_1 = 11;
+            this.y9_1 = 10;
+            var tmp_2 = this;
+            tmp_2.ubl_1 = this.rbl_1;
+            this.vbl_1 = this.ubl_1;
+            this.wbl_1 = this.vbl_1.p();
+            this.x9_1 = 4;
+            continue $sm;
+          case 4:
+            this.x9_1 = 5;
+            suspendResult = this.wbl_1.t2e(this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 5:
+            if (!suspendResult) {
+              this.x9_1 = 8;
+              continue $sm;
+            }
+
+            this.xbl_1 = this.wbl_1.r();
+            var tmp_3 = this;
+            tmp_3.ybl_1 = this.xbl_1;
+            this.zbl_1 = this.ybl_1;
+            this.x9_1 = 6;
+            suspendResult = writeByteArray(this.lbl_1, toByteArray(this.zbl_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 6:
+            this.x9_1 = 7;
+            suspendResult = this.lbl_1.c4i(this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 7:
+            this.x9_1 = 4;
+            continue $sm;
+          case 8:
+            var tmp_4 = this;
+            tmp_4.tbl_1 = Unit_instance;
+            this.y9_1 = 12;
+            this.x9_1 = 9;
+            var tmp_5 = this;
+            continue $sm;
+          case 9:
+            this.y9_1 = 12;
+            var tmp_6 = this;
+            cancelConsumed(this.rbl_1, this.sbl_1);
+            tmp_6.qbl_1 = Unit_instance;
+            this.x9_1 = 14;
+            continue $sm;
+          case 10:
+            this.y9_1 = 11;
+            var tmp_7 = this.aa_1;
+            if (tmp_7 instanceof Error) {
+              var e = this.aa_1;
+              var tmp_8 = this;
+              this.sbl_1 = e;
+              throw e;
+            } else {
+              throw this.aa_1;
+            }
+
+          case 11:
+            this.y9_1 = 12;
+            var t = this.aa_1;
+            cancelConsumed(this.rbl_1, this.sbl_1);
+            throw t;
+          case 12:
+            throw this.aa_1;
+          case 13:
+            this.y9_1 = 12;
+            cancelConsumed(this.rbl_1, this.sbl_1);
+            if (false) {
+              this.x9_1 = 1;
+              continue $sm;
+            }
+
+            this.x9_1 = 14;
+            continue $sm;
+          case 14:
+            return Unit_instance;
+        }
+      } catch ($p) {
+        var e_0 = $p;
+        if (this.y9_1 === 12) {
+          throw e_0;
+        } else {
+          this.x9_1 = this.y9_1;
+          this.aa_1 = e_0;
+        }
+      }
+     while (true);
+  };
+  protoOf(SocketImpl$attachForReadingImpl$slambda).z5w = function ($this$writer, completion) {
+    var i = new SocketImpl$attachForReadingImpl$slambda(this.kbl_1, this.lbl_1, completion);
+    i.mbl_1 = $this$writer;
+    return i;
+  };
+  function SocketImpl$attachForReadingImpl$slambda_0(this$0, $channel, resultContinuation) {
+    var i = new SocketImpl$attachForReadingImpl$slambda(this$0, $channel, resultContinuation);
+    var l = function ($this$writer, $completion) {
+      return i.y5w($this$writer, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function SocketImpl$attachForWritingImpl$slambda($channel, this$0, resultContinuation) {
+    this.tbm_1 = $channel;
+    this.ubm_1 = this$0;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(SocketImpl$attachForWritingImpl$slambda).q5q = function ($this$reader, $completion) {
+    var tmp = this.r5q($this$reader, $completion);
+    tmp.z9_1 = Unit_instance;
+    tmp.aa_1 = null;
+    return tmp.fa();
+  };
+  protoOf(SocketImpl$attachForWritingImpl$slambda).ra = function (p1, $completion) {
+    return this.q5q(p1 instanceof ReaderScope ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(SocketImpl$attachForWritingImpl$slambda).fa = function () {
+    var suspendResult = this.z9_1;
+    $sm: do
+      try {
+        var tmp = this.x9_1;
+        switch (tmp) {
+          case 0:
+            this.y9_1 = 10;
+            this.x9_1 = 1;
+            continue $sm;
+          case 1:
+            if (!true) {
+              this.x9_1 = 11;
+              continue $sm;
+            }
+
+            var tmp_0 = this;
+            tmp_0.wbm_1 = this.tbm_1;
+            this.x9_1 = 2;
+            continue $sm;
+          case 2:
+            this.ybm_1 = this.wbm_1;
+            if (this.ybm_1.l4i()) {
+              this.xbm_1 = -1;
+              this.x9_1 = 7;
+              continue $sm;
+            } else {
+              this.x9_1 = 3;
+              continue $sm;
+            }
+
+          case 3:
+            if (this.ybm_1.e4i().r3a()) {
+              this.x9_1 = 4;
+              suspendResult = this.ybm_1.n4i(VOID, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.x9_1 = 5;
+              continue $sm;
+            }
+
+          case 4:
+            this.x9_1 = 5;
+            continue $sm;
+          case 5:
+            if (this.ybm_1.l4i()) {
+              this.xbm_1 = -1;
+              this.x9_1 = 7;
+              continue $sm;
+            } else {
+              this.x9_1 = 6;
+              continue $sm;
+            }
+
+          case 6:
+            var buffer = this.ybm_1.e4i().q3a();
+            if (!!buffer.r3a()) {
+              var message = 'Buffer is empty';
+              throw IllegalArgumentException_init_$Create$(toString(message));
+            }
+
+            var head = ensureNotNull(buffer.n3a_1);
+            var tmp0 = head.j3d(true);
+            var tmp2 = head.w3a_1;
+            var tmp_1 = this;
+            var endIndex = head.x3a_1;
+            this.ubm_1.kbm_1.write(toJsBuffer(tmp0, tmp2, endIndex));
+            tmp_1.zbm_1 = endIndex - tmp2 | 0;
+            var bytesRead = this.zbm_1;
+            if (!(bytesRead === 0)) {
+              if (bytesRead < 0)
+                throw IllegalStateException_init_$Create$('Returned negative read bytes count');
+              if (bytesRead > head.s())
+                throw IllegalStateException_init_$Create$('Returned too many bytes');
+              buffer.o3b(toLong(bytesRead));
+            }
+
+            this.xbm_1 = this.zbm_1;
+            if (false) {
+              this.x9_1 = 2;
+              continue $sm;
+            }
+
+            this.x9_1 = 7;
+            continue $sm;
+          case 7:
+            this.abn_1 = this.xbm_1;
+            if (this.abn_1 === -1) {
+              this.bbn_1 = CompletableDeferred();
+              this.ubm_1.kbm_1.end(SocketImpl$attachForWritingImpl$slambda$lambda(this.bbn_1));
+              this.x9_1 = 9;
+              suspendResult = this.bbn_1.w21(this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.x9_1 = 8;
+              continue $sm;
+            }
+
+          case 8:
+            this.x9_1 = 1;
+            continue $sm;
+          case 9:
+            this.x9_1 = 11;
+            continue $sm;
+          case 10:
+            throw this.aa_1;
+          case 11:
+            return Unit_instance;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.y9_1 === 10) {
+          throw e;
+        } else {
+          this.x9_1 = this.y9_1;
+          this.aa_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(SocketImpl$attachForWritingImpl$slambda).r5q = function ($this$reader, completion) {
+    var i = new SocketImpl$attachForWritingImpl$slambda(this.tbm_1, this.ubm_1, completion);
+    i.vbm_1 = $this$reader;
+    return i;
+  };
+  function SocketImpl$attachForWritingImpl$slambda_0($channel, this$0, resultContinuation) {
+    var i = new SocketImpl$attachForWritingImpl$slambda($channel, this$0, resultContinuation);
+    var l = function ($this$reader, $completion) {
+      return i.q5q($this$reader, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  function SocketImpl(localAddress, remoteAddress, coroutineContext, incoming, socket) {
+    SocketBase.call(this, coroutineContext);
+    this.gbm_1 = localAddress;
+    this.hbm_1 = remoteAddress;
+    this.ibm_1 = coroutineContext;
+    this.jbm_1 = incoming;
+    this.kbm_1 = socket;
+  }
+  protoOf(SocketImpl).jb4 = function () {
+    return this.gbm_1;
+  };
+  protoOf(SocketImpl).tb4 = function () {
+    return this.hbm_1;
+  };
+  protoOf(SocketImpl).z1v = function () {
+    return this.ibm_1;
+  };
+  protoOf(SocketImpl).cbj = function (channel) {
+    var tmp = Dispatchers_getInstance().x29_1;
+    return writer(this, tmp, channel, SocketImpl$attachForReadingImpl$slambda_0(this, channel, null));
+  };
+  protoOf(SocketImpl).ebj = function (channel) {
+    var tmp = Dispatchers_getInstance().x29_1;
+    return reader(this, tmp, channel, SocketImpl$attachForWritingImpl$slambda_0(channel, this, null));
+  };
+  protoOf(SocketImpl).nbi = function () {
+    this.kbm_1.destroy(null);
+    return null;
+  };
+  function tcpBind(selector, localAddress, socketOptions, $completion) {
+    var cancellable = new CancellableContinuationImpl(intercepted($completion), 1);
+    cancellable.b20();
+    var tmp = get_nodeNet();
+    var server = tmp.createServer(CreateServerOptions(tcpBind$lambda));
+    (new ServerSocketContext(server, localAddress, null)).vbk(cancellable);
+    return cancellable.c20();
+  }
+  function tcpBind$lambda($this$CreateServerOptions) {
+    return Unit_instance;
+  }
+  function get_nodeNet() {
+    _init_properties_node_net_kt__gywyxb();
+    var tmp0 = nodeNet$delegate;
+    var tmp = KProperty0;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('nodeNet', 0, tmp, _get_nodeNet_$ref_y13ztx(), null);
+    return tmp0.b1();
+  }
+  var nodeNet$delegate;
+  function onError(_this__u8e3s4, block) {
+    _init_properties_node_net_kt__gywyxb();
+    return _this__u8e3s4.on('error', block);
+  }
+  function onTimeout(_this__u8e3s4, block) {
+    _init_properties_node_net_kt__gywyxb();
+    return _this__u8e3s4.on('timeout', block);
+  }
+  function onEnd(_this__u8e3s4, block) {
+    _init_properties_node_net_kt__gywyxb();
+    return _this__u8e3s4.on('end', block);
+  }
+  function onClose(_this__u8e3s4, block) {
+    _init_properties_node_net_kt__gywyxb();
+    return _this__u8e3s4.on('close', block);
+  }
+  function onData(_this__u8e3s4, block) {
+    _init_properties_node_net_kt__gywyxb();
+    return _this__u8e3s4.on('data', block);
+  }
+  function onConnect(_this__u8e3s4, block) {
+    _init_properties_node_net_kt__gywyxb();
+    return _this__u8e3s4.on('connect', block);
+  }
+  function onConnection(_this__u8e3s4, block) {
+    _init_properties_node_net_kt__gywyxb();
+    return _this__u8e3s4.on('connection', block);
+  }
+  function onClose_0(_this__u8e3s4, block) {
+    _init_properties_node_net_kt__gywyxb();
+    return _this__u8e3s4.on('close', block);
+  }
+  function onError_0(_this__u8e3s4, block) {
+    _init_properties_node_net_kt__gywyxb();
+    return _this__u8e3s4.on('error', block);
+  }
+  function onListening(_this__u8e3s4, block) {
+    _init_properties_node_net_kt__gywyxb();
+    return _this__u8e3s4.on('listening', block);
+  }
+  function ServerListenOptions_0(localAddress) {
+    _init_properties_node_net_kt__gywyxb();
+    return ServerListenOptions(ServerListenOptions$lambda(localAddress));
+  }
+  function nodeNet$delegate$lambda() {
+    _init_properties_node_net_kt__gywyxb();
+    // Inline function 'kotlin.runCatching' call
+    var tmp;
+    try {
+      // Inline function 'kotlin.Companion.success' call
+      var value = nodeNet();
+      tmp = _Result___init__impl__xyqfz8(value);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof Error) {
+        var e = $p;
+        // Inline function 'kotlin.Companion.failure' call
+        tmp_0 = _Result___init__impl__xyqfz8(createFailure(e));
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    // Inline function 'kotlin.Result.getOrNull' call
+    var this_0 = tmp;
+    var tmp_1;
+    if (_Result___get_isFailure__impl__jpiriv(this_0)) {
+      tmp_1 = null;
+    } else {
+      var tmp_2 = _Result___get_value__impl__bjfvqg(this_0);
+      tmp_1 = (tmp_2 == null ? true : !(tmp_2 == null)) ? tmp_2 : THROW_CCE();
+    }
+    var tmp0 = tmp_1;
+    var tmp$ret$6;
+    $l$block: {
+      // Inline function 'kotlin.requireNotNull' call
+      if (tmp0 == null) {
+        var message = 'Node.js net module is not available. Please verify that you are using Node.js';
+        throw IllegalArgumentException_init_$Create$(toString(message));
+      } else {
+        tmp$ret$6 = tmp0;
+        break $l$block;
+      }
+    }
+    return tmp$ret$6;
+  }
+  function _get_nodeNet_$ref_y13ztx() {
+    return function () {
+      return get_nodeNet();
+    };
+  }
+  function ServerListenOptions$lambda($localAddress) {
+    return function ($this$ServerListenOptions) {
+      var tmp0_subject = $localAddress;
+      var tmp;
+      if (tmp0_subject instanceof InetSocketAddress) {
+        $this$ServerListenOptions.port = $localAddress.ebn_1;
+        $this$ServerListenOptions.host = $localAddress.dbn_1;
+        tmp = Unit_instance;
+      } else {
+        if (tmp0_subject instanceof UnixSocketAddress) {
+          $this$ServerListenOptions.path = $localAddress.cbn_1;
+          tmp = Unit_instance;
+        } else {
+          if (tmp0_subject == null) {
+            $this$ServerListenOptions.host = '0.0.0.0';
+            $this$ServerListenOptions.port = 0;
+            tmp = Unit_instance;
+          } else {
+            noWhenBranchMatchedException();
+          }
+        }
+      }
+      return Unit_instance;
+    };
+  }
+  var properties_initialized_node_net_kt_hlweib;
+  function _init_properties_node_net_kt__gywyxb() {
+    if (!properties_initialized_node_net_kt_hlweib) {
+      properties_initialized_node_net_kt_hlweib = true;
+      nodeNet$delegate = lazy(nodeNet$delegate$lambda);
+    }
+  }
+  function SocketAddress() {
+  }
+  function Companion_1() {
+  }
+  var Companion_instance_2;
+  function Companion_getInstance_1() {
+    return Companion_instance_2;
+  }
+  function UnixSocketAddress(path) {
+    SocketAddress.call(this);
+    this.cbn_1 = path;
+  }
+  protoOf(UnixSocketAddress).equals = function (other) {
+    var tmp;
+    if (other == null) {
+      tmp = true;
+    } else {
+      tmp = !(other instanceof UnixSocketAddress);
+    }
+    if (tmp)
+      return false;
+    return other.cbn_1 === this.cbn_1;
+  };
+  protoOf(UnixSocketAddress).hashCode = function () {
+    return getStringHashCode(this.cbn_1);
+  };
+  protoOf(UnixSocketAddress).toString = function () {
+    return 'UnixSocketAddress(' + this.cbn_1 + ')';
+  };
+  function InetSocketAddress(hostname, port) {
+    SocketAddress.call(this);
+    this.dbn_1 = hostname;
+    this.ebn_1 = port;
+  }
+  protoOf(InetSocketAddress).equals = function (other) {
+    var tmp;
+    if (other == null) {
+      tmp = true;
+    } else {
+      tmp = !(other instanceof InetSocketAddress);
+    }
+    if (tmp)
+      return false;
+    return other.dbn_1 === this.dbn_1 && other.ebn_1 === this.ebn_1;
+  };
+  protoOf(InetSocketAddress).hashCode = function () {
+    return imul(getStringHashCode(this.dbn_1), 31) + this.ebn_1 | 0;
+  };
+  protoOf(InetSocketAddress).toString = function () {
+    return 'InetSocketAddress(' + this.dbn_1 + ':' + this.ebn_1 + ')';
+  };
+  function SocketTimeoutException_init_$Init$(message, $this) {
+    SocketTimeoutException.call($this, message, null);
+    return $this;
+  }
+  function SocketTimeoutException_init_$Create$(message) {
+    var tmp = SocketTimeoutException_init_$Init$(message, objectCreate(protoOf(SocketTimeoutException)));
+    captureStack(tmp, SocketTimeoutException_init_$Create$);
+    return tmp;
+  }
+  function SocketTimeoutException(message, cause) {
+    IOException_init_$Init$(message, cause, this);
+    captureStack(this, SocketTimeoutException);
+  }
+  //region block: post-declaration
+  protoOf(ServerSocketImpl).y1y = dispose;
+  //endregion
+  //region block: init
+  Companion_instance_0 = new Companion();
+  NoopSelectorManager_instance = new NoopSelectorManager();
+  Companion_instance_2 = new Companion_1();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = awaitClosed;
+  _.$_$.b = SelectorManager;
+  _.$_$.c = InetSocketAddress;
+  _.$_$.d = UnixSocketAddress;
+  _.$_$.e = aSocket;
+  _.$_$.f = openReadChannel;
+  _.$_$.g = openWriteChannel;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=ktor-ktor-network.js.map