@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/CoreImage/QRCode.swift

@@ -0,0 +1,393 @@
+// A QR code encoder for `CIQRCodeGenerator` (ISO/IEC 18004): byte mode, the
+// smallest version (1...40) that holds the message at the requested error
+// correction level, and the mask with the lowest penalty score. The
+// structure follows Project Nayuki's reference implementation (MIT).
+
+struct _QRCode {
+    enum ErrorCorrection: Int, CaseIterable {
+        case low, medium, quartile, high
+
+        /// Core Image's `inputCorrectionLevel` letters.
+        init?(letter: String) {
+            switch letter.uppercased() {
+            case "L": self = .low
+            case "M": self = .medium
+            case "Q": self = .quartile
+            case "H": self = .high
+            default: return nil
+            }
+        }
+
+        /// The two format bits.
+        var formatBits: Int {
+            switch self {
+            case .low: 1
+            case .medium: 0
+            case .quartile: 3
+            case .high: 2
+            }
+        }
+    }
+
+    let version: Int
+    let size: Int
+    let correction: ErrorCorrection
+    /// The mask applied (0...7).
+    private(set) var mask: Int = 0
+    /// Row-major, true for a dark module.
+    private var modules: [Bool]
+    private var isFunction: [Bool]
+
+    func module(x: Int, y: Int) -> Bool { modules[y * size + x] }
+
+    /// The code for `data`; nil when it does not fit version 40. `mask`
+    /// forces a mask pattern instead of the one with the lowest penalty.
+    static func encode(_ data: [UInt8], correction: ErrorCorrection, mask forcedMask: Int? = nil) -> _QRCode? {
+        var chosen: Int?
+        for version in 1...40 {
+            let capacity = numDataCodewords(version: version, correction: correction) * 8
+            let countBits = version <= 9 ? 8 : 16
+            if data.count < (1 << countBits), 4 + countBits + data.count * 8 <= capacity {
+                chosen = version
+                break
+            }
+        }
+        guard let version = chosen else { return nil }
+        let capacity = numDataCodewords(version: version, correction: correction) * 8
+
+        // Mode indicator (byte), character count, the bytes, then a
+        // terminator, zero bits to a byte boundary and alternating pad bytes.
+        var bits: [Bool] = []
+        func append(_ value: Int, _ count: Int) {
+            for i in stride(from: count - 1, through: 0, by: -1) { bits.append((value >> i) & 1 == 1) }
+        }
+        append(0b0100, 4)
+        append(data.count, version <= 9 ? 8 : 16)
+        for byte in data { append(Int(byte), 8) }
+        append(0, min(4, capacity - bits.count))
+        append(0, (8 - bits.count % 8) % 8)
+        var pad = 0xEC
+        while bits.count < capacity {
+            append(pad, 8)
+            pad ^= 0xEC ^ 0x11
+        }
+        var codewords = [UInt8](repeating: 0, count: bits.count / 8)
+        for (index, bit) in bits.enumerated() where bit { codewords[index >> 3] |= 1 << (7 - UInt8(index & 7)) }
+
+        var code = _QRCode(version: version, correction: correction)
+        code.drawFunctionPatterns()
+        code.drawCodewords(code.interleavedWithErrorCorrection(codewords))
+        var best = forcedMask ?? 0
+        if forcedMask == nil {
+            var lowest = Int.max
+            for candidate in 0..<8 {
+                code.applyMask(candidate)
+                code.drawFormatBits(mask: candidate)
+                let penalty = code.penaltyScore()
+                if penalty < lowest {
+                    lowest = penalty
+                    best = candidate
+                }
+                code.applyMask(candidate) // undo: masking is an XOR
+            }
+        }
+        code.applyMask(best)
+        code.drawFormatBits(mask: best)
+        code.mask = best
+        return code
+    }
+
+    private init(version: Int, correction: ErrorCorrection) {
+        self.version = version
+        self.correction = correction
+        size = version * 4 + 17
+        modules = [Bool](repeating: false, count: size * size)
+        isFunction = [Bool](repeating: false, count: size * size)
+    }
+
+    // MARK: Function patterns
+
+    private mutating func setFunction(_ x: Int, _ y: Int, _ dark: Bool) {
+        modules[y * size + x] = dark
+        isFunction[y * size + x] = true
+    }
+
+    private mutating func drawFunctionPatterns() {
+        for i in 0..<size {
+            setFunction(6, i, i % 2 == 0)
+            setFunction(i, 6, i % 2 == 0)
+        }
+        drawFinder(3, 3)
+        drawFinder(size - 4, 3)
+        drawFinder(3, size - 4)
+        let positions = alignmentPatternPositions()
+        let count = positions.count
+        for i in 0..<count {
+            for j in 0..<count {
+                // Not over the three finder patterns.
+                if (i == 0 && j == 0) || (i == 0 && j == count - 1) || (i == count - 1 && j == 0) { continue }
+                drawAlignment(positions[i], positions[j])
+            }
+        }
+        drawFormatBits(mask: 0) // reserves the area; redrawn once the mask is chosen
+        drawVersion()
+    }
+
+    private mutating func drawFinder(_ x: Int, _ y: Int) {
+        for dy in -4...4 {
+            for dx in -4...4 {
+                let distance = max(abs(dx), abs(dy))
+                let xx = x + dx, yy = y + dy
+                if xx >= 0, xx < size, yy >= 0, yy < size { setFunction(xx, yy, distance != 2 && distance != 4) }
+            }
+        }
+    }
+
+    private mutating func drawAlignment(_ x: Int, _ y: Int) {
+        for dy in -2...2 {
+            for dx in -2...2 { setFunction(x + dx, y + dy, max(abs(dx), abs(dy)) != 1) }
+        }
+    }
+
+    private func alignmentPatternPositions() -> [Int] {
+        if version == 1 { return [] }
+        let count = version / 7 + 2
+        let step = (version * 8 + count * 3 + 5) / (count * 4 - 4) * 2
+        var result = [6]
+        var position = size - 7
+        for _ in 0..<(count - 1) {
+            result.insert(position, at: 1)
+            position -= step
+        }
+        return result
+    }
+
+    private mutating func drawFormatBits(mask: Int) {
+        let data = correction.formatBits << 3 | mask
+        var remainder = data
+        for _ in 0..<10 { remainder = (remainder << 1) ^ ((remainder >> 9) * 0x537) }
+        let bits = (data << 10 | remainder) ^ 0x5412
+        func bit(_ i: Int) -> Bool { (bits >> i) & 1 == 1 }
+        // Around the top left finder.
+        for i in 0...5 { setFunction(8, i, bit(i)) }
+        setFunction(8, 7, bit(6))
+        setFunction(8, 8, bit(7))
+        setFunction(7, 8, bit(8))
+        for i in 9..<15 { setFunction(14 - i, 8, bit(i)) }
+        // Beside the other two.
+        for i in 0..<8 { setFunction(size - 1 - i, 8, bit(i)) }
+        for i in 8..<15 { setFunction(8, size - 15 + i, bit(i)) }
+        setFunction(8, size - 8, true) // the dark module
+    }
+
+    private mutating func drawVersion() {
+        guard version >= 7 else { return }
+        var remainder = version
+        for _ in 0..<12 { remainder = (remainder << 1) ^ ((remainder >> 11) * 0x1F25) }
+        let bits = version << 12 | remainder
+        for i in 0..<18 {
+            let dark = (bits >> i) & 1 == 1
+            let a = size - 11 + i % 3, b = i / 3
+            setFunction(a, b, dark)
+            setFunction(b, a, dark)
+        }
+    }
+
+    // MARK: Data
+
+    /// The data codewords split into blocks, each followed by its
+    /// Reed-Solomon error correction, interleaved.
+    private func interleavedWithErrorCorrection(_ data: [UInt8]) -> [UInt8] {
+        let blocks = Self.blockCount[correction.rawValue][version]
+        let eccLength = Self.eccPerBlock[correction.rawValue][version]
+        let raw = Self.numRawDataModules(version: version) / 8
+        let shortBlocks = blocks - raw % blocks
+        let shortLength = raw / blocks
+        let divisor = Self.reedSolomonDivisor(degree: eccLength)
+        var split: [[UInt8]] = []
+        var offset = 0
+        for i in 0..<blocks {
+            let length = shortLength - eccLength + (i < shortBlocks ? 0 : 1)
+            var block = Array(data[offset..<(offset + length)])
+            offset += length
+            let ecc = Self.reedSolomonRemainder(block, divisor: divisor)
+            if i < shortBlocks { block.append(0) } // a placeholder, skipped below
+            split.append(block + ecc)
+        }
+        var result: [UInt8] = []
+        result.reserveCapacity(raw)
+        for i in 0..<split[0].count {
+            for (j, block) in split.enumerated() where i != shortLength - eccLength || j >= shortBlocks {
+                result.append(block[i])
+            }
+        }
+        return result
+    }
+
+    /// Two columns at a time from the right, zigzagging up and down, skipping
+    /// the timing column and the function patterns.
+    private mutating func drawCodewords(_ data: [UInt8]) {
+        var index = 0
+        var right = size - 1
+        while right >= 1 {
+            if right == 6 { right = 5 }
+            for vertical in 0..<size {
+                for j in 0..<2 {
+                    let x = right - j
+                    let upward = (right + 1) & 2 == 0
+                    let y = upward ? size - 1 - vertical : vertical
+                    if !isFunction[y * size + x], index < data.count * 8 {
+                        modules[y * size + x] = (data[index >> 3] >> (7 - UInt8(index & 7))) & 1 == 1
+                        index += 1
+                    }
+                }
+            }
+            right -= 2
+        }
+    }
+
+    private mutating func applyMask(_ mask: Int) {
+        for y in 0..<size {
+            for x in 0..<size where !isFunction[y * size + x] {
+                let invert: Bool
+                switch mask {
+                case 0: invert = (x + y) % 2 == 0
+                case 1: invert = y % 2 == 0
+                case 2: invert = x % 3 == 0
+                case 3: invert = (x + y) % 3 == 0
+                case 4: invert = (x / 3 + y / 2) % 2 == 0
+                case 5: invert = x * y % 2 + x * y % 3 == 0
+                case 6: invert = (x * y % 2 + x * y % 3) % 2 == 0
+                default: invert = ((x + y) % 2 + x * y % 3) % 2 == 0
+                }
+                if invert { modules[y * size + x].toggle() }
+            }
+        }
+    }
+
+    // MARK: Penalty
+
+    /// The mask selection score: runs of five or more, 2×2 blocks, finder-like
+    /// patterns and the dark/light balance.
+    func penaltyScore() -> Int {
+        var result = 0
+        for horizontal in [true, false] {
+            for a in 0..<size {
+                var runColor = false
+                var run = 0
+                var history = [Int](repeating: 0, count: 7)
+                for b in 0..<size {
+                    let dark = horizontal ? module(x: b, y: a) : module(x: a, y: b)
+                    if dark == runColor {
+                        run += 1
+                        if run == 5 { result += 3 } else if run > 5 { result += 1 }
+                    } else {
+                        addHistory(run, &history)
+                        if !runColor { result += finderLikePatterns(history) * 40 }
+                        runColor = dark
+                        run = 1
+                    }
+                }
+                // The light border closes the last run.
+                if runColor {
+                    addHistory(run, &history)
+                    run = 0
+                }
+                addHistory(run + size, &history)
+                result += finderLikePatterns(history) * 40
+            }
+        }
+        for y in 0..<(size - 1) {
+            for x in 0..<(size - 1) {
+                let color = module(x: x, y: y)
+                if color == module(x: x + 1, y: y), color == module(x: x, y: y + 1), color == module(x: x + 1, y: y + 1) { result += 3 }
+            }
+        }
+        let dark = modules.reduce(0) { $0 + ($1 ? 1 : 0) }
+        let total = size * size
+        let k = (abs(dark * 20 - total * 10) + total - 1) / total - 1
+        result += k * 10
+        return result
+    }
+
+    private func addHistory(_ run: Int, _ history: inout [Int]) {
+        // The light border before the first run.
+        let length = history[0] == 0 ? run + size : run
+        history.removeLast()
+        history.insert(length, at: 0)
+    }
+
+    private func finderLikePatterns(_ history: [Int]) -> Int {
+        let n = history[1]
+        let core = n > 0 && history[2] == n && history[3] == n * 3 && history[4] == n && history[5] == n
+        return (core && history[0] >= n * 4 && history[6] >= n ? 1 : 0) + (core && history[6] >= n * 4 && history[0] >= n ? 1 : 0)
+    }
+
+    // MARK: Tables and arithmetic
+
+    static func numRawDataModules(version: Int) -> Int {
+        var result = (16 * version + 128) * version + 64
+        if version >= 2 {
+            let alignments = version / 7 + 2
+            result -= (25 * alignments - 10) * alignments - 55
+            if version >= 7 { result -= 36 }
+        }
+        return result
+    }
+
+    static func numDataCodewords(version: Int, correction: ErrorCorrection) -> Int {
+        numRawDataModules(version: version) / 8
+            - eccPerBlock[correction.rawValue][version] * blockCount[correction.rawValue][version]
+    }
+
+    /// Error correction codewords per block, by level (L, M, Q, H) and version (index 0 unused).
+    static let eccPerBlock: [[Int]] = [
+        [-1, 7, 10, 15, 20, 26, 18, 20, 24, 30, 18, 20, 24, 26, 30, 22, 24, 28, 30, 28, 28, 28, 28, 30, 30, 26, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+        [-1, 10, 16, 26, 18, 24, 16, 18, 22, 22, 26, 30, 22, 22, 24, 24, 28, 28, 26, 26, 26, 26, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28],
+        [-1, 13, 22, 18, 26, 18, 24, 18, 22, 20, 24, 28, 26, 24, 20, 30, 24, 28, 28, 26, 30, 28, 30, 30, 30, 30, 28, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+        [-1, 17, 28, 22, 16, 22, 28, 26, 26, 24, 28, 24, 28, 22, 24, 24, 30, 28, 28, 26, 28, 30, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30],
+    ]
+
+    /// Error correction blocks, by level (L, M, Q, H) and version (index 0 unused).
+    static let blockCount: [[Int]] = [
+        [-1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 6, 7, 8, 8, 9, 9, 10, 12, 12, 12, 13, 14, 15, 16, 17, 18, 19, 19, 20, 21, 22, 24, 25],
+        [-1, 1, 1, 1, 2, 2, 4, 4, 4, 5, 5, 5, 8, 9, 9, 10, 10, 11, 13, 14, 16, 17, 17, 18, 20, 21, 23, 25, 26, 28, 29, 31, 33, 35, 37, 38, 40, 43, 45, 47, 49],
+        [-1, 1, 1, 2, 2, 4, 4, 6, 6, 8, 8, 8, 10, 12, 16, 12, 17, 16, 18, 21, 20, 23, 23, 25, 27, 29, 34, 34, 35, 38, 40, 43, 45, 48, 51, 53, 56, 59, 62, 65, 68],
+        [-1, 1, 1, 2, 4, 4, 4, 5, 6, 8, 8, 11, 11, 16, 16, 18, 16, 19, 21, 25, 25, 25, 34, 30, 32, 35, 37, 40, 42, 45, 48, 51, 54, 57, 60, 63, 66, 70, 74, 77, 81],
+    ]
+
+    /// The generator polynomial's coefficients for `degree` codewords, highest first.
+    static func reedSolomonDivisor(degree: Int) -> [UInt8] {
+        var result = [UInt8](repeating: 0, count: degree)
+        result[degree - 1] = 1
+        var root: UInt8 = 1
+        for _ in 0..<degree {
+            for j in 0..<degree {
+                result[j] = multiply(result[j], root)
+                if j + 1 < degree { result[j] ^= result[j + 1] }
+            }
+            root = multiply(root, 0x02)
+        }
+        return result
+    }
+
+    static func reedSolomonRemainder(_ data: [UInt8], divisor: [UInt8]) -> [UInt8] {
+        var result = [UInt8](repeating: 0, count: divisor.count)
+        for byte in data {
+            let factor = byte ^ result.removeFirst()
+            result.append(0)
+            for i in 0..<result.count { result[i] ^= multiply(divisor[i], factor) }
+        }
+        return result
+    }
+
+    /// Multiplication in GF(2^8) modulo x^8 + x^4 + x^3 + x^2 + 1.
+    static func multiply(_ x: UInt8, _ y: UInt8) -> UInt8 {
+        var z = 0
+        for i in stride(from: 7, through: 0, by: -1) {
+            z = (z << 1) ^ ((z >> 7) * 0x11D)
+            z ^= ((Int(y) >> i) & 1) * Int(x)
+        }
+        return UInt8(z)
+    }
+}

package/Sources/CoreLocation/Coordinate.swift

@@ -0,0 +1,30 @@
+// Core Location's value types, without location services: a coordinate is a
+// plain latitude and longitude. No protocol conformances are added, as on
+// Apple platforms (where it is a C struct), so an app's own
+// `extension CLLocationCoordinate2D: Equatable` or `Codable` still compiles.
+
+public typealias CLLocationDegrees = Double
+public typealias CLLocationDistance = Double
+
+public struct CLLocationCoordinate2D: Sendable {
+    public var latitude: CLLocationDegrees
+    public var longitude: CLLocationDegrees
+
+    public init() {
+        latitude = 0
+        longitude = 0
+    }
+
+    public init(latitude: CLLocationDegrees, longitude: CLLocationDegrees) {
+        self.latitude = latitude
+        self.longitude = longitude
+    }
+}
+
+/// Whether `coordinate` is a valid latitude and longitude.
+public func CLLocationCoordinate2DIsValid(_ coordinate: CLLocationCoordinate2D) -> Bool {
+    (-90...90).contains(coordinate.latitude) && (-180...180).contains(coordinate.longitude)
+}
+
+/// An invalid coordinate, as Core Location returns when it has none.
+public let kCLLocationCoordinate2DInvalid = CLLocationCoordinate2D(latitude: -180, longitude: -180)

package/Sources/CoreLocation/Location.swift

@@ -0,0 +1,65 @@
+// `CLLocation`: a coordinate with its altitude, accuracy and time, as apps
+// keep one for a place (Food Truck's parking spots). There are no location
+// services, so nothing produces one but the app. Like Apple's (an `NSObject`
+// that does not override `isEqual`), two locations are equal when they are
+// the same object.
+
+#if canImport(WASILibc)
+import WASILibc
+#elseif canImport(Glibc)
+import Glibc
+#elseif canImport(Musl)
+import Musl
+#elseif canImport(Darwin)
+import Darwin
+#endif
+
+public typealias CLLocationAccuracy = Double
+public typealias CLLocationSpeed = Double
+public typealias CLLocationDirection = Double
+
+open class CLLocation: Hashable, @unchecked Sendable {
+    public let coordinate: CLLocationCoordinate2D
+    public let altitude: CLLocationDistance
+    public let horizontalAccuracy: CLLocationAccuracy
+    public let verticalAccuracy: CLLocationAccuracy
+    public let course: CLLocationDirection
+    public let speed: CLLocationSpeed
+    /// Seconds since 1970 (`timestamp` is Foundation's `Date`, which this module does not import).
+    public let _timestamp: Double
+
+    public init(latitude: CLLocationDegrees, longitude: CLLocationDegrees) {
+        coordinate = CLLocationCoordinate2D(latitude: latitude, longitude: longitude)
+        altitude = 0
+        horizontalAccuracy = 0
+        verticalAccuracy = -1
+        course = -1
+        speed = -1
+        _timestamp = 0
+    }
+
+    public init(coordinate: CLLocationCoordinate2D, altitude: CLLocationDistance,
+                horizontalAccuracy: CLLocationAccuracy, verticalAccuracy: CLLocationAccuracy,
+                course: CLLocationDirection = -1, speed: CLLocationSpeed = -1, timestamp: Double = 0) {
+        self.coordinate = coordinate
+        self.altitude = altitude
+        self.horizontalAccuracy = horizontalAccuracy
+        self.verticalAccuracy = verticalAccuracy
+        self.course = course
+        self.speed = speed
+        _timestamp = timestamp
+    }
+
+    /// The great-circle distance to `location`, in meters.
+    public func distance(from location: CLLocation) -> CLLocationDistance {
+        let radians = Double.pi / 180
+        let lat1 = coordinate.latitude * radians, lat2 = location.coordinate.latitude * radians
+        let dLat = lat2 - lat1
+        let dLon = (location.coordinate.longitude - coordinate.longitude) * radians
+        let a = sin(dLat / 2) * sin(dLat / 2) + cos(lat1) * cos(lat2) * sin(dLon / 2) * sin(dLon / 2)
+        return 6_371_000 * 2 * atan2(a.squareRoot(), (1 - a).squareRoot())
+    }
+
+    public static func == (lhs: CLLocation, rhs: CLLocation) -> Bool { lhs === rhs }
+    public func hash(into hasher: inout Hasher) { hasher.combine(ObjectIdentifier(self)) }
+}