@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/CoreHaptics/CoreHaptics.swift

@@ -0,0 +1,399 @@
+// `import CoreHaptics` for the browser: the haptic engine's API, with no
+// engine behind it. A browser cannot drive a Taptic Engine (the Vibration
+// API buzzes some Android phones and nothing else, and has no intensity or
+// sharpness), so `CHHapticEngine.capabilitiesForHardware()` reports neither
+// haptics nor audio, as an iPad or a Mac does. Code that checks it, as
+// Apple's samples and Ice Cubes' `HapticManager` do, skips haptics. Code that
+// does not still runs: an engine starts and stops, patterns are built and
+// validated, and players accept every call and play nothing.
+
+import Foundation
+
+public let CHHapticTimeImmediate: TimeInterval = 0
+
+/// Core Haptics' errors, with Apple's codes.
+public struct CHHapticError: Error, Hashable, Sendable {
+    public enum Code: Int, Sendable {
+        case engineNotRunning = -4805
+        case operationNotPermitted = -4806
+        case engineStartTimeout = -4808
+        case notSupported = -4809
+        case serverInitFailed = -4810
+        case serverInterrupted = -4811
+        case invalidPatternPlayer = -4812
+        case invalidPatternData = -4813
+        case invalidPatternDictionary = -4814
+        case invalidAudioSession = -4815
+        case invalidEngineParameter = -4816
+        case invalidParameterType = -4820
+        case invalidEventType = -4821
+        case invalidEventTime = -4822
+        case invalidEventDuration = -4823
+        case invalidAudioResource = -4824
+        case resourceNotAvailable = -4825
+        case badEventEntry = -4830
+        case badParameterEntry = -4831
+        case invalidTime = -4840
+        case fileNotFound = -4851
+        case insufficientPower = -4897
+        case unknownError = -4898
+        case memoryError = -4899
+    }
+
+    public let code: Code
+    public init(_ code: Code) { self.code = code }
+    public static let notSupported = Code.notSupported
+}
+
+// MARK: - Events and parameters
+
+public struct CHHapticEvent: Sendable {
+    public struct EventType: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let hapticTransient = EventType(rawValue: "HapticTransient")
+        public static let hapticContinuous = EventType(rawValue: "HapticContinuous")
+        public static let audioContinuous = EventType(rawValue: "AudioContinuous")
+        public static let audioCustom = EventType(rawValue: "AudioCustom")
+    }
+
+    public struct ParameterID: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let hapticIntensity = ParameterID(rawValue: "HapticIntensity")
+        public static let hapticSharpness = ParameterID(rawValue: "HapticSharpness")
+        public static let attackTime = ParameterID(rawValue: "AttackTime")
+        public static let decayTime = ParameterID(rawValue: "DecayTime")
+        public static let releaseTime = ParameterID(rawValue: "ReleaseTime")
+        public static let sustained = ParameterID(rawValue: "Sustained")
+        public static let audioVolume = ParameterID(rawValue: "AudioVolume")
+        public static let audioPitch = ParameterID(rawValue: "AudioPitch")
+        public static let audioPan = ParameterID(rawValue: "AudioPan")
+        public static let audioBrightness = ParameterID(rawValue: "AudioBrightness")
+    }
+
+    public let type: EventType
+    public var eventParameters: [CHHapticEventParameter]
+    public var relativeTime: TimeInterval
+    public var duration: TimeInterval
+
+    public init(eventType: EventType, parameters: [CHHapticEventParameter], relativeTime: TimeInterval) {
+        self.init(eventType: eventType, parameters: parameters, relativeTime: relativeTime, duration: 0)
+    }
+
+    public init(eventType: EventType, parameters: [CHHapticEventParameter], relativeTime: TimeInterval, duration: TimeInterval) {
+        self.type = eventType
+        self.eventParameters = parameters
+        self.relativeTime = relativeTime
+        self.duration = duration
+    }
+
+    public init(audioResourceID resID: CHHapticAudioResourceID, parameters: [CHHapticEventParameter], relativeTime: TimeInterval) {
+        self.init(eventType: .audioCustom, parameters: parameters, relativeTime: relativeTime, duration: 0)
+    }
+
+    public init(audioResourceID resID: CHHapticAudioResourceID, parameters: [CHHapticEventParameter], relativeTime: TimeInterval, duration: TimeInterval) {
+        self.init(eventType: .audioCustom, parameters: parameters, relativeTime: relativeTime, duration: duration)
+    }
+}
+
+public typealias CHHapticAudioResourceID = UInt
+public typealias CHHapticEventType = CHHapticEvent.EventType
+public typealias CHHapticEventParameterID = CHHapticEvent.ParameterID
+
+public struct CHHapticEventParameter: Sendable {
+    public let parameterID: CHHapticEvent.ParameterID
+    public var value: Float
+    public init(parameterID: CHHapticEvent.ParameterID, value: Float) {
+        self.parameterID = parameterID
+        self.value = value
+    }
+}
+
+public struct CHHapticDynamicParameter: Sendable {
+    public struct ID: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let hapticIntensityControl = ID(rawValue: "HapticIntensityControl")
+        public static let hapticSharpnessControl = ID(rawValue: "HapticSharpnessControl")
+        public static let hapticAttackTimeControl = ID(rawValue: "HapticAttackTimeControl")
+        public static let hapticDecayTimeControl = ID(rawValue: "HapticDecayTimeControl")
+        public static let hapticReleaseTimeControl = ID(rawValue: "HapticReleaseTimeControl")
+        public static let audioVolumeControl = ID(rawValue: "AudioVolumeControl")
+        public static let audioPanControl = ID(rawValue: "AudioPanControl")
+        public static let audioBrightnessControl = ID(rawValue: "AudioBrightnessControl")
+        public static let audioPitchControl = ID(rawValue: "AudioPitchControl")
+        public static let audioAttackTimeControl = ID(rawValue: "AudioAttackTimeControl")
+        public static let audioDecayTimeControl = ID(rawValue: "AudioDecayTimeControl")
+        public static let audioReleaseTimeControl = ID(rawValue: "AudioReleaseTimeControl")
+    }
+
+    public let parameterID: ID
+    public var value: Float
+    public var relativeTime: TimeInterval
+    public init(parameterID: ID, value: Float, relativeTime: TimeInterval) {
+        self.parameterID = parameterID
+        self.value = value
+        self.relativeTime = relativeTime
+    }
+}
+
+public struct CHHapticParameterCurve: Sendable {
+    public struct ControlPoint: Sendable {
+        public var relativeTime: TimeInterval
+        public var value: Float
+        public init(relativeTime: TimeInterval, value: Float) {
+            self.relativeTime = relativeTime
+            self.value = value
+        }
+    }
+
+    public let parameterID: CHHapticDynamicParameter.ID
+    public var relativeTime: TimeInterval
+    public var controlPoints: [ControlPoint]
+    public init(parameterID: CHHapticDynamicParameter.ID, controlPoints: [ControlPoint], relativeTime: TimeInterval) {
+        self.parameterID = parameterID
+        self.controlPoints = controlPoints
+        self.relativeTime = relativeTime
+    }
+}
+
+// MARK: - Patterns
+
+/// A pattern of events, kept as given. Its duration is the end of its last event.
+public final class CHHapticPattern: @unchecked Sendable {
+    public struct Key: RawRepresentable, Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let version = Key(rawValue: "Version")
+        public static let pattern = Key(rawValue: "Pattern")
+        public static let event = Key(rawValue: "Event")
+        public static let eventType = Key(rawValue: "EventType")
+        public static let time = Key(rawValue: "Time")
+        public static let eventDuration = Key(rawValue: "EventDuration")
+        public static let eventParameters = Key(rawValue: "EventParameters")
+        public static let parameterID = Key(rawValue: "ParameterID")
+        public static let parameterValue = Key(rawValue: "ParameterValue")
+        public static let parameter = Key(rawValue: "Parameter")
+        public static let parameterCurve = Key(rawValue: "ParameterCurve")
+        public static let parameterCurveControlPoints = Key(rawValue: "ParameterCurveControlPoints")
+    }
+
+    public let events: [CHHapticEvent]
+    public let parameters: [CHHapticDynamicParameter]
+    public let parameterCurves: [CHHapticParameterCurve]
+
+    public var duration: TimeInterval {
+        events.map { $0.relativeTime + $0.duration }.max() ?? 0
+    }
+
+    public init(events: [CHHapticEvent], parameters: [CHHapticDynamicParameter]) throws {
+        try Self.validate(events)
+        self.events = events
+        self.parameters = parameters
+        self.parameterCurves = []
+    }
+
+    public init(events: [CHHapticEvent], parameterCurves: [CHHapticParameterCurve]) throws {
+        try Self.validate(events)
+        self.events = events
+        self.parameters = []
+        self.parameterCurves = parameterCurves
+    }
+
+    /// A pattern from an AHAP dictionary: its `Event` entries are read; parameters and curves are not.
+    public convenience init(dictionary: [Key: Any]) throws {
+        guard let entries = dictionary[.pattern] as? [[Key: Any]] else {
+            throw CHHapticError(.invalidPatternDictionary)
+        }
+        var events: [CHHapticEvent] = []
+        for entry in entries {
+            guard let event = entry[.event] as? [Key: Any] else { continue }
+            guard let type = event[.eventType] as? String else { throw CHHapticError(.badEventEntry) }
+            let parameters = (event[.eventParameters] as? [[Key: Any]] ?? []).compactMap { parameter -> CHHapticEventParameter? in
+                guard let id = parameter[.parameterID] as? String else { return nil }
+                let value = (parameter[.parameterValue] as? Double).map(Float.init) ?? (parameter[.parameterValue] as? Float) ?? 0
+                return CHHapticEventParameter(parameterID: .init(rawValue: id), value: value)
+            }
+            events.append(CHHapticEvent(eventType: .init(rawValue: type), parameters: parameters,
+                                        relativeTime: event[.time] as? Double ?? 0,
+                                        duration: event[.eventDuration] as? Double ?? 0))
+        }
+        try self.init(events: events, parameters: [])
+    }
+
+    /// The events as an AHAP dictionary.
+    public func exportDictionary() throws -> [Key: Any] {
+        [.version: 1.0, .pattern: events.map { event -> [Key: Any] in
+            [.event: [
+                .eventType: event.type.rawValue,
+                .time: event.relativeTime,
+                .eventDuration: event.duration,
+                .eventParameters: event.eventParameters.map { [Key.parameterID: $0.parameterID.rawValue, .parameterValue: Double($0.value)] },
+            ] as [Key: Any]]
+        }]
+    }
+
+    private static func validate(_ events: [CHHapticEvent]) throws {
+        for event in events {
+            if event.relativeTime < 0 { throw CHHapticError(.invalidEventTime) }
+            if event.duration < 0 { throw CHHapticError(.invalidEventDuration) }
+        }
+    }
+}
+
+// MARK: - Players
+
+/// Plays a pattern. Here every call succeeds and nothing is felt or heard.
+public protocol CHHapticPatternPlayer: AnyObject {
+    var isMuted: Bool { get set }
+    func start(atTime time: TimeInterval) throws
+    func stop(atTime time: TimeInterval) throws
+    func sendParameters(_ parameters: [CHHapticDynamicParameter], atTime time: TimeInterval) throws
+    func scheduleParameterCurve(_ parameterCurve: CHHapticParameterCurve, atTime time: TimeInterval) throws
+    func cancel() throws
+}
+
+public protocol CHHapticAdvancedPatternPlayer: CHHapticPatternPlayer {
+    var loopEnabled: Bool { get set }
+    var loopEnd: TimeInterval { get set }
+    var playbackRate: Float { get set }
+    var completionHandler: CHHapticAdvancedPatternPlayerCompletionHandler? { get set }
+    func pause(atTime time: TimeInterval) throws
+    func resume(atTime time: TimeInterval) throws
+    func seek(toOffset offsetTime: TimeInterval) throws
+}
+
+public typealias CHHapticAdvancedPatternPlayerCompletionHandler = @Sendable (Error?) -> Void
+
+final class _SilentPlayer: CHHapticAdvancedPatternPlayer, @unchecked Sendable {
+    let pattern: CHHapticPattern?
+    var isMuted = false
+    var loopEnabled = false
+    var loopEnd: TimeInterval = 0
+    var playbackRate: Float = 1
+    var completionHandler: CHHapticAdvancedPatternPlayerCompletionHandler?
+
+    init(pattern: CHHapticPattern?) { self.pattern = pattern }
+
+    func start(atTime time: TimeInterval) throws {}
+    func stop(atTime time: TimeInterval) throws {}
+    func sendParameters(_ parameters: [CHHapticDynamicParameter], atTime time: TimeInterval) throws {}
+    func scheduleParameterCurve(_ parameterCurve: CHHapticParameterCurve, atTime time: TimeInterval) throws {}
+    func cancel() throws {}
+    func pause(atTime time: TimeInterval) throws {}
+    func resume(atTime time: TimeInterval) throws {}
+    func seek(toOffset offsetTime: TimeInterval) throws {}
+}
+
+// MARK: - Capabilities
+
+public protocol CHHapticParameterAttributes {
+    var minValue: Float { get }
+    var maxValue: Float { get }
+    var defaultValue: Float { get }
+}
+
+/// What the hardware can play.
+public protocol CHHapticDeviceCapability {
+    var supportsHaptics: Bool { get }
+    var supportsAudio: Bool { get }
+    func attributes(forEventParameter inParameter: CHHapticEvent.ParameterID, eventType type: CHHapticEvent.EventType) throws -> CHHapticParameterAttributes
+    func attributes(forDynamicParameter inParameter: CHHapticDynamicParameter.ID) throws -> CHHapticParameterAttributes
+}
+
+struct _Attributes: CHHapticParameterAttributes {
+    var minValue: Float = 0
+    var maxValue: Float = 1
+    var defaultValue: Float = 0
+}
+
+/// The browser's: no haptics, no audio.
+struct _BrowserCapability: CHHapticDeviceCapability {
+    var supportsHaptics: Bool { false }
+    var supportsAudio: Bool { false }
+    func attributes(forEventParameter inParameter: CHHapticEvent.ParameterID, eventType type: CHHapticEvent.EventType) throws -> CHHapticParameterAttributes { _Attributes() }
+    func attributes(forDynamicParameter inParameter: CHHapticDynamicParameter.ID) throws -> CHHapticParameterAttributes { _Attributes() }
+}
+
+// MARK: - The engine
+
+/// The haptic engine. `capabilitiesForHardware()` reports no haptics; the
+/// engine still starts, stops and makes players, which play nothing.
+open class CHHapticEngine: @unchecked Sendable {
+    public enum StoppedReason: Int, Sendable {
+        case audioSessionInterrupt = 1, applicationSuspended, idleTimeout, notifyWhenFinished,
+             engineDestroyed, gameControllerDisconnect, systemError = -1
+    }
+
+    public enum FinishedAction: Int, Sendable {
+        case stopEngine = 1, leaveEngineRunning
+    }
+
+    public typealias StoppedHandler = @Sendable (StoppedReason) -> Void
+    public typealias ResetHandler = @Sendable () -> Void
+    public typealias CompletionHandler = @Sendable (Error?) -> Void
+    public typealias FinishedHandler = @Sendable (Error?) -> FinishedAction
+
+    open var stoppedHandler: StoppedHandler = { _ in }
+    open var resetHandler: ResetHandler = {}
+    open var playsHapticsOnly = false
+    open var playsAudioOnly = false
+    open var isMutedForAudio = false
+    open var isMutedForHaptics = false
+    open var isAutoShutdownEnabled = false
+    /// Whether `start` was called more recently than `stop`.
+    public private(set) var isRunning = false
+
+    /// No haptics and no audio: the browser has no haptic engine.
+    public class func capabilitiesForHardware() -> CHHapticDeviceCapability { _BrowserCapability() }
+
+    public init() throws {}
+    public init(audioSession: AnyObject?) throws {}
+
+    /// Seconds since the engine was made (the hardware clock patterns are timed by).
+    open var currentTime: TimeInterval { Date().timeIntervalSince(created) }
+    private let created = Date()
+
+    open func start() async throws { isRunning = true }
+    open func start(completionHandler: CompletionHandler? = nil) {
+        isRunning = true
+        completionHandler?(nil)
+    }
+    open func startAndReturnError() throws { isRunning = true }
+
+    open func stop() async throws { isRunning = false }
+    open func stop(completionHandler: CompletionHandler? = nil) {
+        isRunning = false
+        completionHandler?(nil)
+    }
+
+    /// Calls `finishedHandler` at once: no player is ever playing.
+    open func notifyWhenPlayersFinished(finishedHandler: @escaping FinishedHandler) {
+        if finishedHandler(nil) == .stopEngine { isRunning = false }
+    }
+
+    open func makePlayer(with pattern: CHHapticPattern) throws -> CHHapticPatternPlayer { _SilentPlayer(pattern: pattern) }
+    open func makeAdvancedPlayer(with pattern: CHHapticPattern) throws -> CHHapticAdvancedPatternPlayer { _SilentPlayer(pattern: pattern) }
+
+    /// Reads and checks an AHAP file; plays nothing.
+    open func playPattern(from url: URL) throws {
+        guard let data = try? Data(contentsOf: url) else { throw CHHapticError(.fileNotFound) }
+        try playPattern(from: data)
+    }
+
+    /// Checks AHAP data (JSON); plays nothing.
+    open func playPattern(from data: Data) throws {
+        guard (try? JSONSerialization.jsonObject(with: data)) is [String: Any] else {
+            throw CHHapticError(.invalidPatternData)
+        }
+    }
+
+    /// Audio resources are accepted and never played.
+    open func registerAudioResource(_ resourceURL: URL, options: [AnyHashable: Any] = [:]) throws -> CHHapticAudioResourceID {
+        nextResource += 1
+        return nextResource
+    }
+    open func unregisterAudioResource(_ resourceID: CHHapticAudioResourceID) throws {}
+    private var nextResource: CHHapticAudioResourceID = 0
+}

package/Sources/CoreImage/CIColor.swift

@@ -0,0 +1,41 @@
+// Core Image's color: RGBA components in 0…1, as code reads them back from a
+// UIColor or a Color (`CIColor(color:)` is UIKit's, in Sources/UIKit).
+
+import SwiftUI
+
+public final class CIColor: Hashable, @unchecked Sendable, CustomStringConvertible {
+    public let red: CGFloat
+    public let green: CGFloat
+    public let blue: CGFloat
+    public let alpha: CGFloat
+    public var numberOfComponents: Int { 4 }
+    public var components: [CGFloat] { [red, green, blue, alpha] }
+
+    public init(red: CGFloat, green: CGFloat, blue: CGFloat, alpha: CGFloat = 1) {
+        (self.red, self.green, self.blue, self.alpha) = (red, green, blue, alpha)
+    }
+
+    /// "r g b a", as Core Image writes it.
+    public convenience init(string representation: String) {
+        let values = representation.split(separator: " ").compactMap { Double($0) }.map { CGFloat($0) }
+        self.init(red: values.count > 0 ? values[0] : 0, green: values.count > 1 ? values[1] : 0,
+                  blue: values.count > 2 ? values[2] : 0, alpha: values.count > 3 ? values[3] : 1)
+    }
+
+    public var stringRepresentation: String { "\(red) \(green) \(blue) \(alpha)" }
+    public var description: String { stringRepresentation }
+
+    public static let black = CIColor(red: 0, green: 0, blue: 0)
+    public static let white = CIColor(red: 1, green: 1, blue: 1)
+    public static let gray = CIColor(red: 0.5, green: 0.5, blue: 0.5)
+    public static let red = CIColor(red: 1, green: 0, blue: 0)
+    public static let green = CIColor(red: 0, green: 1, blue: 0)
+    public static let blue = CIColor(red: 0, green: 0, blue: 1)
+    public static let cyan = CIColor(red: 0, green: 1, blue: 1)
+    public static let magenta = CIColor(red: 1, green: 0, blue: 1)
+    public static let yellow = CIColor(red: 1, green: 1, blue: 0)
+    public static let clear = CIColor(red: 0, green: 0, blue: 0, alpha: 0)
+
+    public static func == (lhs: CIColor, rhs: CIColor) -> Bool { lhs.components == rhs.components }
+    public func hash(into hasher: inout Hasher) { hasher.combine(components) }
+}

package/Sources/CoreImage/CIContext.swift

@@ -0,0 +1,31 @@
+import SwiftUI
+
+/// Options for a context; accepted and ignored.
+public struct CIContextOption: Hashable, RawRepresentable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+
+    public static let useSoftwareRenderer = CIContextOption(rawValue: "kCIContextUseSoftwareRenderer")
+    public static let workingColorSpace = CIContextOption(rawValue: "kCIContextWorkingColorSpace")
+    public static let outputColorSpace = CIContextOption(rawValue: "kCIContextOutputColorSpace")
+    public static let cacheIntermediates = CIContextOption(rawValue: "kCIContextCacheIntermediates")
+    public static let priorityRequestLow = CIContextOption(rawValue: "kCIContextPriorityRequestLow")
+    public static let highQualityDownsample = CIContextOption(rawValue: "kCIContextHighQualityDownsample")
+    public static let useSoftwareRendererIfNeeded = CIContextOption(rawValue: "kCIContextUseSoftwareRenderer")
+}
+
+/// Where Core Image renders. Rendering here is a promise: `createCGImage`
+/// returns at once a bitmap whose recipe the page runs when the image is
+/// drawn, so a context is cheap and holds nothing.
+public final class CIContext: @unchecked Sendable {
+    public init() {}
+    public init(options: [CIContextOption: Any]?) {}
+
+    /// The part of `image` inside `fromRect` (rounded out to whole pixels) as
+    /// a bitmap of that size, clear where the image does not reach; nil for
+    /// an infinite or empty rectangle, as on Apple platforms.
+    public func createCGImage(_ image: CIImage, from fromRect: CGRect) -> CGImage? {
+        guard let recipe = image._recipe.rendered(in: fromRect) else { return nil }
+        return CGImage(_recipe: recipe)
+    }
+}

package/Sources/CoreImage/CIDetector.swift

@@ -0,0 +1,57 @@
+// Core Image's feature detectors, as code that scans a picked photo for a QR
+// code (CodeScanner's gallery) calls them. Swift holds no decoded pixels
+// (docs/ops-protocol.md, "Bitmaps and Core Image") and the page's
+// `BarcodeDetector` answers asynchronously, so `features(in:)`, which is
+// synchronous, finds nothing: the code reports that the image has no code.
+
+import struct Foundation.Data
+import SwiftUI
+
+public let CIDetectorTypeQRCode = "CIDetectorTypeQRCode"
+public let CIDetectorTypeFace = "CIDetectorTypeFace"
+public let CIDetectorTypeRectangle = "CIDetectorTypeRectangle"
+public let CIDetectorTypeText = "CIDetectorTypeText"
+public let CIDetectorAccuracy = "CIDetectorAccuracy"
+public let CIDetectorAccuracyHigh = "CIDetectorAccuracyHigh"
+public let CIDetectorAccuracyLow = "CIDetectorAccuracyLow"
+
+/// Finds features in an image: none, in the browser.
+open class CIDetector: @unchecked Sendable {
+    public let type: String
+
+    public init?(ofType type: String, context: CIContext?, options: [String: Any]? = nil) {
+        self.type = type
+    }
+
+    open func features(in image: CIImage) -> [CIFeature] { [] }
+    open func features(in image: CIImage, options: [String: Any]? = nil) -> [CIFeature] { [] }
+}
+
+/// Something a detector found.
+open class CIFeature: @unchecked Sendable {
+    public let type: String
+    public let bounds: CGRect
+
+    init(type: String, bounds: CGRect) {
+        self.type = type
+        self.bounds = bounds
+    }
+}
+
+/// A QR code a detector found.
+open class CIQRCodeFeature: CIFeature, @unchecked Sendable {
+    public let messageString: String?
+    public let topLeft: CGPoint
+    public let topRight: CGPoint
+    public let bottomLeft: CGPoint
+    public let bottomRight: CGPoint
+
+    init(messageString: String?, topLeft: CGPoint, topRight: CGPoint, bottomLeft: CGPoint, bottomRight: CGPoint) {
+        self.messageString = messageString
+        self.topLeft = topLeft
+        self.topRight = topRight
+        self.bottomLeft = bottomLeft
+        self.bottomRight = bottomRight
+        super.init(type: CIDetectorTypeQRCode, bounds: CGRect(x: bottomLeft.x, y: bottomLeft.y, width: topRight.x - bottomLeft.x, height: topRight.y - bottomLeft.y))
+    }
+}