### Kompressor Dependency Setup with BOM

Source: https://context7.com/ensody/kompressor/llms.txt

Set up Kompressor dependencies using the Bill of Materials (BOM) in `build.gradle.kts`. Ensure the Maven Central repository is added.

```kotlin
dependencies {
    // BOM manages all module versions
    api(platform("com.ensody.kompressor:kompressor-bom:0.5.0"))

    // zstd/Zstandard
    api("com.ensody.kompressor:kompressor-zstd--nativelib")
    api("com.ensody.nativebuilds:zstd-libzstd:1.5.7.8")          // explicit native lib version
    api("com.ensody.kompressor:kompressor-zstd-ktor")             // optional Ktor plugin

    // zlib (deflate + gzip)
    api("com.ensody.kompressor:kompressor-zlib--nativelib")
    api("com.ensody.nativebuilds:zlib-libz:1.3.1.8")
    api("com.ensody.kompressor:kompressor-zlib-ktor")             // optional Ktor plugin

    // brotli
    api("com.ensody.kompressor:kompressor-brotli--nativelib")
    api("com.ensody.nativebuilds:brotli-libbrotlicommon:1.2.0_4")
    api("com.ensody.nativebuilds:brotli-libbrotlienc:1.2.0_4")
    api("com.ensody.nativebuilds:brotli-libbrotlidec:1.2.0_4")
    api("com.ensody.kompressor:kompressor-brotli-ktor")          // optional Ktor plugin

    // kotlinx-io streaming bridge (required for pipe() API)
    api("com.ensody.kompressor:kompressor-kotlinx-io")

    // JS / WASM Compression Streams API
    api("com.ensody.kompressor:kompressor-js")
}

// Also add Maven Central repository:
repositories {
    mavenCentral()
}
```

--------------------------------

### Zstd Compression and Decompression

Source: https://context7.com/ensody/kompressor/llms.txt

Provides examples of in-memory zstd compression and decompression using ZstdCompressor and ZstdDecompressor. Demonstrates default usage, dictionary-aided compression for improved ratios on similar payloads, and handling decompression failures without a dictionary.

```kotlin
import com.ensody.kompressor.core.transform
import com.ensody.kompressor.zstd.ZstdCompressor
import com.ensody.kompressor.zstd.ZstdDecompressor
import kotlin.random.Random
import kotlin.test.assertContentEquals

// --- In-memory roundtrip ---
val testData = Random.nextBytes(128 * 1024 + 3)
val compressed: ByteArray = ZstdCompressor(compressionLevel = 3).transform(testData)
val decompressed: ByteArray = ZstdDecompressor().transform(compressed)
assertContentEquals(testData, decompressed)
println("Compressed ${testData.size} → ${compressed.size} bytes")

// --- Dictionary-aided compression (improves ratio for small, similar payloads) ---
val dictionary = "content-type:application/json\r\naccept-encoding:zstd".encodeToByteArray()
val payload = "{\"status\":\"ok\",\"code\":200,\"message\":\"success\"}".encodeToByteArray()

val compressedWithDict = ZstdCompressor(compressionLevel = 3, dictionary = dictionary).transform(payload)
val compressedNoDict   = ZstdCompressor(compressionLevel = 3).transform(payload)
println("With dict: ${compressedWithDict.size}, without: ${compressedNoDict.size}")

val restoredWithDict = ZstdDecompressor(dictionary = dictionary).transform(compressedWithDict)
assertContentEquals(payload, restoredWithDict)

// Decompressing without the matching dictionary will fail
runCatching { ZstdDecompressor().transform(compressedWithDict) }
    .onFailure { println("Expected failure: ${it.message}") }
```

--------------------------------

### Integrate Zstd Compression with Ktor HttpClient

Source: https://github.com/ensody/kompressor/blob/main/README.md

Installs a custom Zstd encoder into the Ktor HttpClient's ContentEncoding feature for transparent compression of outgoing requests.

```kotlin
val client = HttpClient(CIO) {
    install(ContentEncoding) {
        customEncoder(ZstdContentEncoder(compressionLevel = 1), 1.0f)
    }
}
```

--------------------------------

### Zlib Compression and Decompression with Different Formats

Source: https://context7.com/ensody/kompressor/llms.txt

Demonstrates compressing and decompressing data using Zlib, Gzip, and Raw deflate formats. Also shows auto-detection for decompression and an interop test with Python's zlib.

```kotlin
import com.ensody.kompressor.core.transform
import com.ensody.kompressor.zlib.ZlibCompressor
import com.ensody.kompressor.zlib.ZlibDecompressor
import com.ensody.kompressor.zlib.ZlibFormat
import kotlin.random.Random
import kotlin.test.assertContentEquals
import kotlin.test.assertEquals

val testData = Random.nextBytes(64 * 1024)

// --- Zlib (deflate) format ---
val zlibCompressed = ZlibCompressor(ZlibFormat.Zlib, compressionLevel = 6).transform(testData)
val zlibRestored   = ZlibDecompressor(ZlibFormat.Zlib).transform(zlibCompressed)
assertContentEquals(testData, zlibRestored)

// --- Gzip format ---
val gzipCompressed = ZlibCompressor(ZlibFormat.Gzip, compressionLevel = 6).transform(testData)
val gzipRestored   = ZlibDecompressor(ZlibFormat.Gzip).transform(gzipCompressed)
assertContentEquals(testData, gzipRestored)

// --- Raw deflate (no header/trailer) ---
val rawCompressed = ZlibCompressor(ZlibFormat.Raw).transform(testData)
val rawRestored   = ZlibDecompressor(ZlibFormat.Raw).transform(rawCompressed)
assertContentEquals(testData, rawRestored)

// --- Auto-detect: handles both zlib and gzip transparently ---
val autoRestored = ZlibDecompressor(ZlibFormat.AutoDetectZlibGzip).transform(gzipCompressed)
assertContentEquals(testData, autoRestored)

// --- Known-value interop test (matches Python zlib.compress output) ---
val known = "hello compression world"
val fromPython = kotlin.io.encoding.Base64.decode("eJzLSM3JyVdIzs8tKEotLs7Mz1Mozy/KSQEAbW0JLw==")
assertEquals(known, ZlibDecompressor().transform(fromPython).decodeToString())
```

--------------------------------

### Zlib Compression Formats

Source: https://context7.com/ensody/kompressor/llms.txt

Demonstrates using ZlibCompressor with different wire formats (Zlib, Gzip, Raw) and auto-detection for decompression. Adjusts the 'windowBits' parameter for tuning.

```kotlin
import com.ensody.kompressor.zlib.ZlibFormat
import com.ensody.kompressor.zlib.ZlibCompressor
import com.ensody.kompressor.zlib.ZlibDecompressor
import com.ensody.kompressor.core.transform

val data = "format selection demo".encodeToByteArray()

// ZlibFormat.Zlib   — RFC 1950, deflate with 2-byte header + Adler-32 checksum
val zlibBytes  = ZlibCompressor(ZlibFormat.Zlib).transform(data)

// ZlibFormat.Gzip   — RFC 1952, gzip header + CRC-32 + length trailer
val gzipBytes  = ZlibCompressor(ZlibFormat.Gzip).transform(data)

// ZlibFormat.Raw    — Raw DEFLATE stream, no header/trailer, no checksum
val rawBytes   = ZlibCompressor(ZlibFormat.Raw).transform(data)

// ZlibFormat.AutoDetectZlibGzip — decompression only; detects Zlib or Gzip automatically
val autoResult = ZlibDecompressor(ZlibFormat.AutoDetectZlibGzip).transform(gzipBytes)

println(autoResult.decodeToString())
// Output: format selection demo

// windowBits tuning — valid range: 9..15 for Zlib/AutoDetect, 8..15 for Gzip/Raw
val highWindowZlib = ZlibCompressor(ZlibFormat.Zlib, windowBits = 15).transform(data)
val lowWindowRaw   = ZlibCompressor(ZlibFormat.Raw,  windowBits = 8).transform(data)
```

--------------------------------

### Experimental JS Compression Formats

Source: https://context7.com/ensody/kompressor/llms.txt

Demonstrates using experimental JavaScript compression formats like Zstd and Brotli via the Compression Streams API. Requires opting in with @OptIn(ExperimentalCompressionFormat::class).

```kotlin
import com.ensody.kompressor.core.ExperimentalCompressionFormat
import com.ensody.kompressor.js.JsCompressor
import com.ensody.kompressor.js.JsDecompressor
import com.ensody.kompressor.js.JsCompressionFormat
import com.ensody.kompressor.core.transform
import kotlinx.coroutines.test.runTest
import kotlin.test.assertContentEquals

@OptIn(ExperimentalCompressionFormat::class)
fun useExperimentalFormats() = runTest {
    val data = "experimental format".encodeToByteArray()

    // Zstd via Compression Streams API (Chrome 123+, Firefox not yet)
    val zstdCompressed   = JsCompressor(JsCompressionFormat.Zstd).transform(data)
    val zstdDecompressed = JsDecompressor(JsCompressionFormat.Zstd).transform(zstdCompressed)
    assertContentEquals(data, zstdDecompressed)

    // Brotli via Compression Streams API (not widely available)
    val brotliCompressed   = JsCompressor(JsCompressionFormat.Brotli).transform(data)
    val brotliDecompressed = JsDecompressor(JsCompressionFormat.Brotli).transform(brotliCompressed)
    assertContentEquals(data, brotliDecompressed)

    // Custom format string
    val custom = JsCompressor(JsCompressionFormat.Custom("deflate-raw"))
}
```

--------------------------------

### Async Brotli Compression and Decompression

Source: https://context7.com/ensody/kompressor/llms.txt

Demonstrates default and text-mode async Brotli compression and decompression using AsyncBrotliCompressor and AsyncBrotliDecompressor. Ensure coroutines are set up for async operations.

```kotlin
import com.ensody.kompressor.brotli.AsyncBrotliCompressor
import com.ensody.kompressor.brotli.AsyncBrotliDecompressor
import com.ensody.kompressor.brotli.BrotliCompressorMode
import com.ensody.kompressor.core.transform
import kotlinx.coroutines.runBlocking
import kotlin.random.Random
import kotlin.test.assertContentEquals

runBlocking {
    val testData = Random.nextBytes(64 * 1024)

    // Default async brotli roundtrip
    val compressed   = AsyncBrotliCompressor(compressionLevel = 4).transform(testData)
    val decompressed = AsyncBrotliDecompressor().transform(compressed)
    assertContentEquals(testData, decompressed)

    // Text mode for HTML/JSON
    val html = "<html><body><p>Hello World</p></body></html>".repeat(1000).encodeToByteArray()
    val compressedHtml = AsyncBrotliCompressor(
        compressionLevel = 6,
        mode = BrotliCompressorMode.TEXT,
        lgwin = 20,
    ).transform(html)
    val restoredHtml = AsyncBrotliDecompressor().transform(compressedHtml)
    assertContentEquals(html, restoredHtml)
}
```

--------------------------------

### Brotli Compression and Decompression with Different Modes

Source: https://context7.com/ensody/kompressor/llms.txt

Shows Brotli compression and decompression with default settings, faster compression, and text-optimized mode. Includes an interop test with CLI Brotli output.

```kotlin
import com.ensody.kompressor.brotli.BrotliCompressor
import com.ensody.kompressor.brotli.BrotliCompressorMode
import com.ensody.kompressor.brotli.BrotliDecompressor
import com.ensody.kompressor.core.transform
import kotlin.random.Random
import kotlin.test.assertContentEquals
import kotlin.test.assertEquals

val testData = Random.nextBytes(128 * 1024)

// --- Default compression (level 11 = maximum ratio) ---
val compressed   = BrotliCompressor().transform(testData)
val decompressed = BrotliDecompressor().transform(compressed)
assertContentEquals(testData, decompressed)

// --- Faster compression (level 3) ---
val fastCompressed = BrotliCompressor(compressionLevel = 3).transform(testData)
println("Level 11: ${compressed.size} bytes, level 3: ${fastCompressed.size} bytes")

// --- Text-optimised mode for JSON/HTML ---
val json = """{"key":"value","items":[1,2,3,4,5]}""".repeat(200).encodeToByteArray()
val textCompressed = BrotliCompressor(
    compressionLevel = 6,
    mode = BrotliCompressorMode.TEXT,
).transform(json)
val textRestored = BrotliDecompressor().transform(textCompressed)
assertContentEquals(json, textRestored)

// --- Known-value interop test (matches CLI brotli output) ---
val known = "hello compression world"
val fromCli = kotlin.io.encoding.Base64.decode("HxYA+KXL0Nje1CDoVAnrLHUQ")
assertEquals(known, BrotliDecompressor().transform(fromCli).decodeToString())
```

--------------------------------

### Add Kompressor Dependencies to build.gradle.kts

Source: https://github.com/ensody/kompressor/blob/main/README.md

Add the Kompressor Bill of Materials (BOM) and specific algorithm libraries to your project's build.gradle.kts file. Ensure you also include the Maven Central repository.

```kotlin
dependencies {
    // Add the BOM using the desired library version
    api(platform("com.ensody.kompressor:kompressor-bom:VERSION"))

    // zstd/Zstandard
    api("com.ensody.kompressor:kompressor-zstd--nativelib")
    // Select the native zstd library version from NativeBuilds
    api("com.ensody.nativebuilds:zstd-libzstd:1.5.7.4")
    // ZstdContentEncoder for Ktor (optional)
    api("com.ensody.kompressor:kompressor-zstd-ktor")

    // zlib (deflate & gzip)
    api("com.ensody.kompressor:kompressor-zlib--nativelib")
    // Select the native zlib library version from NativeBuilds
    api("com.ensody.nativebuilds:zlib-libz:1.3.1.4")
    // DeflateContentEncoder and GzipContentEncoder for Ktor (optional)
    api("com.ensody.kompressor:kompressor-zlib-ktor")

    // brotli
    api("com.ensody.kompressor:kompressor-brotli--nativelib")
    // Select the native brotli library version from NativeBuilds
    api("com.ensody.nativebuilds:brotli-libbrotlicommon:1.2.0")
    api("com.ensody.nativebuilds:brotli-libbrotlienc:1.2.0")
    api("com.ensody.nativebuilds:brotli-libbrotlidec:1.2.0")
    // BrotliContentEncoder for Ktor (optional)
    api("com.ensody.kompressor:kompressor-brotli-ktor")
}
```

```kotlin
subprojects {
    repositories {
        // ...
        mavenCentral()
        // ...
    }
}
```

--------------------------------

### Zlib Compression and Decompression

Source: https://context7.com/ensody/kompressor/llms.txt

Demonstrates the usage of ZlibCompressor and ZlibDecompressor with different Zlib formats (Zlib, Gzip, Raw) and the AutoDetectZlibGzip option for decompression.

```APIDOC
## ZlibCompressor / ZlibDecompressor

`ZlibCompressor` and `ZlibDecompressor` wrap the zlib native library and support three wire formats via the `ZlibFormat` enum: `Zlib` (RFC 1950 / deflate with header), `Gzip` (RFC 1952), and `Raw` (raw deflate, no header). `AutoDetectZlibGzip` can be used for decompression to transparently handle both zlib and gzip streams. Default compression level is `-1` (zlib default, equivalent to level 6).

### Usage Examples

```kotlin
import com.ensody.kompressor.core.transform
import com.ensody.kompressor.zlib.ZlibCompressor
import com.ensody.kompressor.zlib.ZlibDecompressor
import com.ensody.kompressor.zlib.ZlibFormat
import kotlin.random.Random
import kotlin.test.assertContentEquals
import kotlin.test.assertEquals

val testData = Random.nextBytes(64 * 1024)

// --- Zlib (deflate) format ---
val zlibCompressed = ZlibCompressor(ZlibFormat.Zlib, compressionLevel = 6).transform(testData)
val zlibRestored   = ZlibDecompressor(ZlibFormat.Zlib).transform(zlibCompressed)
assertContentEquals(testData, zlibRestored)

// --- Gzip format ---
val gzipCompressed = ZlibCompressor(ZlibFormat.Gzip, compressionLevel = 6).transform(testData)
val gzipRestored   = ZlibDecompressor(ZlibFormat.Gzip).transform(gzipCompressed)
assertContentEquals(testData, gzipRestored)

// --- Raw deflate (no header/trailer) ---
val rawCompressed = ZlibCompressor(ZlibFormat.Raw).transform(testData)
val rawRestored   = ZlibDecompressor(ZlibFormat.Raw).transform(rawCompressed)
assertContentEquals(testData, rawRestored)

// --- Auto-detect: handles both zlib and gzip transparently ---
val autoRestored = ZlibDecompressor(ZlibFormat.AutoDetectZlibGzip).transform(gzipCompressed)
assertContentEquals(testData, autoRestored)

// --- Known-value interop test (matches Python zlib.compress output) ---
val known = "hello compression world"
val fromPython = kotlin.io.encoding.Base64.decode("eJzLSM3JyVdIzs8tKEotLs7Mz1Mozy/KSQEAbW0JLw==")
assertEquals(known, ZlibDecompressor().transform(fromPython).decodeToString())
```
```

--------------------------------

### Ktor Client with Deflate Content Encoding

Source: https://context7.com/ensody/kompressor/llms.txt

Sets up a Ktor client to use Deflate (zlib/RFC 1950) compression with the ContentEncoding plugin. Requires the `kompressor-zlib-ktor` module. Default compression level is 6.

```kotlin
import com.ensody.kompressor.zlib.ktor.DeflateContentEncoder
import io.ktor.client.HttpClient
import io.ktor.client.engine.cio.CIO
import io.ktor.client.plugins.compression.ContentEncoding

val client = HttpClient(CIO) {
    install(ContentEncoding) {
        customEncoder(DeflateContentEncoder(compressionLevel = 6), quality = 0.9f)
    }
}
```

--------------------------------

### Async Zlib Compression/Decompression

Source: https://context7.com/ensody/kompressor/llms.txt

Utilize `AsyncZlibCompressor` and `AsyncZlibDecompressor` for asynchronous Zlib transformations, supporting various formats like Gzip and Zlib. The `ZlibFormat.AutoDetectZlibGzip` option allows for automatic detection during decompression.

```kotlin
import com.ensody.kompressor.zlib.AsyncZlibCompressor
import com.ensody.kompressor.zlib.AsyncZlibDecompressor
import com.ensody.kompressor.zlib.ZlibFormat
import com.ensody.kompressor.core.transform
import kotlinx.coroutines.runBlocking
import kotlin.random.Random
import kotlin.test.assertContentEquals

runBlocking {
    val testData = Random.nextBytes(64 * 1024)

    // Gzip async roundtrip
    val gzipped   = AsyncZlibCompressor(ZlibFormat.Gzip, compressionLevel = 6).transform(testData)
    val ungzipped = AsyncZlibDecompressor(ZlibFormat.Gzip).transform(gzipped)
    assertContentEquals(testData, ungzipped)

    // Auto-detect decompression
    val deflated = AsyncZlibCompressor(ZlibFormat.Zlib).transform(testData)
    val inflated = AsyncZlibDecompressor(ZlibFormat.AutoDetectZlibGzip).transform(deflated)
    assertContentEquals(testData, inflated)
}
```

--------------------------------

### Stream Data with kotlinx-io pipe()

Source: https://context7.com/ensody/kompressor/llms.txt

Use `pipe()` to wrap kotlinx-io sources or sinks for transparent data transformation. Transforms can be chained for complex pipelines. Requires the `kompressor-kotlinx-io` module.

```kotlin
import com.ensody.kompressor.kotlinx.io.pipe
import com.ensody.kompressor.zstd.ZstdCompressor
import com.ensody.kompressor.zstd.ZstdDecompressor
import com.ensody.kompressor.zlib.ZlibCompressor
import com.ensody.kompressor.zlib.ZlibDecompressor
import com.ensody.kompressor.zlib.ZlibFormat
import kotlinx.io.Buffer
import kotlinx.io.Source
import kotlinx.io.Sink
import kotlinx.io.buffered
import kotlinx.io.readByteArray
import kotlin.random.Random
import kotlin.test.assertContentEquals

val testData = Random.nextBytes(1024 * 1024 + 3)
val input = Buffer().apply { write(testData) }

// --- Compress via Source pipe (pull model) ---
// Build a pipeline: input → ZstdCompressor → ZstdDecompressor → sink
val roundtripSource: Source = input.pipe(ZstdCompressor(compressionLevel = 3)).pipe(ZstdDecompressor())
val result = roundtripSource.buffered().readByteArray()
assertContentEquals(testData, result)

// --- Compress via Sink pipe (push model) ---
val input2 = Buffer().apply { write(testData) }
val output = Buffer()
// Write into compressor → decompressor → output buffer
val sink: Sink = ZstdCompressor(compressionLevel = 3).pipe(ZstdDecompressor().pipe(output))
input2.transferTo(sink)
sink.close()  // flushes and finalises the compressed stream
assertContentEquals(testData, output.readByteArray())

// --- Streaming compress to a file sink ---
// val fileSource: RawSource = FileSystem.SYSTEM.source("input.bin".toPath())
// val fileSink: RawSink   = FileSystem.SYSTEM.sink("output.zst".toPath())
// fileSource.pipe(ZstdCompressor(compressionLevel = 3)).buffered().use { src ->
//     fileSink.buffered().use { dst -> src.transferTo(dst) }
// }

// --- Mixed algorithm pipeline (zlib compress → zstd decompress won't work, just an API demo) ---
val zlibInput = Buffer().apply { write(testData) }
val zlibOutput = Buffer()
val zlibSink: Sink = ZlibCompressor(ZlibFormat.Gzip).pipe(ZlibDecompressor(ZlibFormat.Gzip).pipe(zlibOutput))
zlibInput.transferTo(zlibSink)
zlibSink.close()
assertContentEquals(testData, zlibOutput.readByteArray())
```

--------------------------------

### Ktor Client with Gzip Content Encoding

Source: https://context7.com/ensody/kompressor/llms.txt

Configures a Ktor client to use Gzip compression via the ContentEncoding plugin. Requires the `kompressor-zlib-ktor` module. Default compression level is 6.

```kotlin
import com.ensody.kompressor.zlib.ktor.GzipContentEncoder
import io.ktor.client.HttpClient
import io.ktor.client.engine.cio.CIO
import io.ktor.client.plugins.compression.ContentEncoding

val client = HttpClient(CIO) {
    install(ContentEncoding) {
        customEncoder(GzipContentEncoder(compressionLevel = 6), quality = 1.0f)
    }
}
```

--------------------------------

### Ktor Client with Brotli Content Encoding

Source: https://context7.com/ensody/kompressor/llms.txt

Configures a Ktor client to prefer Brotli compression, falling back to Gzip, using the ContentEncoding plugin. Requires the `kompressor-brotli-ktor` module. Default Brotli compression level is 11.

```kotlin
import com.ensody.kompressor.brotli.ktor.BrotliContentEncoder
import io.ktor.client.HttpClient
import io.ktor.client.engine.cio.CIO
import io.ktor.client.plugins.compression.ContentEncoding

// Ktor client preferring brotli, falling back to gzip
val client = HttpClient(CIO) {
    install(ContentEncoding) {
        customEncoder(BrotliContentEncoder(compressionLevel = 4), quality = 1.0f)
        gzip(quality = 0.9f)
    }
}
```

--------------------------------

### Brotli Compression Modes

Source: https://context7.com/ensody/kompressor/llms.txt

Illustrates using BrotliCompressor with different optimization modes (GENERIC, TEXT, FONT) for various content types. Compression level can also be adjusted.

```kotlin
import com.ensody.kompressor.brotli.BrotliCompressor
import com.ensody.kompressor.brotli.BrotliDecompressor
import com.ensody.kompressor.brotli.BrotliCompressorMode
import com.ensody.kompressor.core.transform

val html = "<html><body>Hello World</body></html>".repeat(300).encodeToByteArray()
val font = ByteArray(10_000) { it.toByte() }  // simulated font binary

// GENERIC — default mode, no assumptions about input content
val genericCompressed = BrotliCompressor(compressionLevel = 6, mode = BrotliCompressorMode.GENERIC).transform(html)

// TEXT — optimised for UTF-8 text; best for HTML, JSON, XML, CSS
val textCompressed    = BrotliCompressor(compressionLevel = 6, mode = BrotliCompressorMode.TEXT).transform(html)

// FONT — optimised for WOFF 2.0 font files
val fontCompressed    = BrotliCompressor(compressionLevel = 11, mode = BrotliCompressorMode.FONT).transform(font)

println("Generic: ${genericCompressed.size}, Text: ${textCompressed.size}")
// Text mode is typically smaller for UTF-8 content

val restored = BrotliDecompressor().transform(textCompressed)
println(restored.decodeToString().take(40))
// Output: <html><body>Hello World</body></html><htm...
```

--------------------------------

### Stream Data Compression with Zstd and kotlinx-io

Source: https://github.com/ensody/kompressor/blob/main/README.md

Streams data for compression using ZstdCompressor and kotlinx-io's Source and Sink. Uses buffered operations for efficiency.

```kotlin
val source: Source = ...
val sink: Sink = ...
source.pipe(ZstdCompressor(compressionLevel = 3)).buffered().use { it.transferTo(sink) }
```

--------------------------------

### ByteArraySlice Buffer Abstraction

Source: https://context7.com/ensody/kompressor/llms.txt

Demonstrates creating and manipulating ByteArraySlice for managing readable and writable regions within a byte array. Useful for efficient buffer handling in data processing pipelines.

```kotlin
import com.ensody.kompressor.core.ByteArraySlice

// Create a writable slice (writeStart = 0, ready to be filled)
val outputSlice = ByteArraySlice(size = 4096)
println("Writable: ${outputSlice.remainingWrite}")  // 4096
println("Readable: ${outputSlice.remainingRead}")   // 0

// Wrap existing data as a readable slice (default writeStart = data.size)
val data = "some input".encodeToByteArray()
val inputSlice = ByteArraySlice(data)
println("Readable: ${inputSlice.remainingRead}")    // 10
println("Is full:  ${inputSlice.isFull}")           // true

// Copy readable bytes into another slice
val dest = ByteArraySlice(32)
inputSlice.readInto(dest, size = 4)
println("dest readable: ${dest.remainingRead}")     // 4
println("input remaining: ${inputSlice.remainingRead}") // 6

// Reset a slice's internal state, moving remaining readable data to offset 0
inputSlice.moveReadableToStart()
println("After reset, readStart=${inputSlice.readStart}") // 0
```

--------------------------------

### JsCompressor/JsDecompressor for Browser Compression Streams API

Source: https://context7.com/ensody/kompressor/llms.txt

Wraps the browser's native Compression Streams API for JS and WASM targets. Supports Gzip, Deflate, and DeflateRaw formats. Brotli and Zstd are experimental.

```kotlin
import com.ensody.kompressor.js.JsCompressor
import com.ensody.kompressor.js.JsDecompressor
import com.ensody.kompressor.js.JsCompressionFormat
import com.ensody.kompressor.core.transform
import com.ensody.kompressor.kotlinx.io.transform
import kotlinx.coroutines.test.runTest
import kotlinx.io.Buffer
import kotlinx.io.buffered
import kotlinx.io.readByteArray
import kotlin.test.assertContentEquals

// In-memory async roundtrip (JS/WASM targets)
runTest {
    val testData = "Hello from browser compression!".encodeToByteArray()

    val compressed:   ByteArray = JsCompressor(JsCompressionFormat.Gzip).transform(testData)
    val decompressed: ByteArray = JsDecompressor(JsCompressionFormat.Gzip).transform(compressed)
    assertContentEquals(testData, decompressed)
}

// Streaming via Buffer (large data)
runTest {
    val largeData = ByteArray(8192 * 4) { it.toByte() }
    val input = Buffer().apply { write(largeData) }

    val compressed = Buffer()
    JsCompressor(JsCompressionFormat.Deflate).transform(input, compressed)

    val decompressed = Buffer()
    JsDecompressor(JsCompressionFormat.Deflate).transform(compressed, decompressed)

    assertContentEquals(largeData, decompressed.readByteArray())
}

// @ExperimentalCompressionFormat formats (not available in all browsers)
// @OptIn(ExperimentalCompressionFormat::class)
// val brotliCompressor = JsCompressor(JsCompressionFormat.Brotli)
// val zstdCompressor   = JsCompressor(JsCompressionFormat.Zstd)
```

--------------------------------

### Stream Data Decompression with Zstd and kotlinx-io

Source: https://github.com/ensody/kompressor/blob/main/README.md

Streams data for decompression using ZstdDecompressor and kotlinx-io's Source and Sink. Uses buffered operations for efficiency.

```kotlin
source.pipe(ZstdDecompressor()).buffered().use { it.transferTo(sink) }
```

--------------------------------

### Ktor Client with Zstd Content Encoding

Source: https://context7.com/ensody/kompressor/llms.txt

Integrates Zstd compression into a Ktor client using the ContentEncoding plugin. Requires the `kompressor-zstd-ktor` module. This client will automatically send 'Accept-Encoding: zstd' and decompress zstd responses.

```kotlin
import com.ensody.kompressor.zstd.ktor.ZstdContentEncoder
import io.ktor.client.HttpClient
import io.ktor.client.engine.cio.CIO
import io.ktor.client.plugins.compression.ContentEncoding
import io.ktor.client.request.get
import io.ktor.client.statement.bodyAsText

// Ktor client with zstd content encoding
val client = HttpClient(CIO) {
    install(ContentEncoding) {
        // Quality 1.0f = prefer zstd over other encodings
        customEncoder(ZstdContentEncoder(compressionLevel = 1), quality = 1.0f)
    }
}

// The client will now:
//   - Send "Accept-Encoding: zstd" on every request
//   - Automatically decompress zstd-encoded responses
val response = client.get("https://api.example.com/data")
println(response.bodyAsText())

// Server-side: install on Ktor server application
// install(ContentEncoding) {
//     customEncoder(ZstdContentEncoder(compressionLevel = 3))
// }
```

--------------------------------

### AsyncSliceTransform for Coroutine-based Transformations

Source: https://context7.com/ensody/kompressor/llms.txt

Shows how to wrap a synchronous SliceTransform into an AsyncSliceTransform for use in asynchronous contexts, particularly on JS/WASM targets. The transform extension handles full in-memory async transformation.

```kotlin
import com.ensody.kompressor.core.AsyncSliceTransform
import com.ensody.kompressor.core.SliceTransform
import com.ensody.kompressor.core.toAsync
import com.ensody.kompressor.core.transform
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.runBlocking

// Wrap any synchronous SliceTransform for use in async contexts
val syncTransform: SliceTransform = XorTransform(0x42) // Assuming XorTransform is defined elsewhere
val asyncTransform: AsyncSliceTransform = syncTransform.toAsync(Dispatchers.Default)

runBlocking {
    val original = "async compression demo".encodeToByteArray()
    val encoded: ByteArray = asyncTransform.transform(original)
    val decoded: ByteArray = asyncTransform.transform(encoded)
    println(decoded.decodeToString())
    // Output: async compression demo
}
```

--------------------------------

### Custom XOR Transform Implementation and Usage

Source: https://context7.com/ensody/kompressor/llms.txt

Implement a custom `SliceTransform` for XOR encryption/decryption. The `transform` extension function simplifies in-memory transformations by managing buffer allocation.

```kotlin
import com.ensody.kompressor.core.ByteArraySlice
import com.ensody.kompressor.core.SliceTransform
import com.ensody.kompressor.core.transform
import kotlin.math.min

// Example: a custom XOR transform implementing SliceTransform
class XorTransform(val key: Byte) : SliceTransform {
    override fun transform(input: ByteArraySlice, output: ByteArraySlice, finish: Boolean) {
        // Signal if output buffer is too small for remaining input
        output.insufficient = output.remainingWrite < input.remainingRead
        val size = min(input.remainingRead, output.remainingWrite)
        repeat(size) {
            output.data[output.writeStart + it] = (input.data[input.readStart + it].toInt() xor key.toInt()).toByte()
        }
        input.readStart += size
        output.writeStart += size
    }
}

// Using the convenience extension for full in-memory transformation
val original = "Hello, Kompressor!".encodeToByteArray()
val xor = XorTransform(0x42)
val encoded: ByteArray = xor.transform(original)
val decoded: ByteArray = xor.transform(encoded)  // XOR is its own inverse
println(decoded.decodeToString())
// Output: Hello, Kompressor!
```

--------------------------------

### Async Zstd Compression/Decompression

Source: https://context7.com/ensody/kompressor/llms.txt

Use `AsyncZstdCompressor` and `AsyncZstdDecompressor` for non-blocking Zstd transformations. On non-JS platforms, these are wrappers around synchronous versions. On JS/WASM, they use `Dispatchers.Default` to avoid blocking the main thread. Supports dictionaries for context-specific compression.

```kotlin
import com.ensody.kompressor.zstd.AsyncZstdCompressor
import com.ensody.kompressor.zstd.AsyncZstdDecompressor
import com.ensody.kompressor.core.transform
import kotlinx.coroutines.runBlocking
import kotlin.random.Random
import kotlin.test.assertContentEquals

runBlocking {
    val testData = Random.nextBytes(64 * 1024)

    // Async in-memory roundtrip
    val compressed:   ByteArray = AsyncZstdCompressor(compressionLevel = 3).transform(testData)
    val decompressed: ByteArray = AsyncZstdDecompressor().transform(compressed)
    assertContentEquals(testData, decompressed)

    // With dictionary
    val dict = "shared context".encodeToByteArray()
    val compressedWithDict = AsyncZstdCompressor(compressionLevel = 3, dictionary = dict).transform(testData)
    val restoredWithDict   = AsyncZstdDecompressor(dictionary = dict).transform(compressedWithDict)
    assertContentEquals(testData, restoredWithDict)
}
```

--------------------------------

### Build Zstd Decompression Pipe with Sink

Source: https://github.com/ensody/kompressor/blob/main/README.md

Constructs a Zstd decompression pipe directly with a sink, allowing data to be transferred from a source to the decompressor.

```kotlin
ZstdDecompressor().pipe(sink).buffered().use { decompressor ->
    source.transferTo(decompressor)
}
```

--------------------------------

### Brotli Compression and Decompression

Source: https://context7.com/ensody/kompressor/llms.txt

Provides Brotli compression and decompression functionalities with options for compression level, mode (GENERIC, TEXT, FONT), and window size.

```APIDOC
## BrotliCompressor / BrotliDecompressor

`BrotliCompressor` and `BrotliDecompressor` provide Brotli compression. Compression level ranges 0–11 (default 11, maximum compression). The `mode` parameter accepts `BrotliCompressorMode.GENERIC` (default), `TEXT` (optimised for UTF-8 text), or `FONT` (WOFF 2.0). The `lgwin` parameter (default 22) controls the LZ77 sliding window size (log₂ of window bytes). Available on Android, JVM, and all native platforms.

### Usage Examples

```kotlin
import com.ensody.kompressor.brotli.BrotliCompressor
import com.ensody.kompressor.brotli.BrotliCompressorMode
import com.ensody.kompressor.brotli.BrotliDecompressor
import com.ensody.kompressor.core.transform
import kotlin.random.Random
import kotlin.test.assertContentEquals
import kotlin.test.assertEquals

val testData = Random.nextBytes(128 * 1024)

// --- Default compression (level 11 = maximum ratio) ---
val compressed   = BrotliCompressor().transform(testData)
val decompressed = BrotliDecompressor().transform(compressed)
assertContentEquals(testData, decompressed)

// --- Faster compression (level 3) ---
val fastCompressed = BrotliCompressor(compressionLevel = 3).transform(testData)
println("Level 11: ${compressed.size} bytes, level 3: ${fastCompressed.size} bytes")

// --- Text-optimised mode for JSON/HTML ---
val json = """{"key":"value","items":[1,2,3,4,5]}""".repeat(200).encodeToByteArray()
val textCompressed = BrotliCompressor(
    compressionLevel = 6,
    mode = BrotliCompressorMode.TEXT,
).transform(json)
val textRestored = BrotliDecompressor().transform(textCompressed)
assertContentEquals(json, textRestored)

// --- Known-value interop test (matches CLI brotli output) ---
val known = "hello compression world"
val fromCli = kotlin.io.encoding.Base64.decode("HxYA+KXL0Nje1CDoVAnrLHUQ")
assertEquals(known, BrotliDecompressor().transform(fromCli).decodeToString())
```
```

--------------------------------

### SliceTransform.toAsync() for Synchronous to Async Conversion

Source: https://context7.com/ensody/kompressor/llms.txt

Promotes any synchronous SliceTransform to an AsyncSliceTransform by running blocking calls in a coroutine. Defaults to Dispatchers.Default and is used internally by Async*Compressor factory functions on non-JS platforms.

```kotlin
import com.ensody.kompressor.core.SliceTransform
import com.ensody.kompressor.core.AsyncSliceTransform
import com.ensody.kompressor.core.toAsync
import com.ensody.kompressor.core.transform
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.runBlocking

// Promote any SliceTransform to AsyncSliceTransform
val syncTransform: SliceTransform = XorTransform(0xFF.toByte())
val asyncTransform: AsyncSliceTransform = syncTransform.toAsync(Dispatchers.IO)

runBlocking {
    val data = "convert sync to async".encodeToByteArray()
    val encoded = asyncTransform.transform(data)
    val decoded = asyncTransform.transform(encoded)
    println(decoded.decodeToString())
    // Output: convert sync to async
}
```

--------------------------------

### Compress and Decompress ByteArray with Zstd

Source: https://github.com/ensody/kompressor/blob/main/README.md

Compresses and decompresses a ByteArray using ZstdCompressor and ZstdDecompressor. Ensure the data fits in RAM for this method.

```kotlin
val testData: ByteArray = Random.nextBytes(128 * 1024 + 3)
val compressed: ByteArray = ZstdCompressor(compressionLevel = 3).transform(testData)
val decompressed: ByteArray = ZstdDecompressor().transform(compressed)
assertContentEquals(testData, decompressed)
```

--------------------------------

### StreamCompressor/StreamDecompressor for JVM InputStream/OutputStream Bridge

Source: https://context7.com/ensody/kompressor/llms.txt

Wraps Java InputStream or OutputStream-based compressors/decompressors into a SliceTransform for JVM/Android. Enables third-party JVM compression libraries to integrate with Kompressor's streaming pipeline.

```kotlin
import com.ensody.kompressor.core.StreamCompressor
import com.ensody.kompressor.core.StreamDecompressor
import com.ensody.kompressor.core.transform
import com.ensody.kompressor.kotlinx.io.pipe
import kotlinx.io.Buffer
import kotlinx.io.buffered
import kotlinx.io.readByteArray
import java.util.zip.GZIPInputStream
import java.util.zip.GZIPOutputStream
import kotlin.test.assertContentEquals

// Wrap standard JDK GZIPOutputStream / GZIPInputStream as SliceTransform
val gzipCompressor   = StreamCompressor   { outputStream -> GZIPOutputStream(outputStream) }
val gzipDecompressor = StreamDecompressor { inputStream  -> GZIPInputStream(inputStream)   }

val testData = "bridge to Java streams".repeat(500).encodeToByteArray()

// In-memory roundtrip via convenience extension
val compressed   = gzipCompressor.transform(testData)
val decompressed = gzipDecompressor.transform(compressed)
assertContentEquals(testData, decompressed)

// Streaming roundtrip via pipe
val input = Buffer().apply { write(testData) }
val output = Buffer()
val sink = gzipCompressor.pipe(gzipDecompressor.pipe(output))
input.transferTo(sink)
sink.close()
assertContentEquals(testData, output.readByteArray())
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.