if (length == 0) {
            return;
        }

        final int s = length % 16;
        final int r = s == 0 ? length / 16 : length / 16 + 1;
        final char[] c = new char[r * (74 + NL_LENGTH)];
        final char[] d = new char[16];
        int i;
        int si = 0;
        int ci = 0;

        do {

    // choosing to turn .precomputed() into a no-op in GWT, because it doesn't
    // seem to be a worthwhile tradeoff in a browser.
    return matcher;
  }

  static String formatCompact4Digits(double value) {
    return toPrecision(value, 4);
  }

  @JsMethod(name = "Number.prototype.toPrecision.call", namespace = JsPackage.GLOBAL)
  private static native String toPrecision(double value, int precision);

  @JsMethod

      mutablePos += bytesWritten
      mutableByteCount -= bytesWritten
    }
  }

  /**
   * Copy [byteCount] bytes from the file at [pos] into `sink`. It is the
   * caller's responsibility to make sure there are sufficient bytes to read: if there aren't this
   * method throws an `EOFException`.
   */
  fun read(
    pos: Long,
    sink: Buffer,

  @ParametricNullness
  public final T next() {
    if (!hasNext()) {
      throw new NoSuchElementException();
    }
    state = State.NOT_READY;
    // Safe because hasNext() ensures that tryToComputeNext() has put a T into `next`.
    T result = uncheckedCastNullableTToT(next);
    next = null;
    return result;
  }

  @Override
  public final void remove() {
    throw new UnsupportedOperationException();
  }

  static String format(String template, Object... args) {
    // start substituting the arguments into the '%s' placeholders
    StringBuilder builder = new StringBuilder(template.length() + 16 * args.length);
    int templateStart = 0;
    int i = 0;
    while (i < args.length) {
      int placeholderStart = template.indexOf("%s", templateStart);
      if (placeholderStart == -1) {
        break;
      }

    @Override
    public int read(final byte[] b) throws IOException {
        return read(b, 0, b.length);
    }

    /**
     * Reads up to len bytes of data from this input stream into an array of bytes.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override
    public int read(final byte[] b, final int off, final int len) throws IOException {

     */
    fun newEventSource(
      request: Request,
      listener: EventSourceListener,
    ): EventSource

    companion object {
      /**
       * Wraps a [Call.Factory] into [EventSource.Factory].
       */
      @JvmStatic
      @JvmName("create")
      fun Call.Factory.asEventSourceFactory(): Factory =
        Factory { request, listener ->
          val actualRequest =

 *
 * All event methods must execute fast, without external locking, cannot throw exceptions,
 * attempt to mutate the event parameters, or be reentrant back into the client.
 * Any IO - writing to files or network should be done asynchronously.
 */
internal abstract class ConnectionListener {
  /**
   * Invoked as soon as a call causes a connection to be started.
   */

  @ParametricNullness
  public final T next() {
    if (!hasNext()) {
      throw new NoSuchElementException();
    }
    state = State.NOT_READY;
    // Safe because hasNext() ensures that tryToComputeNext() has put a T into `next`.
    T result = uncheckedCastNullableTToT(next);
    next = null;
    return result;
  }

  @Override
  public final void remove() {
    throw new UnsupportedOperationException();
  }

  enum State {
    /** The {@link CloseableList} has not been subsumed or closed. */
    OPEN,

    /**
     * The {@link CloseableList} has been subsumed into another. It may not be closed or subsumed
     * into any other.
     */
    SUBSUMED,

    /**
     * Some {@link ListenableFuture} has a callback attached that will close the {@link