@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/Compression/Deflate.swift

@@ -0,0 +1,407 @@
+// DEFLATE (RFC 1951), the format behind `COMPRESSION_ZLIB` and zlib's
+// `inflate`, computed in Swift: a complete decoder (stored, fixed and dynamic
+// Huffman blocks) and an encoder that writes one fixed-Huffman block over a
+// hash-chain LZ77 search (or stored blocks when that would be larger). The
+// encoder's output is valid DEFLATE that any inflater reads; it is not as
+// small as zlib's, which also builds dynamic Huffman tables. The zlib (RFC
+// 1950) and gzip (RFC 1952) wrappers and their checksums are here too.
+
+enum _Deflate {
+    enum Failure: Error, Equatable {
+        /// The input ended before the stream did: more input may complete it.
+        case truncated
+        /// The input is not a valid stream (or its checksum does not match).
+        case invalid
+    }
+
+    /// The wrapper around the DEFLATE data.
+    enum Format: Equatable {
+        /// Bare DEFLATE, as Apple's `COMPRESSION_ZLIB` and zlib's negative window bits.
+        case raw
+        /// RFC 1950: a two-byte header and an Adler-32 trailer.
+        case zlib
+        /// RFC 1952: a gzip member header and a CRC-32 and length trailer.
+        case gzip
+        /// zlib or gzip, whichever the header says (zlib's window bits + 32).
+        case automatic
+    }
+
+    // MARK: Decoding
+
+    /// Decodes one stream at the start of `input`; returns the output and the
+    /// index of the first byte after the stream (its trailer included).
+    static func inflate(_ input: [UInt8], format: Format = .raw) throws(Failure) -> (output: [UInt8], end: Int) {
+        var format = format
+        var start = 0
+        if format == .automatic {
+            guard input.count >= 2 else { throw .truncated }
+            format = input[0] == 0x1f && input[1] == 0x8b ? .gzip : .zlib
+        }
+        switch format {
+        case .zlib:
+            guard input.count >= 2 else { throw .truncated }
+            let cmf = Int(input[0]), flg = Int(input[1])
+            // Method 8 (deflate), a window of at most 32K, a valid check, no preset dictionary.
+            guard cmf & 0x0f == 8, cmf >> 4 <= 7, (cmf << 8 | flg) % 31 == 0, flg & 0x20 == 0 else { throw .invalid }
+            start = 2
+        case .gzip:
+            start = try gzipHeaderLength(input)
+        case .raw, .automatic:
+            break
+        }
+        var inflater = Inflater(input: input, position: start)
+        try inflater.run()
+        var end = inflater.position
+        let output = inflater.output
+        switch format {
+        case .zlib:
+            guard end + 4 <= input.count else { throw .truncated }
+            let expected = input[end..<end + 4].reduce(UInt32(0)) { $0 << 8 | UInt32($1) }
+            guard expected == adler32(output) else { throw .invalid }
+            end += 4
+        case .gzip:
+            guard end + 8 <= input.count else { throw .truncated }
+            let crc = littleEndian32(input, end), size = littleEndian32(input, end + 4)
+            guard crc == crc32(output), size == UInt32(truncatingIfNeeded: output.count) else { throw .invalid }
+            end += 8
+        case .raw, .automatic:
+            break
+        }
+        return (output, end)
+    }
+
+    static func littleEndian32(_ bytes: [UInt8], _ at: Int) -> UInt32 {
+        UInt32(bytes[at]) | UInt32(bytes[at + 1]) << 8 | UInt32(bytes[at + 2]) << 16 | UInt32(bytes[at + 3]) << 24
+    }
+
+    /// The length of the gzip member header at the start of `input`.
+    static func gzipHeaderLength(_ input: [UInt8]) throws(Failure) -> Int {
+        func need(_ count: Int) throws(Failure) { if count > input.count { throw .truncated } }
+        try need(10)
+        guard input[0] == 0x1f, input[1] == 0x8b, input[2] == 8 else { throw .invalid }
+        let flags = input[3]
+        var position = 10
+        if flags & 0x04 != 0 { // FEXTRA
+            try need(position + 2)
+            position += 2 + (Int(input[position]) | Int(input[position + 1]) << 8)
+        }
+        for flag: UInt8 in [0x08, 0x10] where flags & flag != 0 { // FNAME, FCOMMENT: zero-terminated
+            while true {
+                try need(position + 1)
+                position += 1
+                if input[position - 1] == 0 { break }
+            }
+        }
+        if flags & 0x02 != 0 { position += 2 } // FHCRC
+        try need(position)
+        return position
+    }
+
+    /// Length and distance bases and extra bits (RFC 1951, 3.2.5).
+    static let lengthBase: [Int] = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258]
+    static let lengthExtra: [Int] = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]
+    static let distanceBase: [Int] = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577]
+    static let distanceExtra: [Int] = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]
+    /// The order code length code lengths come in (RFC 1951, 3.2.7).
+    static let codeLengthOrder: [Int] = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
+
+    /// A canonical Huffman code: how many codes each length has, and the
+    /// symbols in code order.
+    struct Huffman {
+        var counts = [Int](repeating: 0, count: 16)
+        var symbols: [Int]
+
+        init(lengths: ArraySlice<Int>) throws(Failure) {
+            for length in lengths { counts[length] += 1 }
+            counts[0] = 0
+            var left = 1
+            for length in 1...15 {
+                left = left << 1 - counts[length]
+                if left < 0 { throw .invalid } // over-subscribed
+            }
+            var offsets = [Int](repeating: 0, count: 16)
+            for length in 1..<15 { offsets[length + 1] = offsets[length] + counts[length] }
+            symbols = [Int](repeating: 0, count: lengths.count)
+            for (symbol, length) in lengths.enumerated() where length != 0 {
+                symbols[offsets[length]] = symbol
+                offsets[length] += 1
+            }
+        }
+
+        static let fixedLiterals = try! Huffman(lengths: ArraySlice((0..<288).map { $0 < 144 ? 8 : $0 < 256 ? 9 : $0 < 280 ? 7 : 8 }))
+        static let fixedDistances = try! Huffman(lengths: ArraySlice([Int](repeating: 5, count: 30)))
+    }
+
+    struct Inflater {
+        let input: [UInt8]
+        var position: Int
+        var bitBuffer = 0
+        var bitCount = 0
+        var output: [UInt8] = []
+
+        init(input: [UInt8], position: Int) {
+            self.input = input
+            self.position = position
+            output.reserveCapacity(input.count * 3)
+        }
+
+        mutating func bits(_ count: Int) throws(Failure) -> Int {
+            while bitCount < count {
+                guard position < input.count else { throw .truncated }
+                bitBuffer |= Int(input[position]) << bitCount
+                position += 1
+                bitCount += 8
+            }
+            let value = bitBuffer & (1 << count - 1)
+            bitBuffer >>= count
+            bitCount -= count
+            return value
+        }
+
+        /// Reads one symbol, a bit at a time (codes are stored most significant bit first).
+        mutating func decode(_ huffman: Huffman) throws(Failure) -> Int {
+            var code = 0, first = 0, index = 0
+            for length in 1...15 {
+                code |= try bits(1)
+                let count = huffman.counts[length]
+                if code - first < count { return huffman.symbols[index + code - first] }
+                index += count
+                first = (first + count) << 1
+                code <<= 1
+            }
+            throw .invalid
+        }
+
+        mutating func run() throws(Failure) {
+            var last = false
+            while !last {
+                last = try bits(1) == 1
+                switch try bits(2) {
+                case 0: try stored()
+                case 1: try codes(Huffman.fixedLiterals, Huffman.fixedDistances)
+                case 2: try dynamic()
+                default: throw .invalid
+                }
+            }
+            // The stream ends on a byte boundary; unread whole bytes go back to the input.
+            position -= bitCount / 8
+        }
+
+        mutating func stored() throws(Failure) {
+            bitBuffer = 0
+            bitCount = 0
+            guard position + 4 <= input.count else { throw .truncated }
+            let length = Int(input[position]) | Int(input[position + 1]) << 8
+            let complement = Int(input[position + 2]) | Int(input[position + 3]) << 8
+            guard length == ~complement & 0xffff else { throw .invalid }
+            position += 4
+            guard position + length <= input.count else { throw .truncated }
+            output.append(contentsOf: input[position..<position + length])
+            position += length
+        }
+
+        mutating func dynamic() throws(Failure) {
+            let literalCount = try bits(5) + 257
+            let distanceCount = try bits(5) + 1
+            let codeLengthCount = try bits(4) + 4
+            guard literalCount <= 286, distanceCount <= 30 else { throw .invalid }
+            var lengths = [Int](repeating: 0, count: 19)
+            for index in 0..<codeLengthCount { lengths[_Deflate.codeLengthOrder[index]] = try bits(3) }
+            let lengthCode = try Huffman(lengths: lengths[...])
+            lengths = []
+            lengths.reserveCapacity(literalCount + distanceCount)
+            while lengths.count < literalCount + distanceCount {
+                let symbol = try decode(lengthCode)
+                if symbol < 16 {
+                    lengths.append(symbol)
+                    continue
+                }
+                var value = 0, repeats: Int
+                switch symbol {
+                case 16:
+                    guard let previous = lengths.last else { throw .invalid }
+                    value = previous
+                    repeats = try 3 + bits(2)
+                case 17: repeats = try 3 + bits(3)
+                default: repeats = try 11 + bits(7)
+                }
+                guard lengths.count + repeats <= literalCount + distanceCount else { throw .invalid }
+                lengths.append(contentsOf: repeatElement(value, count: repeats))
+            }
+            guard lengths[256] != 0 else { throw .invalid } // no end-of-block code
+            try codes(Huffman(lengths: lengths[0..<literalCount]), Huffman(lengths: lengths[literalCount...]))
+        }
+
+        mutating func codes(_ literals: Huffman, _ distances: Huffman) throws(Failure) {
+            while true {
+                let symbol = try decode(literals)
+                if symbol < 256 {
+                    output.append(UInt8(symbol))
+                    continue
+                }
+                if symbol == 256 { return }
+                let lengthIndex = symbol - 257
+                guard lengthIndex < 29 else { throw .invalid }
+                let length = try _Deflate.lengthBase[lengthIndex] + bits(_Deflate.lengthExtra[lengthIndex])
+                let distanceIndex = try decode(distances)
+                guard distanceIndex < 30 else { throw .invalid }
+                let distance = try _Deflate.distanceBase[distanceIndex] + bits(_Deflate.distanceExtra[distanceIndex])
+                guard distance <= output.count else { throw .invalid }
+                let from = output.count - distance
+                for offset in 0..<length { output.append(output[from + offset]) }
+            }
+        }
+    }
+
+    // MARK: Encoding
+
+    /// Encodes `input` as raw DEFLATE.
+    static func deflate(_ input: [UInt8]) -> [UInt8] {
+        var writer = BitWriter()
+        writer.write(1, 1) // final block
+        writer.write(1, 2) // fixed Huffman codes
+        let count = input.count
+        var head = [Int](repeating: -1, count: 1 << 15)
+        var previous = [Int](repeating: -1, count: count)
+        func hash(_ at: Int) -> Int {
+            (Int(input[at]) << 10 ^ Int(input[at + 1]) << 5 ^ Int(input[at + 2])) & 0x7fff
+        }
+        func insert(_ at: Int) {
+            guard at + 2 < count else { return }
+            let key = hash(at)
+            previous[at] = head[key]
+            head[key] = at
+        }
+        var position = 0
+        while position < count {
+            var bestLength = 0, bestDistance = 0
+            if position + 2 < count {
+                var candidate = head[hash(position)]
+                var chain = 64
+                let limit = min(258, count - position)
+                while candidate >= 0, position - candidate <= 32768, chain > 0 {
+                    var length = 0
+                    while length < limit, input[candidate + length] == input[position + length] { length += 1 }
+                    if length > bestLength {
+                        bestLength = length
+                        bestDistance = position - candidate
+                        if length == limit { break }
+                    }
+                    candidate = previous[candidate]
+                    chain -= 1
+                }
+            }
+            if bestLength >= 3 {
+                writer.writeLength(bestLength)
+                writer.writeDistance(bestDistance)
+                for at in position..<position + bestLength { insert(at) }
+                position += bestLength
+            } else {
+                writer.writeLiteral(Int(input[position]))
+                insert(position)
+                position += 1
+            }
+        }
+        writer.writeLiteral(256)
+        writer.flush()
+        // Incompressible input: stored blocks are at most 5 bytes per 64K larger than the input.
+        if writer.bytes.count > count + 5 * (count / 65535 + 1) { return stored(input) }
+        return writer.bytes
+    }
+
+    /// `input` in stored (uncompressed) blocks.
+    static func stored(_ input: [UInt8]) -> [UInt8] {
+        var output: [UInt8] = []
+        output.reserveCapacity(input.count + 5 * (input.count / 65535 + 1))
+        var position = 0
+        repeat {
+            let length = min(65535, input.count - position)
+            let final: UInt8 = position + length == input.count ? 1 : 0
+            output += [final, UInt8(length & 0xff), UInt8(length >> 8), UInt8(~length & 0xff), UInt8(~length >> 8 & 0xff)]
+            output += input[position..<position + length]
+            position += length
+        } while position < input.count
+        return output
+    }
+
+    struct BitWriter {
+        var bytes: [UInt8] = []
+        var buffer = 0
+        var count = 0
+
+        mutating func write(_ value: Int, _ bits: Int) {
+            buffer |= value << count
+            count += bits
+            while count >= 8 {
+                bytes.append(UInt8(buffer & 0xff))
+                buffer >>= 8
+                count -= 8
+            }
+        }
+
+        /// Writes a Huffman code, most significant bit first.
+        mutating func writeCode(_ code: Int, _ bits: Int) {
+            var reversed = 0
+            for bit in 0..<bits { reversed |= (code >> bit & 1) << (bits - 1 - bit) }
+            write(reversed, bits)
+        }
+
+        mutating func writeLiteral(_ symbol: Int) {
+            switch symbol {
+            case 0..<144: writeCode(0x30 + symbol, 8)
+            case 144..<256: writeCode(0x190 + symbol - 144, 9)
+            case 256..<280: writeCode(symbol - 256, 7)
+            default: writeCode(0xc0 + symbol - 280, 8)
+            }
+        }
+
+        mutating func writeLength(_ length: Int) {
+            var index = 28
+            while _Deflate.lengthBase[index] > length { index -= 1 }
+            writeLiteral(257 + index)
+            write(length - _Deflate.lengthBase[index], _Deflate.lengthExtra[index])
+        }
+
+        mutating func writeDistance(_ distance: Int) {
+            var index = 29
+            while _Deflate.distanceBase[index] > distance { index -= 1 }
+            writeCode(index, 5)
+            write(distance - _Deflate.distanceBase[index], _Deflate.distanceExtra[index])
+        }
+
+        mutating func flush() {
+            if count > 0 { write(0, 8 - count) }
+        }
+    }
+
+    // MARK: Checksums
+
+    static func adler32(_ bytes: [UInt8], _ start: UInt32 = 1) -> UInt32 {
+        var a = start & 0xffff, b = start >> 16
+        var index = 0
+        while index < bytes.count {
+            // 5552 bytes is the most that cannot overflow before the modulo.
+            let end = min(index + 5552, bytes.count)
+            while index < end {
+                a += UInt32(bytes[index])
+                b += a
+                index += 1
+            }
+            a %= 65521
+            b %= 65521
+        }
+        return b << 16 | a
+    }
+
+    static let crcTable: [UInt32] = (0..<256).map { (n: UInt32) in
+        var c = n
+        for _ in 0..<8 { c = c & 1 != 0 ? 0xedb8_8320 ^ c >> 1 : c >> 1 }
+        return c
+    }
+
+    static func crc32(_ bytes: [UInt8], _ start: UInt32 = 0) -> UInt32 {
+        var crc = ~start
+        for byte in bytes { crc = crcTable[Int((crc ^ UInt32(byte)) & 0xff)] ^ crc >> 8 }
+        return ~crc
+    }
+}

package/Sources/Compression/Zlib.swift

@@ -0,0 +1,179 @@
+// zlib's decompression API (zlib.h), as Swift code calls it after
+// `import zlib`: `inflateInit2_` / `inflate` / `inflateEnd` over a
+// `z_stream`, decoding zlib, gzip and raw DEFLATE streams for real with the
+// decoder in Deflate.swift. RevenueCat gunzips its container elements this
+// way. As with Compression's streams, the output comes once the input holds
+// the whole stream (Swift has no partial-block state to resume from), then
+// in as many pieces as the caller's buffers need. There is no `deflate`:
+// nothing that builds for the browser compresses through zlib yet.
+
+/// zlib's byte and size types.
+public typealias Bytef = UInt8
+public typealias uInt = UInt32
+public typealias uLong = UInt
+public typealias voidpf = UnsafeMutableRawPointer
+public typealias alloc_func = @convention(c) (voidpf?, uInt, uInt) -> voidpf?
+public typealias free_func = @convention(c) (voidpf?, voidpf?) -> Void
+
+/// The version the API is declared after (Apple's SDKs ship 1.2.12).
+public let ZLIB_VERSION = "1.2.12"
+public let ZLIB_VERNUM: Int32 = 0x12c0
+/// The largest window, 32K: `MAX_WBITS + 16` asks for gzip, `+ 32` for
+/// either header, a negative value for raw DEFLATE.
+public let MAX_WBITS: Int32 = 15
+public let MAX_MEM_LEVEL: Int32 = 9
+public let Z_DEFLATED: Int32 = 8
+
+public let Z_NO_FLUSH: Int32 = 0
+public let Z_PARTIAL_FLUSH: Int32 = 1
+public let Z_SYNC_FLUSH: Int32 = 2
+public let Z_FULL_FLUSH: Int32 = 3
+public let Z_FINISH: Int32 = 4
+public let Z_BLOCK: Int32 = 5
+public let Z_TREES: Int32 = 6
+
+public let Z_OK: Int32 = 0
+public let Z_STREAM_END: Int32 = 1
+public let Z_NEED_DICT: Int32 = 2
+public let Z_ERRNO: Int32 = -1
+public let Z_STREAM_ERROR: Int32 = -2
+public let Z_DATA_ERROR: Int32 = -3
+public let Z_MEM_ERROR: Int32 = -4
+public let Z_BUF_ERROR: Int32 = -5
+public let Z_VERSION_ERROR: Int32 = -6
+
+/// A stream in progress, as zlib.h declares it. The allocator fields are
+/// accepted and unused: Swift manages the memory.
+public struct z_stream {
+    public var next_in: UnsafeMutablePointer<Bytef>!
+    public var avail_in: uInt
+    public var total_in: uLong
+    public var next_out: UnsafeMutablePointer<Bytef>!
+    public var avail_out: uInt
+    public var total_out: uLong
+    public var msg: UnsafeMutablePointer<CChar>!
+    public var state: OpaquePointer!
+    public var zalloc: alloc_func!
+    public var zfree: free_func!
+    public var opaque: voidpf!
+    public var data_type: Int32
+    public var adler: uLong
+    public var reserved: uLong
+
+    public init() {
+        next_in = nil
+        avail_in = 0
+        total_in = 0
+        next_out = nil
+        avail_out = 0
+        total_out = 0
+        msg = nil
+        state = nil
+        zalloc = nil
+        zfree = nil
+        opaque = nil
+        data_type = 0
+        adler = 0
+        reserved = 0
+    }
+}
+
+public typealias z_streamp = UnsafeMutablePointer<z_stream>
+
+/// Starts decoding. `windowBits` 8...15 reads a zlib stream, 24...31 a gzip
+/// one, 40...47 either, and -15...-8 raw DEFLATE.
+public func inflateInit2_(_ strm: z_streamp!, _ windowBits: Int32, _ version: UnsafePointer<CChar>!, _ stream_size: Int32) -> Int32 {
+    guard let strm else { return Z_STREAM_ERROR }
+    guard let version, version.pointee == CChar(UInt8(ascii: "1")) else { return Z_VERSION_ERROR }
+    let format: _Deflate.Format
+    switch windowBits {
+    case 0, 8...15: format = .zlib
+    case -15 ... -8: format = .raw
+    case 24...31: format = .gzip
+    case 32, 40...47: format = .automatic
+    default: return Z_STREAM_ERROR
+    }
+    strm.pointee.state = OpaquePointer(Unmanaged.passRetained(_StreamCodec(encoding: false, format: format)).toOpaque())
+    strm.pointee.total_in = 0
+    strm.pointee.total_out = 0
+    strm.pointee.msg = nil
+    strm.pointee.adler = format == .raw || format == .gzip ? 0 : 1
+    return Z_OK
+}
+
+/// Starts decoding a zlib stream.
+public func inflateInit_(_ strm: z_streamp!, _ version: UnsafePointer<CChar>!, _ stream_size: Int32) -> Int32 {
+    inflateInit2_(strm, MAX_WBITS, version, stream_size)
+}
+
+/// Takes the input at `next_in` and writes output to `next_out`, advancing
+/// both. Returns `Z_STREAM_END` once the whole stream has been written out,
+/// `Z_OK` after progress, `Z_BUF_ERROR` when no progress was possible (the
+/// stream needs more input or more output space) and `Z_DATA_ERROR` for
+/// input that is not a valid stream.
+public func inflate(_ strm: z_streamp!, _ flush: Int32) -> Int32 {
+    guard let strm, let state = strm.pointee.state else { return Z_STREAM_ERROR }
+    let codec = Unmanaged<_StreamCodec>.fromOpaque(UnsafeRawPointer(state)).takeUnretainedValue()
+    if codec.isDone { return Z_STREAM_END }
+    let available = Int(strm.pointee.avail_in)
+    let input = available > 0 ? UnsafeRawBufferPointer(start: strm.pointee.next_in, count: available) : UnsafeRawBufferPointer(start: nil, count: 0)
+    let consumed: Int
+    do {
+        consumed = try codec.consume(input, finish: flush == Z_FINISH)
+    } catch {
+        strm.pointee.msg = _invalidStreamMessage
+        return Z_DATA_ERROR
+    }
+    strm.pointee.next_in = strm.pointee.next_in.map { $0 + consumed }
+    strm.pointee.avail_in -= uInt(consumed)
+    strm.pointee.total_in += uLong(consumed)
+    let written = codec.drain(into: strm.pointee.next_out, capacity: Int(strm.pointee.avail_out))
+    strm.pointee.next_out = strm.pointee.next_out.map { $0 + written }
+    strm.pointee.avail_out -= uInt(written)
+    strm.pointee.total_out += uLong(written)
+    if codec.finished { strm.pointee.adler = uLong(codec.checksum) }
+    if codec.isDone { return Z_STREAM_END }
+    return consumed > 0 || written > 0 ? Z_OK : Z_BUF_ERROR
+}
+
+/// Frees what `inflateInit2_` allocated.
+public func inflateEnd(_ strm: z_streamp!) -> Int32 {
+    guard let strm, let state = strm.pointee.state else { return Z_STREAM_ERROR }
+    Unmanaged<_StreamCodec>.fromOpaque(UnsafeRawPointer(state)).release()
+    strm.pointee.state = nil
+    return Z_OK
+}
+
+/// Starts the next stream with the same settings.
+public func inflateReset(_ strm: z_streamp!) -> Int32 {
+    guard let strm, let state = strm.pointee.state else { return Z_STREAM_ERROR }
+    let old = Unmanaged<_StreamCodec>.fromOpaque(UnsafeRawPointer(state))
+    let format = old.takeUnretainedValue().format
+    old.release()
+    strm.pointee.state = OpaquePointer(Unmanaged.passRetained(_StreamCodec(encoding: false, format: format)).toOpaque())
+    strm.pointee.total_in = 0
+    strm.pointee.total_out = 0
+    strm.pointee.msg = nil
+    return Z_OK
+}
+
+/// The running Adler-32 of `buf` after `adler` (pass 1 to start, or nil
+/// `buf` to get the initial value).
+public func adler32(_ adler: uLong, _ buf: UnsafePointer<Bytef>!, _ len: uInt) -> uLong {
+    guard let buf else { return 1 }
+    return uLong(_Deflate.adler32(Array(UnsafeBufferPointer(start: buf, count: Int(len))), UInt32(truncatingIfNeeded: adler)))
+}
+
+/// The running CRC-32 of `buf` after `crc` (pass 0 to start).
+public func crc32(_ crc: uLong, _ buf: UnsafePointer<Bytef>!, _ len: uInt) -> uLong {
+    guard let buf else { return 0 }
+    return uLong(_Deflate.crc32(Array(UnsafeBufferPointer(start: buf, count: Int(len))), UInt32(truncatingIfNeeded: crc)))
+}
+
+/// `z_stream.msg` for invalid input: a C string that lives as long as the process.
+nonisolated(unsafe) let _invalidStreamMessage: UnsafeMutablePointer<CChar> = {
+    let text = Array("invalid stream".utf8CString)
+    let message = UnsafeMutablePointer<CChar>.allocate(capacity: text.count)
+    message.initialize(from: text, count: text.count)
+    return message
+}()

package/Sources/CoreFoundationTypes/CoreFoundationTypes.swift

@@ -0,0 +1,101 @@
+// Core Foundation's types, as the frameworks over it take them: on Apple
+// platforms `CFString`, `CFURL`, `CFDictionary`… come from CoreFoundation,
+// which Foundation, Security, Image I/O and Audio Toolbox all bring along.
+// Here they are plain Swift values (`data as CFData`, `options as
+// CFDictionary`), declared once in this module and re-exported by each of
+// those, so a file that imports several sees one `CFString`. (The name
+// CoreFoundation is taken: Linux toolchains ship corelibs' own.)
+
+import Foundation
+
+public typealias CFTypeRef = AnyObject
+public typealias CFString = String
+public typealias CFURL = URL
+public typealias CFData = Data
+public typealias CFMutableData = NSMutableData
+public typealias CFDictionary = [String: Any]
+public typealias CFTypeID = UInt
+public typealias CFIndex = Int
+public typealias CFAllocator = AnyObject
+public typealias OSStatus = Int32
+/// Toll-free bridged with `NSError` on Apple platforms (`error as NSError`,
+/// `Unmanaged<CFError>` out-parameters).
+public typealias CFError = NSError
+
+/// Core Foundation's booleans, as options dictionaries take them
+/// (`[kCGImageSourceShouldCache: kCFBooleanFalse]`, `kSecReturnData: kCFBooleanTrue`).
+public let kCFBooleanTrue: Bool = true
+public let kCFBooleanFalse: Bool = false
+
+/// The type of a Core Foundation object, as `CFGetTypeID` answers it and the
+/// `…GetTypeID()` functions name it (Apple's values). A boolean `NSNumber`
+/// is a `CFBoolean`, as `JSONSerialization` makes them: the usual way to tell
+/// `true` from `1`.
+public func CFGetTypeID(_ cf: CFTypeRef?) -> CFTypeID {
+    switch cf {
+    case let number as NSNumber:
+        String(cString: number.objCType) == "c" ? CFBooleanGetTypeID() : CFNumberGetTypeID()
+    case is NSString, is String: CFStringGetTypeID()
+    case is NSData, is Data: CFDataGetTypeID()
+    case is NSArray: CFArrayGetTypeID()
+    case is NSDictionary: CFDictionaryGetTypeID()
+    case is NSDate, is Date: CFDateGetTypeID()
+    case is NSNull: CFNullGetTypeID()
+    default: 1
+    }
+}
+
+public func CFStringGetTypeID() -> CFTypeID { 7 }
+public func CFNullGetTypeID() -> CFTypeID { 16 }
+public func CFDictionaryGetTypeID() -> CFTypeID { 18 }
+public func CFArrayGetTypeID() -> CFTypeID { 19 }
+public func CFDataGetTypeID() -> CFTypeID { 20 }
+public func CFBooleanGetTypeID() -> CFTypeID { 21 }
+public func CFNumberGetTypeID() -> CFTypeID { 22 }
+public func CFDateGetTypeID() -> CFTypeID { 42 }
+
+public func CFDataCreateMutable(_ allocator: CFAllocator?, _ capacity: CFIndex) -> CFMutableData? { NSMutableData() }
+
+/// A URL from a string, as Core Foundation parses one: characters that may
+/// not appear in a URL are percent-encoded, and escapes already in the string
+/// (`%20`) are kept rather than encoded again, which `URL(string:)` does to
+/// every `%` once anything in the string needs encoding. Square brackets are
+/// kept in the host (`[::1]`) and encoded elsewhere. Nil when the result is
+/// still no URL.
+public func CFURLCreateWithString(_ allocator: CFAllocator?, _ urlString: CFString, _ baseURL: CFURL?) -> CFURL? {
+    let escaped = _escapingInvalidURLCharacters(urlString)
+    if let baseURL { return URL(string: escaped, relativeTo: baseURL) }
+    return URL(string: escaped)
+}
+
+/// `urlString` with the characters a URL may not contain percent-encoded (UTF-8).
+func _escapingInvalidURLCharacters(_ urlString: String) -> String {
+    let scalars = Array(urlString.unicodeScalars)
+    // The authority (`//host:port`), where `[` and `]` delimit an IPv6 address.
+    var authority = 0..<0
+    if let colon = scalars.firstIndex(of: ":"), scalars.count > colon + 2, scalars[colon + 1] == "/", scalars[colon + 2] == "/" {
+        let start = colon + 3
+        let end = scalars[start...].firstIndex { $0 == "/" || $0 == "?" || $0 == "#" } ?? scalars.count
+        authority = start..<end
+    }
+    var out = ""
+    for (index, scalar) in scalars.enumerated() {
+        let isHexEscape = scalar == "%" && index + 2 < scalars.count && scalars[index + 1].properties.isASCIIHexDigit && scalars[index + 2].properties.isASCIIHexDigit
+        if isHexEscape || _urlLegal(scalar) || ((scalar == "[" || scalar == "]") && authority.contains(index)) {
+            out.unicodeScalars.append(scalar)
+        } else {
+            for byte in String(scalar).utf8 { out += String(format: "%%%02X", byte) }
+        }
+    }
+    return out
+}
+
+/// RFC 3986's unreserved and reserved characters, but the brackets.
+private func _urlLegal(_ scalar: Unicode.Scalar) -> Bool {
+    guard scalar.isASCII else { return false }
+    switch scalar {
+    case "a"..."z", "A"..."Z", "0"..."9": return true
+    case "-", ".", "_", "~", ":", "/", "?", "#", "@", "!", "$", "&", "'", "(", ")", "*", "+", ",", ";", "=": return true
+    default: return false
+    }
+}