}
        }
      }

      ImportResults(sortedRules, sortedExceptionRules, totalRuleBytes, totalExceptionRuleBytes)
    }

  private fun String.toRule(): ByteString? {
    if (trim { it <= ' ' }.isEmpty() || startsWith("//")) return null
    if (contains(WILDCARD_CHAR)) {
      assertWildcardRule(this)
    }
    return encodeUtf8()
  }

  data class ImportResults(

          FILE_HEADER_SIZE + upstreamPos,
          upstreamBuffer.clone(),
          upstreamBytesRead,
        )

        synchronized(this@Relay) {
          // Append new upstream bytes into the buffer. Trim it to its max size.
          buffer.write(upstreamBuffer, upstreamBytesRead)
          if (buffer.size > bufferMaxSize) {
            buffer.skip(buffer.size - bufferMaxSize)
          }

root = true

[*]
indent_size = 2
ij_continuation_indent_size = 2
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true

[*.{kt, kts}]

      }
    }

    var pos = 0
    while (pos < value.length) {
      val tokenStart = pos
      pos = value.indexOfElement("=,;", pos)
      val directive = value.substring(tokenStart, pos).trim()
      val parameter: String?

      if (pos == value.length || value[pos] == ',' || value[pos] == ';') {
        pos++ // Consume ',' or ';' (if necessary).
        parameter = null
      } else {

  val mimeType =
    headers?.let {
      for (header in it) {
        val parts = header.split(':', limit = 2)
        if ("Content-Type".equals(parts[0], ignoreCase = true)) {
          return@let parts[1].trim()
        }
      }
      return@let null
    } ?: "application/x-www-form-urlencoded"

  return mimeType.toMediaTypeOrNull()
}

private fun isSpecialHeader(s: String): Boolean {

    fun add(line: String) =
      apply {
        val index = line.indexOf(':')
        require(index != -1) { "Unexpected header: $line" }
        add(line.substring(0, index).trim(), line.substring(index + 1))
      }

    /**
     * Add a header with the specified name and value. Does validation of header names and values.
     */
    fun add(
      name: String,

        source.readUtf8LineStrict()
      }
      try {
        bytesRemainingInChunk = source.readHexadecimalUnsignedLong()
        val extensions = source.readUtf8LineStrict().trim()
        if (bytesRemainingInChunk < 0L || extensions.isNotEmpty() && !extensions.startsWith(";")) {
          throw ProtocolException(
            "expected chunk size and optional extensions" +

        val value = value(i)
        if (result == null) {
          result = TreeSet(String.CASE_INSENSITIVE_ORDER)
        }
        for (varyField in value.split(',')) {
          result.add(varyField.trim())
        }
      }
      return result ?: emptySet()
    }

    /**
     * Returns the subset of the headers in this's request that impact the content of this's body.
     */

    set("b", "bb", "bbb")

    // Cause the cache trim job to fail.
    filesystem.setFaultyDelete(cacheDir / "a.0", true)
    taskFaker.runNextTask()

    // An edit should now add a job to clean up if the most recent trim failed.
    assertThat(cache.edit("b")).isNull()
    taskFaker.runNextTask()

    // Confirm a successful cache trim now allows edits.
    filesystem.setFaultyDelete(cacheDir / "a.0", false)

      this.sameSite = cookie.sameSite
    }

    fun name(name: String) =
      apply {
        require(name.trim() == name) { "name is not trimmed" }
        this.name = name
      }

    fun value(value: String) =
      apply {
        require(value.trim() == value) { "value is not trimmed" }
        this.value = value
      }

    fun expiresAt(expiresAt: Long) =
      apply {