Yet Another LLM Rant(overengineer.dev)

    init(algorithm: compression_algorithm = COMPRESSION_LZFSE) {
        self.algo = algorithm
    }

    func append(_ input: Data, isFinal: Bool, outChunkSize: Int = 64 * 1024) -> [Data] {
        if !isInitialized {
            let status = compression_stream_init(&stream, COMPRESSION_STREAM_ENCODE, algo)
            precondition(status != COMPRESSION_STATUS_ERROR, "compression_stream_init failed")
            isInitialized = true
        }

        var outputs: [Data] = []
        input.withUnsafeBytes { (srcBuf: UnsafeRawBufferPointer) in
            var flags: Int32 = isFinal ? Int32(COMPRESSION_STREAM_FINALIZE.rawValue) : 0
            stream.src_ptr = srcBuf.bindMemory(to: UInt8.self).baseAddress
            stream.src_size = srcBuf.count

            var out = Data(count: outChunkSize)
            out.withUnsafeMutableBytes { dstBuf in
                while true {
                    stream.dst_ptr = dstBuf.bindMemory(to: UInt8.self).baseAddress
                    stream.dst_size = dstBuf.count

                    let status = compression_stream_process(&stream, flags)
                    let produced = dstBuf.count - stream.dst_size
                    if produced > 0 {
                        outputs.append(Data(bytes: dstBuf.baseAddress!, count: produced))
                    }

                    if status == COMPRESSION_STATUS_OK && stream.src_size == 0 && stream.dst_size > 0 {
                        break // need more input to continue
                    } else if status == COMPRESSION_STATUS_OK && stream.dst_size == 0 {
                        // output buffer filled; loop to drain more
                        continue
                    } else if status == COMPRESSION_STATUS_END {
                        break
                    } else if status == COMPRESSION_STATUS_ERROR {
                        preconditionFailure("compression_stream_process failed")
                    } else {
                        // Shouldn’t happen
                        break
                    }
                }
            }
        }
        return outputs
    }

    deinit {
        if isInitialized {
            compression_stream_destroy(&stream)
        }
    }