}

        override fun onMessage(
          webSocket: WebSocket,
          text: String,
        ) {
          webSocket.send(text)
        }

        override fun onClosing(
          webSocket: WebSocket,
          code: Int,
          reason: String,
        ) {
          webSocket.close(1000, null)
          latch.countDown()
        }

        override fun onFailure(

    } else {
      events.add(Message(string = text))
    }
  }

  override fun onClosing(
    webSocket: WebSocket,
    code: Int,
    reason: String,
  ) {
    Platform.get().log("[WS $name] onClosing $code", Platform.INFO, null)
    val delegate = delegate
    if (delegate != null) {
      this.delegate = null
      delegate.onClosing(webSocket, code, reason)
    } else {
      events.add(Closing(code, reason))
    }

  open fun onMessage(
    webSocket: WebSocket,
    bytes: ByteString,
  ) {
  }

  /**
   * Invoked when the remote peer has indicated that no more incoming messages will be transmitted.
   */
  open fun onClosing(
    webSocket: WebSocket,
    code: Int,
    reason: String,
  ) {
  }

  /**
   * Invoked when both peers have indicated that no more messages will be transmitted and the

              return
            }

          // Apply the extensions. If they're unacceptable initiate a graceful shut down.
          // TODO(jwilson): Listeners should get onFailure() instead of onClosing() + onClosed(1010).
          val extensions = WebSocketExtensions.parse(response.headers)
          ******@****.***ions = extensions
          if (!extensions.isValid()) {

}

public abstract class okhttp3/WebSocketListener {
	public fun <init> ()V
	public fun onClosed (Lokhttp3/WebSocket;ILjava/lang/String;)V
	public fun onClosing (Lokhttp3/WebSocket;ILjava/lang/String;)V
	public fun onFailure (Lokhttp3/WebSocket;Ljava/lang/Throwable;Lokhttp3/Response;)V
	public fun onMessage (Lokhttp3/WebSocket;Ljava/lang/String;)V

    // equal
    assertEquals(range, range.intersection(range));

    // enclosing with same start
    assertEquals(range, range.intersection(Range.closed(4, 10)));

    // enclosing with same end
    assertEquals(range, range.intersection(Range.closed(2, 8)));

    // enclosing, exterior
    assertEquals(range, range.intersection(Range.closed(2, 10)));

    // overlap above

	return nil
}

// LiteralString is a type for parsed SQL string literals
type LiteralString string

// Capture interface used by participle
func (ls *LiteralString) Capture(values []string) error {
	// Remove enclosing single quote
	n := len(values[0])
	r := values[0][1 : n-1]
	// Translate doubled quotes
	*ls = LiteralString(strings.ReplaceAll(r, "''", "'"))
	return nil
}

// LiteralList is a type for parsed SQL lists literals

   * than one, not just two.
   */
  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  @IgnoreJRERequirement // see enclosing class (whose annotation Animal Sniffer ignores here...)
  private static final class ToOptionalState<T extends @Nullable Object> {
    static final int MAX_EXTRAS = 4;

    @Nullable T element;
    List<T> extras;

    result = 31 * result + (if (typeHint) 1 else 0)
    return result
  }

  override fun toString(): String = "$name [$tagClass/$tag]"

  /** Reads and writes values without knowledge of the enclosing tag, length, or defaults. */
  interface Codec<T> {
    fun decode(reader: DerReader): T

    fun encode(
      writer: DerWriter,
      value: T,
    )
  }

   * than one, not just two.
   */
  @SuppressWarnings("EmptyList") // ImmutableList doesn't support nullable element types
  @IgnoreJRERequirement // see enclosing class (whose annotation Animal Sniffer ignores here...)
  private static final class ToOptionalState<T extends @Nullable Object> {
    static final int MAX_EXTRAS = 4;

    @Nullable T element;
    List<T> extras;