@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/Combine/Subscription.swift

@@ -0,0 +1,22 @@
+//
+//  Subscription.swift
+//  OpenCombine
+//
+//  Created by Sergej Jaskiewicz on 10.06.2019.
+//
+
+/// A protocol representing the connection of a subscriber to a publisher.
+///
+/// Subscriptions are class constrained because a `Subscription` has identity -
+/// defined by the moment in time a particular subscriber attached to a publisher.
+/// Canceling a `Subscription` must be thread-safe.
+///
+/// You can only cancel a `Subscription` once.
+///
+/// Canceling a subscription frees up any resources previously allocated by attaching
+/// the `Subscriber`.
+public protocol Subscription: Cancellable, CustomCombineIdentifierConvertible {
+
+    /// Tells a publisher that it may send more values to the subscriber.
+    func request(_ demand: Subscribers.Demand)
+}

package/Sources/Combine/Subscriptions.swift

@@ -0,0 +1,42 @@
+//
+//  Subscriptions.swift
+//
+//
+//  Created by Sergej Jaskiewicz on 26.06.2019.
+//
+
+/// A namespace for symbols related to subscriptions.
+public enum Subscriptions {}
+
+extension Subscriptions {
+
+    /// Returns the “empty” subscription.
+    ///
+    /// Use the empty subscription when you need a `Subscription` that ignores requests
+    /// and cancellation.
+    public static let empty: Subscription = _EmptySubscription.singleton
+}
+
+extension Subscriptions {
+    private struct _EmptySubscription: Subscription,
+                                       CustomStringConvertible,
+                                       CustomReflectable,
+                                       CustomPlaygroundDisplayConvertible
+    {
+        let combineIdentifier = CombineIdentifier()
+
+        private init() {}
+
+        func request(_ demand: Subscribers.Demand) {}
+
+        func cancel() {}
+
+        fileprivate static let singleton = _EmptySubscription()
+
+        var description: String { return "Empty" }
+
+        var customMirror: Mirror { return Mirror(self, children: EmptyCollection()) }
+
+        var playgroundDescription: Any { return description }
+    }
+}

package/Sources/Combine/SwiftUIObservation.swift

@@ -0,0 +1,10 @@
+// The browser's Combine is OpenCombine (https://github.com/OpenCombine/OpenCombine,
+// MIT; LICENSE), built as the module `Combine` without its `ObservableObject`
+// and `@Published`: the SwiftUI shim has its own, which views observe, and
+// they are re-exported here, so `import Combine` alone brings them as on
+// Apple platforms. `#if WASI` selects OpenCombine's single-threaded locks on
+// every platform (the browser has one thread). See docs/ops-protocol.md, "Combine".
+
+@_exported import protocol SwiftUI.ObservableObject
+@_exported import class SwiftUI.ObservableObjectPublisher
+@_exported import struct SwiftUI.Published

package/Sources/Combine/_Introspection.swift

@@ -0,0 +1,107 @@
+//
+//  _Introspection.swift
+//  
+//
+//  Created by Sergej Jaskiewicz on 27.09.2020.
+//
+
+// swiftlint:disable:next type_name
+public protocol _Introspection: AnyObject {
+
+     func willReceive<Upstream: Publisher, Downstream: Subscriber>(
+         publisher: Upstream,
+         subscriber: Downstream
+     ) where Upstream.Failure == Downstream.Failure, Upstream.Output == Downstream.Input
+
+     func didReceive<Upstream: Publisher, Downstream: Subscriber>(
+         publisher: Upstream,
+         subscriber: Downstream
+     ) where Upstream.Failure == Downstream.Failure, Upstream.Output == Downstream.Input
+
+     func willReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                              subscription: Subscription)
+
+     func didReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                             subscription: Subscription)
+
+     func willReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                              input: Downstream.Input)
+
+     func didReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                             input: Downstream.Input,
+                                             resultingDemand: Subscribers.Demand)
+
+     func willReceive<Downstream: Subscriber>(
+         subscriber: Downstream,
+         completion: Subscribers.Completion<Downstream.Failure>
+     )
+
+     func didReceive<Downstream: Subscriber>(
+         subscriber: Downstream,
+         completion: Subscribers.Completion<Downstream.Failure>
+     )
+
+     func willRequest(subscription: Subscription, _ demand: Subscribers.Demand)
+
+     func didRequest(subscription: Subscription, _ demand: Subscribers.Demand)
+
+     func willCancel(subscription: Subscription)
+
+     func didCancel(subscription: Subscription)
+ }
+
+extension _Introspection {
+
+    public func willReceive<Upstream: Publisher, Downstream: Subscriber>(
+        publisher: Upstream,
+        subscriber: Downstream
+    ) where Upstream.Failure == Downstream.Failure, Upstream.Output == Downstream.Input {}
+
+    public func didReceive<Upstream: Publisher, Downstream: Subscriber>(
+        publisher: Upstream,
+        subscriber: Downstream
+    ) where Upstream.Failure == Downstream.Failure, Upstream.Output == Downstream.Input {}
+
+    public func willReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                                    subscription: Subscription) {}
+
+    public func didReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                                   subscription: Subscription) {}
+
+    public func willReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                                    input: Downstream.Input) {}
+
+    public func didReceive<Downstream: Subscriber>(subscriber: Downstream,
+                                                   input: Downstream.Input,
+                                                   resultingDemand: Subscribers.Demand) {}
+
+    public func willReceive<Downstream: Subscriber>(
+        subscriber: Downstream,
+        completion: Subscribers.Completion<Downstream.Failure>
+    ) {}
+
+    public func didReceive<Downstream: Subscriber>(
+        subscriber: Downstream,
+        completion: Subscribers.Completion<Downstream.Failure>
+    ) {}
+
+    public func willRequest(subscription: Subscription, _ demand: Subscribers.Demand) {}
+
+    public func didRequest(subscription: Subscription, _ demand: Subscribers.Demand) {}
+
+    public func willCancel(subscription: Subscription) {}
+
+    public func didCancel(subscription: Subscription) {}
+
+    public func enable() {
+        DebugHook.enable(self)
+    }
+
+    public func disable() {
+        DebugHook.disable(self)
+    }
+
+    public var isEnabled: Bool {
+        return DebugHook.handlerIsEnabled(self)
+    }
+}

package/Sources/CommonCrypto/CommonCrypto.swift

@@ -0,0 +1,80 @@
+// `import CommonCrypto` for the browser: the digest functions of
+// CommonDigest.h, as packages call them from Swift (TelemetryDeck hashes its
+// user identifiers with `CC_SHA256`). The hashing is CryptoKit's.
+
+import CryptoKit
+
+public typealias CC_LONG = UInt32
+
+public let CC_MD5_DIGEST_LENGTH: Int32 = 16
+public let CC_SHA1_DIGEST_LENGTH: Int32 = 20
+public let CC_SHA256_DIGEST_LENGTH: Int32 = 32
+public let CC_SHA384_DIGEST_LENGTH: Int32 = 48
+public let CC_SHA512_DIGEST_LENGTH: Int32 = 64
+public let CC_MD5_BLOCK_BYTES: Int32 = 64
+public let CC_SHA1_BLOCK_BYTES: Int32 = 64
+public let CC_SHA256_BLOCK_BYTES: Int32 = 64
+public let CC_SHA384_BLOCK_BYTES: Int32 = 128
+public let CC_SHA512_BLOCK_BYTES: Int32 = 128
+
+/// Hashes `len` bytes at `data` and writes the digest to `md`, which it returns.
+func _digest<H: HashFunction>(_ hasher: H.Type, _ data: UnsafeRawPointer?, _ len: CC_LONG, _ md: UnsafeMutablePointer<UInt8>?) -> UnsafeMutablePointer<UInt8>? {
+    var hasher = H()
+    if let data { hasher.update(bufferPointer: UnsafeRawBufferPointer(start: data, count: Int(len))) }
+    return _write(hasher.finalize(), to: md)
+}
+
+func _write<D: Digest>(_ digest: D, to md: UnsafeMutablePointer<UInt8>?) -> UnsafeMutablePointer<UInt8>? {
+    guard let md else { return nil }
+    for (i, byte) in digest.enumerated() { md[i] = byte }
+    return md
+}
+
+@discardableResult public func CC_MD5(_ data: UnsafeRawPointer?, _ len: CC_LONG, _ md: UnsafeMutablePointer<UInt8>?) -> UnsafeMutablePointer<UInt8>? { _digest(Insecure.MD5.self, data, len, md) }
+@discardableResult public func CC_SHA1(_ data: UnsafeRawPointer?, _ len: CC_LONG, _ md: UnsafeMutablePointer<UInt8>?) -> UnsafeMutablePointer<UInt8>? { _digest(Insecure.SHA1.self, data, len, md) }
+@discardableResult public func CC_SHA256(_ data: UnsafeRawPointer?, _ len: CC_LONG, _ md: UnsafeMutablePointer<UInt8>?) -> UnsafeMutablePointer<UInt8>? { _digest(SHA256.self, data, len, md) }
+@discardableResult public func CC_SHA384(_ data: UnsafeRawPointer?, _ len: CC_LONG, _ md: UnsafeMutablePointer<UInt8>?) -> UnsafeMutablePointer<UInt8>? { _digest(SHA384.self, data, len, md) }
+@discardableResult public func CC_SHA512(_ data: UnsafeRawPointer?, _ len: CC_LONG, _ md: UnsafeMutablePointer<UInt8>?) -> UnsafeMutablePointer<UInt8>? { _digest(SHA512.self, data, len, md) }
+
+// MARK: - Incremental hashing
+
+/// A hash in progress, as `CC_SHA256_CTX` and its kin hold one.
+public struct _CCContext<H: HashFunction>: Sendable {
+    var hasher = H()
+    public init() {}
+}
+
+public typealias CC_MD5_CTX = _CCContext<Insecure.MD5>
+public typealias CC_SHA1_CTX = _CCContext<Insecure.SHA1>
+public typealias CC_SHA256_CTX = _CCContext<SHA256>
+public typealias CC_SHA512_CTX = _CCContext<SHA512>
+
+func _init<H>(_ c: UnsafeMutablePointer<_CCContext<H>>?) -> Int32 {
+    c?.pointee = _CCContext()
+    return 1
+}
+
+func _update<H>(_ c: UnsafeMutablePointer<_CCContext<H>>?, _ data: UnsafeRawPointer?, _ len: CC_LONG) -> Int32 {
+    guard let c, let data else { return 1 }
+    c.pointee.hasher.update(bufferPointer: UnsafeRawBufferPointer(start: data, count: Int(len)))
+    return 1
+}
+
+func _final<H>(_ md: UnsafeMutablePointer<UInt8>?, _ c: UnsafeMutablePointer<_CCContext<H>>?) -> Int32 {
+    guard let c else { return 0 }
+    _ = _write(c.pointee.hasher.finalize(), to: md)
+    return 1
+}
+
+@discardableResult public func CC_MD5_Init(_ c: UnsafeMutablePointer<CC_MD5_CTX>?) -> Int32 { _init(c) }
+@discardableResult public func CC_MD5_Update(_ c: UnsafeMutablePointer<CC_MD5_CTX>?, _ data: UnsafeRawPointer?, _ len: CC_LONG) -> Int32 { _update(c, data, len) }
+@discardableResult public func CC_MD5_Final(_ md: UnsafeMutablePointer<UInt8>?, _ c: UnsafeMutablePointer<CC_MD5_CTX>?) -> Int32 { _final(md, c) }
+@discardableResult public func CC_SHA1_Init(_ c: UnsafeMutablePointer<CC_SHA1_CTX>?) -> Int32 { _init(c) }
+@discardableResult public func CC_SHA1_Update(_ c: UnsafeMutablePointer<CC_SHA1_CTX>?, _ data: UnsafeRawPointer?, _ len: CC_LONG) -> Int32 { _update(c, data, len) }
+@discardableResult public func CC_SHA1_Final(_ md: UnsafeMutablePointer<UInt8>?, _ c: UnsafeMutablePointer<CC_SHA1_CTX>?) -> Int32 { _final(md, c) }
+@discardableResult public func CC_SHA256_Init(_ c: UnsafeMutablePointer<CC_SHA256_CTX>?) -> Int32 { _init(c) }
+@discardableResult public func CC_SHA256_Update(_ c: UnsafeMutablePointer<CC_SHA256_CTX>?, _ data: UnsafeRawPointer?, _ len: CC_LONG) -> Int32 { _update(c, data, len) }
+@discardableResult public func CC_SHA256_Final(_ md: UnsafeMutablePointer<UInt8>?, _ c: UnsafeMutablePointer<CC_SHA256_CTX>?) -> Int32 { _final(md, c) }
+@discardableResult public func CC_SHA512_Init(_ c: UnsafeMutablePointer<CC_SHA512_CTX>?) -> Int32 { _init(c) }
+@discardableResult public func CC_SHA512_Update(_ c: UnsafeMutablePointer<CC_SHA512_CTX>?, _ data: UnsafeRawPointer?, _ len: CC_LONG) -> Int32 { _update(c, data, len) }
+@discardableResult public func CC_SHA512_Final(_ md: UnsafeMutablePointer<UInt8>?, _ c: UnsafeMutablePointer<CC_SHA512_CTX>?) -> Int32 { _final(md, c) }

package/Sources/Compression/Compression.swift

@@ -0,0 +1,365 @@
+// `import Compression` for the browser: Apple's Compression framework as
+// Swift code calls it, for its zlib algorithm (raw DEFLATE, as on Apple
+// platforms), computed for real in Swift (Deflate.swift): the buffer
+// functions (`compression_encode_buffer` / `compression_decode_buffer`), the
+// `compression_stream` functions, and the Swift overlay's `InputFilter` and
+// `OutputFilter`. The other algorithms (LZFSE, LZ4, LZMA, Brotli, LZBitmap)
+// have no codec here: their constants exist, `Algorithm(rawValue:)` answers
+// nil for them so code that probes for one falls back (RevenueCat then asks
+// its server for gzip instead of Brotli), and using one fails the way a
+// failed call fails on Apple platforms (0 bytes, an error status, a thrown
+// `FilterError`). zlib's own `inflate` API is in Zlib.swift.
+
+import Foundation
+
+// MARK: - The C API (compression.h)
+
+/// An algorithm, as compression.h's enum imports into Swift.
+public struct compression_algorithm: RawRepresentable, Equatable, Hashable, Sendable {
+    public var rawValue: UInt32
+    public init(_ rawValue: UInt32) { self.rawValue = rawValue }
+    public init(rawValue: UInt32) { self.rawValue = rawValue }
+}
+
+/// DEFLATE without the zlib header or trailer (RFC 1951). The one algorithm
+/// the browser has a codec for.
+public let COMPRESSION_ZLIB = compression_algorithm(0x205)
+/// No codec in the browser: encoding and decoding fail.
+public let COMPRESSION_LZ4 = compression_algorithm(0x100)
+/// No codec in the browser: encoding and decoding fail.
+public let COMPRESSION_LZ4_RAW = compression_algorithm(0x101)
+/// No codec in the browser: encoding and decoding fail.
+public let COMPRESSION_LZMA = compression_algorithm(0x306)
+/// No codec in the browser: encoding and decoding fail.
+public let COMPRESSION_LZFSE = compression_algorithm(0x801)
+/// No codec in the browser: encoding and decoding fail.
+public let COMPRESSION_LZBITMAP = compression_algorithm(0x702)
+/// No codec in the browser: encoding and decoding fail.
+public let COMPRESSION_BROTLI = compression_algorithm(0xb02)
+
+public struct compression_status: RawRepresentable, Equatable, Hashable, Sendable {
+    public var rawValue: Int32
+    public init(_ rawValue: Int32) { self.rawValue = rawValue }
+    public init(rawValue: Int32) { self.rawValue = rawValue }
+}
+
+public let COMPRESSION_STATUS_OK = compression_status(0)
+public let COMPRESSION_STATUS_ERROR = compression_status(-1)
+public let COMPRESSION_STATUS_END = compression_status(1)
+
+public struct compression_stream_operation: RawRepresentable, Equatable, Hashable, Sendable {
+    public var rawValue: UInt32
+    public init(_ rawValue: UInt32) { self.rawValue = rawValue }
+    public init(rawValue: UInt32) { self.rawValue = rawValue }
+}
+
+public let COMPRESSION_STREAM_ENCODE = compression_stream_operation(0)
+public let COMPRESSION_STREAM_DECODE = compression_stream_operation(1)
+
+public struct compression_stream_flags: RawRepresentable, Equatable, Hashable, Sendable {
+    public var rawValue: UInt32
+    public init(_ rawValue: UInt32) { self.rawValue = rawValue }
+    public init(rawValue: UInt32) { self.rawValue = rawValue }
+}
+
+/// Passed to `compression_stream_process` when no more input follows.
+public let COMPRESSION_STREAM_FINALIZE = compression_stream_flags(1)
+
+/// The scratch space the buffer functions want: none in the browser.
+public func compression_encode_scratch_buffer_size(_ algorithm: compression_algorithm) -> Int { 0 }
+/// The scratch space the buffer functions want: none in the browser.
+public func compression_decode_scratch_buffer_size(_ algorithm: compression_algorithm) -> Int { 0 }
+
+/// Compresses `src_size` bytes into `dst_buffer`. Returns the compressed
+/// size, or 0 if it does not fit in `dst_size` bytes or the algorithm has no
+/// codec in the browser.
+public func compression_encode_buffer(
+    _ dst_buffer: UnsafeMutablePointer<UInt8>, _ dst_size: Int,
+    _ src_buffer: UnsafePointer<UInt8>, _ src_size: Int,
+    _ scratch_buffer: UnsafeMutableRawPointer?, _ algorithm: compression_algorithm
+) -> Int {
+    guard algorithm == COMPRESSION_ZLIB else { return 0 }
+    let encoded = _Deflate.deflate(Array(UnsafeBufferPointer(start: src_buffer, count: src_size)))
+    guard encoded.count <= dst_size else { return 0 }
+    encoded.withUnsafeBufferPointer { dst_buffer.update(from: $0.baseAddress!, count: encoded.count) }
+    return encoded.count
+}
+
+/// Decompresses `src_size` bytes into `dst_buffer`. Returns the
+/// decompressed size; when that exceeds `dst_size`, the first `dst_size`
+/// bytes are written and `dst_size` is returned (as on Apple platforms).
+/// Returns 0 for invalid or truncated input, or an algorithm with no codec in
+/// the browser.
+public func compression_decode_buffer(
+    _ dst_buffer: UnsafeMutablePointer<UInt8>, _ dst_size: Int,
+    _ src_buffer: UnsafePointer<UInt8>, _ src_size: Int,
+    _ scratch_buffer: UnsafeMutableRawPointer?, _ algorithm: compression_algorithm
+) -> Int {
+    guard algorithm == COMPRESSION_ZLIB,
+          let decoded = try? _Deflate.inflate(Array(UnsafeBufferPointer(start: src_buffer, count: src_size))).output
+    else { return 0 }
+    let count = min(decoded.count, dst_size)
+    decoded.withUnsafeBufferPointer { if count > 0 { dst_buffer.update(from: $0.baseAddress!, count: count) } }
+    return count
+}
+
+/// A stream in progress, as compression.h declares it: the caller points
+/// `src_ptr` / `dst_ptr` at its buffers and `compression_stream_process`
+/// advances them.
+public struct compression_stream {
+    public var dst_ptr: UnsafeMutablePointer<UInt8>!
+    public var dst_size: Int
+    public var src_ptr: UnsafePointer<UInt8>!
+    public var src_size: Int
+    public var state: UnsafeMutableRawPointer!
+
+    public init() {
+        dst_ptr = nil
+        dst_size = 0
+        src_ptr = nil
+        src_size = 0
+        state = nil
+    }
+
+    public init(dst_ptr: UnsafeMutablePointer<UInt8>!, dst_size: Int, src_ptr: UnsafePointer<UInt8>!, src_size: Int, state: UnsafeMutableRawPointer!) {
+        self.dst_ptr = dst_ptr
+        self.dst_size = dst_size
+        self.src_ptr = src_ptr
+        self.src_size = src_size
+        self.state = state
+    }
+}
+
+/// Starts a stream. `COMPRESSION_STATUS_ERROR` for an algorithm with no codec
+/// in the browser.
+public func compression_stream_init(
+    _ stream: UnsafeMutablePointer<compression_stream>,
+    _ operation: compression_stream_operation,
+    _ algorithm: compression_algorithm
+) -> compression_status {
+    guard algorithm == COMPRESSION_ZLIB, operation == COMPRESSION_STREAM_ENCODE || operation == COMPRESSION_STREAM_DECODE else {
+        return COMPRESSION_STATUS_ERROR
+    }
+    let codec = _StreamCodec(encoding: operation == COMPRESSION_STREAM_ENCODE, format: .raw)
+    stream.pointee.state = Unmanaged.passRetained(codec).toOpaque()
+    return COMPRESSION_STATUS_OK
+}
+
+/// Consumes input from `src_ptr` and writes output to `dst_ptr`, advancing
+/// both. Returns `COMPRESSION_STATUS_END` once the whole stream has been
+/// written out. The encoder writes its output once it is finalized; the
+/// decoder writes it once the input holds the whole stream.
+public func compression_stream_process(_ stream: UnsafeMutablePointer<compression_stream>, _ flags: Int32) -> compression_status {
+    guard let state = stream.pointee.state else { return COMPRESSION_STATUS_ERROR }
+    let codec = Unmanaged<_StreamCodec>.fromOpaque(state).takeUnretainedValue()
+    let input = stream.pointee.src_size > 0 ? UnsafeRawBufferPointer(start: stream.pointee.src_ptr, count: stream.pointee.src_size) : UnsafeRawBufferPointer(start: nil, count: 0)
+    let finalize = UInt32(bitPattern: flags) & COMPRESSION_STREAM_FINALIZE.rawValue != 0
+    let consumed: Int
+    do {
+        consumed = try codec.consume(input, finish: finalize)
+    } catch {
+        return COMPRESSION_STATUS_ERROR
+    }
+    stream.pointee.src_ptr = stream.pointee.src_ptr.map { $0 + consumed }
+    stream.pointee.src_size -= consumed
+    if finalize, !codec.finished { return COMPRESSION_STATUS_ERROR } // the input ended mid-stream
+    let written = codec.drain(into: stream.pointee.dst_ptr, capacity: stream.pointee.dst_size)
+    stream.pointee.dst_ptr = stream.pointee.dst_ptr.map { $0 + written }
+    stream.pointee.dst_size -= written
+    return codec.isDone ? COMPRESSION_STATUS_END : COMPRESSION_STATUS_OK
+}
+
+/// Frees what `compression_stream_init` allocated.
+public func compression_stream_destroy(_ stream: UnsafeMutablePointer<compression_stream>) -> compression_status {
+    guard let state = stream.pointee.state else { return COMPRESSION_STATUS_ERROR }
+    Unmanaged<_StreamCodec>.fromOpaque(state).release()
+    stream.pointee.state = nil
+    return COMPRESSION_STATUS_OK
+}
+
+// MARK: - Streaming over whole-buffer codecs
+
+/// A stream over the whole-buffer codecs: input accumulates until it holds
+/// the whole stream (decoding) or until it is finalized (encoding); then the
+/// output is handed out in as many pieces as the caller's buffers need. A
+/// decoder retries only when the input has doubled since the last attempt,
+/// when no new input came, or when finishing, so the work stays linear.
+final class _StreamCodec {
+    let encoding: Bool
+    let format: _Deflate.Format
+    var input: [UInt8] = []
+    var output: [UInt8] = []
+    var outputPosition = 0
+    var finished = false
+    var attemptedAt = 0
+    /// zlib's running checksum (`z_stream.adler`) of the decoded output, once known.
+    var checksum: UInt32 = 0
+
+    init(encoding: Bool, format: _Deflate.Format) {
+        self.encoding = encoding
+        self.format = format
+    }
+
+    var isDone: Bool { finished && outputPosition == output.count }
+
+    /// Takes `bytes` and runs the codec if it is time to. Returns how many of
+    /// `bytes` were used: input after the end of a decoded stream is left over.
+    func consume(_ bytes: UnsafeRawBufferPointer, finish: Bool) throws(_Deflate.Failure) -> Int {
+        guard !finished else { return 0 }
+        input.append(contentsOf: bytes)
+        if encoding {
+            if finish {
+                output = _Deflate.deflate(input)
+                input = []
+                finished = true
+            }
+            return bytes.count
+        }
+        guard finish || bytes.isEmpty || input.count >= max(1, attemptedAt * 2) else { return bytes.count }
+        attemptedAt = input.count
+        do {
+            let (decoded, end) = try _Deflate.inflate(input, format: format)
+            output = decoded
+            finished = true
+            if format != .raw {
+                let gzip = format == .gzip || (format == .automatic && input.first == 0x1f)
+                checksum = gzip ? _Deflate.crc32(decoded) : _Deflate.adler32(decoded)
+            }
+            // Bytes after the stream: give back those that came in this call.
+            let unused = min(input.count - end, bytes.count)
+            input = []
+            return bytes.count - unused
+        } catch .truncated {
+            return bytes.count
+        }
+    }
+
+    /// Copies the next output into `destination`; returns how many bytes.
+    func drain(into destination: UnsafeMutablePointer<UInt8>?, capacity: Int) -> Int {
+        let count = min(capacity, output.count - outputPosition)
+        guard count > 0, let destination else { return 0 }
+        output.withUnsafeBufferPointer { destination.update(from: $0.baseAddress! + outputPosition, count: count) }
+        outputPosition += count
+        if outputPosition == output.count, finished {
+            output = []
+            outputPosition = 0
+        }
+        return count
+    }
+}
+
+// MARK: - The Swift overlay
+
+/// The algorithms, as the Swift overlay names them. Only `.zlib` has a codec
+/// in the browser, so `init(rawValue:)` answers nil for the others; a filter
+/// made with one throws `FilterError.invalidState`.
+public enum Algorithm: CaseIterable, RawRepresentable, Sendable {
+    case lzfse, zlib, lz4, lzma, brotli, lzbitmap
+
+    public init?(rawValue: compression_algorithm) {
+        guard rawValue == COMPRESSION_ZLIB else { return nil }
+        self = .zlib
+    }
+
+    public var rawValue: compression_algorithm {
+        switch self {
+        case .lzfse: COMPRESSION_LZFSE
+        case .zlib: COMPRESSION_ZLIB
+        case .lz4: COMPRESSION_LZ4
+        case .lzma: COMPRESSION_LZMA
+        case .brotli: COMPRESSION_BROTLI
+        case .lzbitmap: COMPRESSION_LZBITMAP
+        }
+    }
+}
+
+public enum FilterOperation: Sendable {
+    case compress, decompress
+}
+
+public enum FilterError: Error, Sendable {
+    case invalidState, invalidData, writingToFinalizedFilter, readingFromEndOfStream
+}
+
+/// Compresses or decompresses data written to it, handing the result to
+/// `writeFunc` in pieces of up to `bufferCapacity` bytes, then nil at the end.
+public class OutputFilter {
+    let codec: _StreamCodec
+    let bufferCapacity: Int
+    let writeFunc: (Data?) throws -> Void
+    var finalized = false
+
+    public init(_ operation: FilterOperation, using algorithm: Algorithm, bufferCapacity: Int = 65536, writingTo writeFunc: @escaping (Data?) throws -> Void) throws {
+        guard algorithm == .zlib, bufferCapacity > 0 else { throw FilterError.invalidState }
+        codec = _StreamCodec(encoding: operation == .compress, format: .raw)
+        self.bufferCapacity = bufferCapacity
+        self.writeFunc = writeFunc
+    }
+
+    /// Takes more input; nil or empty data finalizes the filter.
+    public func write<D: DataProtocol>(_ data: D?) throws {
+        guard let data, !data.isEmpty else { return try finalize() }
+        guard !finalized else { throw FilterError.writingToFinalizedFilter }
+        let bytes = [UInt8](data)
+        try bytes.withUnsafeBytes { buffer in try process(buffer, finish: false) }
+    }
+
+    /// Ends the input and writes out the rest. Does nothing the second time.
+    public func finalize() throws {
+        guard !finalized else { return }
+        try process(UnsafeRawBufferPointer(start: nil, count: 0), finish: true)
+        guard codec.isDone else { throw FilterError.invalidData }
+        finalized = true
+        try writeFunc(nil)
+    }
+
+    func process(_ bytes: UnsafeRawBufferPointer, finish: Bool) throws {
+        do { _ = try codec.consume(bytes, finish: finish) } catch { throw FilterError.invalidData }
+        var chunk = [UInt8](repeating: 0, count: bufferCapacity)
+        while true {
+            let count = chunk.withUnsafeMutableBufferPointer { codec.drain(into: $0.baseAddress, capacity: bufferCapacity) }
+            if count == 0 { break }
+            try writeFunc(Data(chunk[0..<count]))
+        }
+    }
+}
+
+/// Compresses or decompresses what `readFunc` supplies (it is asked for up
+/// to `bufferCapacity` bytes at a time and answers nil or empty data at the
+/// end), handing out the result through `readData(ofLength:)`.
+public class InputFilter<D: DataProtocol> {
+    let codec: _StreamCodec
+    let bufferCapacity: Int
+    let readFunc: (Int) throws -> D?
+    var inputEnded = false
+
+    public init(_ operation: FilterOperation, using algorithm: Algorithm, bufferCapacity: Int = 65536, readingFrom readFunc: @escaping (Int) throws -> D?) throws {
+        guard algorithm == .zlib, bufferCapacity > 0 else { throw FilterError.invalidState }
+        codec = _StreamCodec(encoding: operation == .compress, format: .raw)
+        self.bufferCapacity = bufferCapacity
+        self.readFunc = readFunc
+    }
+
+    /// Up to `count` bytes of output, or nil once all of it has been read.
+    public func readData(ofLength count: Int) throws -> Data? {
+        var result = Data()
+        while result.count < count {
+            var chunk = [UInt8](repeating: 0, count: count - result.count)
+            let written = chunk.withUnsafeMutableBufferPointer { codec.drain(into: $0.baseAddress, capacity: $0.count) }
+            if written > 0 {
+                result.append(contentsOf: chunk[0..<written])
+                continue
+            }
+            if codec.isDone { break }
+            guard !inputEnded else { throw FilterError.invalidData } // the input ended mid-stream
+            let next = try readFunc(bufferCapacity).map { [UInt8]($0) } ?? []
+            if next.isEmpty { inputEnded = true }
+            do {
+                _ = try next.withUnsafeBytes { buffer throws(_Deflate.Failure) in try codec.consume(buffer, finish: next.isEmpty) }
+            } catch {
+                throw FilterError.invalidData
+            }
+        }
+        return result.isEmpty && codec.isDone ? nil : result
+    }
+}