@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/ImageIO/GIF.swift

@@ -0,0 +1,72 @@
+// The structure of a GIF file, as Image I/O reports it: how many frames it
+// has, each frame's delay and the number of times it loops. Reading it walks
+// the file's blocks without decoding a pixel; the page decodes and composes
+// a frame when it draws it (Web/src/gif.ts, docs/ops-protocol.md, "Animated
+// GIFs").
+
+/// A GIF's frames and loop count.
+struct _GIFStructure: Equatable {
+    struct Frame: Equatable {
+        /// The graphic control extension's delay, in hundredths of a second.
+        var delay: Int
+    }
+
+    var frames: [Frame]
+    /// The Netscape application extension's count: 0 loops forever; nil when
+    /// the file has none (it plays once).
+    var loopCount: Int?
+    var hasGlobalColorMap: Bool
+
+    /// The structure of a GIF file; nil for anything else. A file cut short
+    /// has the frames that start before the cut.
+    static func parse(_ bytes: [UInt8]) -> _GIFStructure? {
+        guard bytes.count >= 13, bytes.starts(with: Array("GIF87a".utf8)) || bytes.starts(with: Array("GIF89a".utf8)) else { return nil }
+        let screen = bytes[10]
+        let hasGlobalColorMap = screen & 0x80 != 0
+        var index = 13 + (hasGlobalColorMap ? 3 << (Int(screen & 0x07) + 1) : 0)
+        var structure = _GIFStructure(frames: [], loopCount: nil, hasGlobalColorMap: hasGlobalColorMap)
+        var delay = 0
+
+        /// The index after the data sub-blocks starting at `start`; nil when the file ends first.
+        func skipSubBlocks(_ start: Int) -> Int? {
+            var at = start
+            while at < bytes.count {
+                let size = Int(bytes[at])
+                if size == 0 { return at + 1 }
+                at += 1 + size
+            }
+            return nil
+        }
+
+        while index < bytes.count {
+            switch bytes[index] {
+            case 0x21: // An extension: its label, then data sub-blocks.
+                guard index + 1 < bytes.count else { return structure }
+                let label = bytes[index + 1]
+                let body = index + 2
+                if label == 0xF9, body + 4 < bytes.count, bytes[body] >= 4 {
+                    delay = Int(bytes[body + 2]) | Int(bytes[body + 3]) << 8
+                }
+                if label == 0xFF, body + 16 < bytes.count, bytes[body] == 11,
+                   bytes[(body + 1)...(body + 11)].elementsEqual(Array("NETSCAPE2.0".utf8)) || bytes[(body + 1)...(body + 11)].elementsEqual(Array("ANIMEXTS1.0".utf8)),
+                   bytes[body + 12] >= 3, bytes[body + 13] == 1 {
+                    structure.loopCount = Int(bytes[body + 14]) | Int(bytes[body + 15]) << 8
+                }
+                guard let next = skipSubBlocks(body) else { return structure }
+                index = next
+            case 0x2C: // An image: its descriptor, a local color table, the LZW code size, the data.
+                guard index + 9 < bytes.count else { return structure }
+                let packed = bytes[index + 9]
+                var at = index + 10
+                if packed & 0x80 != 0 { at += 3 << (Int(packed & 0x07) + 1) }
+                guard at < bytes.count, let next = skipSubBlocks(at + 1) else { return structure }
+                structure.frames.append(Frame(delay: delay))
+                delay = 0
+                index = next
+            default: // The trailer (0x3B), or something that is not a block.
+                return structure
+            }
+        }
+        return structure
+    }
+}

package/Sources/ImageIO/ImageIO.swift

@@ -0,0 +1,248 @@
+// `import ImageIO` for the browser: image sources over the shim's decoder.
+// `CGImageSourceCreateWithData` reads the file's header (format, size)
+// without decoding it; an image made from the source is a `CGImage` whose
+// recipe is the file, which the page decodes when it draws it (with its
+// EXIF rotation applied, so the properties report `.up`). An animated GIF
+// has one image per frame, with its delay and the file's loop count in the
+// properties (GIF.swift); the page composes the frame. Thumbnails are the
+// image scaled to the requested size. Incremental sources produce no image
+// until the data is complete. Destinations (encoding) are not available:
+// creating one fails. See docs/ops-protocol.md, "Core Graphics and Image I/O"
+// and "Animated GIFs".
+
+@_exported import CoreGraphics
+import struct Foundation.Data
+import struct Foundation.URL
+import class Foundation.NSMutableData
+import SwiftUI
+
+// Core Foundation's types, as Image I/O takes them (`data as CFData`,
+// `options as CFDictionary`: plain Swift values here).
+@_exported import CoreFoundationTypes
+
+/// An image file, or the bytes of one so far.
+public final class CGImageSource: @unchecked Sendable {
+    var data: Data {
+        didSet { read() }
+    }
+    var header: _ImageHeader?
+    /// A GIF's frames, read once the data is set.
+    var gif: _GIFStructure?
+    let isIncremental: Bool
+    var isFinal: Bool
+
+    init(data: Data, incremental: Bool, final: Bool) {
+        self.data = data
+        self.isIncremental = incremental
+        self.isFinal = final
+        read()
+    }
+
+    private func read() {
+        header = _ImageHeader.parse([UInt8](data.prefix(64 * 1024)))
+        gif = header?.mime == "image/gif" ? _GIFStructure.parse([UInt8](data)) : nil
+    }
+
+    /// The number of images: a GIF's frames (at least one once its header is
+    /// read), one for any other file.
+    var count: Int {
+        guard header != nil else { return 0 }
+        return max(1, gif?.frames.count ?? 1)
+    }
+
+    /// Whether the images are frames the page composes (an animated GIF).
+    var isAnimated: Bool { (gif?.frames.count ?? 0) > 1 }
+
+    /// The decoded file, ready to draw.
+    var source: _ImageSource? {
+        guard isFinal || !isIncremental else { return nil }
+        return _ImageSource(encoded: [UInt8](data))
+    }
+}
+
+public enum CGImageSourceStatus: Int32, Sendable {
+    case statusUnexpectedEOF = -5, statusInvalidData = -4, statusUnknownType = -3, statusReadingHeader = -2, statusIncomplete = -1, statusComplete = 0
+}
+
+public func CGImageSourceCreateWithData(_ data: CFData, _ options: CFDictionary?) -> CGImageSource? {
+    let source = CGImageSource(data: data, incremental: false, final: true)
+    return source.header == nil ? nil : source
+}
+
+/// A source over the file at a file URL (the app's own files); nil for
+/// another scheme or a file that is not an image.
+public func CGImageSourceCreateWithURL(_ url: Any, _ options: CFDictionary?) -> CGImageSource? {
+    guard let url = url as? URL, url.isFileURL, let data = try? Data(contentsOf: url) else { return nil }
+    return CGImageSourceCreateWithData(data, options)
+}
+
+public func CGImageSourceCreateIncremental(_ options: CFDictionary?) -> CGImageSource {
+    CGImageSource(data: Data(), incremental: true, final: false)
+}
+
+public func CGImageSourceUpdateData(_ source: CGImageSource, _ data: CFData, _ final: Bool) {
+    source.isFinal = final
+    source.data = data
+}
+
+public func CGImageSourceGetStatus(_ source: CGImageSource) -> CGImageSourceStatus {
+    guard source.header != nil else { return source.data.isEmpty ? .statusReadingHeader : .statusUnknownType }
+    return source.isFinal ? .statusComplete : .statusIncomplete
+}
+
+public func CGImageSourceGetStatusAtIndex(_ source: CGImageSource, _ index: Int) -> CGImageSourceStatus {
+    index >= 0 && index < source.count ? CGImageSourceGetStatus(source) : .statusInvalidData
+}
+
+/// The number of images: a GIF's frames, one for any other file.
+public func CGImageSourceGetCount(_ source: CGImageSource) -> Int { source.count }
+
+/// The file's uniform type identifier (`public.png`, `public.jpeg`, `com.compuserve.gif`, …).
+public func CGImageSourceGetType(_ source: CGImageSource) -> CFString? {
+    _uniformType(ofMIME: source.header?.mime)
+}
+
+/// The file's size and, for a GIF, its loop count (0: forever; absent when
+/// the file plays once), canvas size and whether it has a global color map.
+public func CGImageSourceCopyProperties(_ source: CGImageSource, _ options: CFDictionary?) -> CFDictionary? {
+    guard let header = source.header else { return nil }
+    var properties: [String: Any] = [kCGImagePropertyFileSize: source.data.count]
+    if let gif = source.gif {
+        var dictionary: [String: Any] = [
+            kCGImagePropertyGIFHasGlobalColorMap: gif.hasGlobalColorMap,
+            kCGImagePropertyGIFCanvasPixelWidth: header.width,
+            kCGImagePropertyGIFCanvasPixelHeight: header.height,
+        ]
+        if let loopCount = gif.loopCount { dictionary[kCGImagePropertyGIFLoopCount] = loopCount }
+        properties[kCGImagePropertyGIFDictionary] = dictionary
+    }
+    return properties
+}
+
+/// The size and orientation (always up: the page applies EXIF rotation) of
+/// image `index`; a GIF frame's delay in seconds, unclamped and as Image I/O
+/// clamps it (a delay under 11 ms is shown for 100 ms, as browsers do).
+public func CGImageSourceCopyPropertiesAtIndex(_ source: CGImageSource, _ index: Int, _ options: CFDictionary?) -> CFDictionary? {
+    guard index >= 0, index < source.count, let header = source.header else { return nil }
+    var properties: [String: Any] = [
+        kCGImagePropertyPixelWidth: header.width,
+        kCGImagePropertyPixelHeight: header.height,
+        kCGImagePropertyOrientation: UInt32(1),
+    ]
+    if header.mime == "image/jpeg" {
+        properties[kCGImagePropertyJFIFDictionary] = [kCGImagePropertyJFIFIsProgressive: _isProgressiveJPEG([UInt8](source.data.prefix(64 * 1024)))] as [String: Any]
+    }
+    if header.mime == "image/gif" {
+        var dictionary = [String: Any]()
+        if let frame = source.gif?.frames[safe: index] {
+            let unclamped = Double(frame.delay) / 100
+            dictionary[kCGImagePropertyGIFUnclampedDelayTime] = unclamped
+            dictionary[kCGImagePropertyGIFDelayTime] = unclamped < 0.011 ? 0.1 : unclamped
+        }
+        properties[kCGImagePropertyGIFDictionary] = dictionary
+    }
+    return properties
+}
+
+/// Image `index`: the file, or one frame of an animated GIF as the earlier
+/// frames leave the canvas (the page composes it).
+public func CGImageSourceCreateImageAtIndex(_ source: CGImageSource, _ index: Int, _ options: CFDictionary?) -> CGImage? {
+    guard index >= 0, index < source.count, let decoded = source.source else { return nil }
+    return CGImage(_recipe: _ImageRecipe(source: decoded, frame: source.isAnimated ? index : nil))
+}
+
+extension Array {
+    fileprivate subscript(safe index: Int) -> Element? { indices.contains(index) ? self[index] : nil }
+}
+
+/// The image scaled down so its longer side is at most
+/// `kCGImageSourceThumbnailMaxPixelSize` (the whole image without it).
+public func CGImageSourceCreateThumbnailAtIndex(_ source: CGImageSource, _ index: Int, _ options: CFDictionary?) -> CGImage? {
+    guard let image = CGImageSourceCreateImageAtIndex(source, index, options) else { return nil }
+    let maxSize = (options?[kCGImageSourceThumbnailMaxPixelSize] as? Int).map(Double.init)
+        ?? (options?[kCGImageSourceThumbnailMaxPixelSize] as? Double)
+        ?? (options?[kCGImageSourceThumbnailMaxPixelSize] as? CGFloat)
+    let longer = Double(max(image.width, image.height))
+    guard let maxSize, maxSize > 0, longer > maxSize else { return image }
+    let scale = maxSize / longer
+    let size = CGSize(width: (Double(image.width) * scale).rounded(), height: (Double(image.height) * scale).rounded())
+    guard let ctx = CGContext(data: nil, width: Int(size.width), height: Int(size.height), bitsPerComponent: 8, bytesPerRow: 0,
+                              space: CGColorSpaceCreateDeviceRGB(), bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue) else { return image }
+    ctx.draw(image, in: CGRect(origin: .zero, size: size))
+    return ctx.makeImage()
+}
+
+/// Whether a JPEG's first frame header is progressive (SOF2).
+func _isProgressiveJPEG(_ bytes: [UInt8]) -> Bool {
+    var i = 2
+    while i + 3 < bytes.count, bytes[i] == 0xFF {
+        let marker = bytes[i + 1]
+        if marker == 0xC2 { return true }
+        if marker >= 0xC0 && marker <= 0xCF && marker != 0xC4 && marker != 0xC8 && marker != 0xCC { return false }
+        let length = Int(bytes[i + 2]) << 8 | Int(bytes[i + 3])
+        i += 2 + length
+    }
+    return false
+}
+
+// MARK: - Destinations
+
+/// Encoding is not available in the browser: no destination can be created.
+public final class CGImageDestination: @unchecked Sendable {}
+
+public func CGImageDestinationCreateWithData(_ data: Any, _ type: CFString, _ count: Int, _ options: CFDictionary?) -> CGImageDestination? { nil }
+public func CGImageDestinationAddImage(_ destination: CGImageDestination, _ image: CGImage, _ properties: CFDictionary?) {}
+public func CGImageDestinationFinalize(_ destination: CGImageDestination) -> Bool { false }
+public func CGImageDestinationCopyTypeIdentifiers() -> [String] { [] }
+
+// MARK: - Orientation
+
+public enum CGImagePropertyOrientation: UInt32, Sendable {
+    case up = 1, upMirrored, down, downMirrored, leftMirrored, right, rightMirrored, left
+}
+
+// MARK: - Keys
+
+public let kCGImageSourceTypeIdentifierHint: CFString = "kCGImageSourceTypeIdentifierHint"
+public let kCGImageSourceShouldCache: CFString = "kCGImageSourceShouldCache"
+public let kCGImageSourceShouldCacheImmediately: CFString = "kCGImageSourceShouldCacheImmediately"
+public let kCGImageSourceShouldAllowFloat: CFString = "kCGImageSourceShouldAllowFloat"
+public let kCGImageSourceCreateThumbnailFromImageIfAbsent: CFString = "kCGImageSourceCreateThumbnailFromImageIfAbsent"
+public let kCGImageSourceCreateThumbnailFromImageAlways: CFString = "kCGImageSourceCreateThumbnailFromImageAlways"
+public let kCGImageSourceThumbnailMaxPixelSize: CFString = "kCGImageSourceThumbnailMaxPixelSize"
+public let kCGImageSourceCreateThumbnailWithTransform: CFString = "kCGImageSourceCreateThumbnailWithTransform"
+public let kCGImageSourceSubsampleFactor: CFString = "kCGImageSourceSubsampleFactor"
+
+public let kCGImagePropertyFileSize: CFString = "FileSize"
+public let kCGImagePropertyPixelWidth: CFString = "PixelWidth"
+public let kCGImagePropertyPixelHeight: CFString = "PixelHeight"
+public let kCGImagePropertyOrientation: CFString = "Orientation"
+public let kCGImagePropertyDPIWidth: CFString = "DPIWidth"
+public let kCGImagePropertyDPIHeight: CFString = "DPIHeight"
+public let kCGImagePropertyHasAlpha: CFString = "HasAlpha"
+public let kCGImagePropertyColorModel: CFString = "ColorModel"
+public let kCGImagePropertyJFIFDictionary: CFString = "{JFIF}"
+public let kCGImagePropertyJFIFIsProgressive: CFString = "IsProgressive"
+public let kCGImagePropertyGIFDictionary: CFString = "{GIF}"
+public let kCGImagePropertyGIFDelayTime: CFString = "DelayTime"
+public let kCGImagePropertyGIFUnclampedDelayTime: CFString = "UnclampedDelayTime"
+public let kCGImagePropertyGIFLoopCount: CFString = "LoopCount"
+public let kCGImagePropertyGIFHasGlobalColorMap: CFString = "HasGlobalColorMap"
+public let kCGImagePropertyGIFCanvasPixelWidth: CFString = "CanvasPixelWidth"
+public let kCGImagePropertyGIFCanvasPixelHeight: CFString = "CanvasPixelHeight"
+public let kCGImagePropertyPNGDictionary: CFString = "{PNG}"
+public let kCGImagePropertyAPNGDelayTime: CFString = "DelayTime"
+public let kCGImagePropertyAPNGUnclampedDelayTime: CFString = "UnclampedDelayTime"
+public let kCGImagePropertyAPNGLoopCount: CFString = "LoopCount"
+public let kCGImagePropertyWebPDictionary: CFString = "{WebP}"
+public let kCGImagePropertyWebPDelayTime: CFString = "DelayTime"
+public let kCGImagePropertyWebPUnclampedDelayTime: CFString = "UnclampedDelayTime"
+public let kCGImagePropertyWebPLoopCount: CFString = "LoopCount"
+public let kCGImagePropertyHEICSDictionary: CFString = "{HEICS}"
+public let kCGImagePropertyHEICSDelayTime: CFString = "DelayTime"
+public let kCGImagePropertyHEICSUnclampedDelayTime: CFString = "UnclampedDelayTime"
+public let kCGImagePropertyExifDictionary: CFString = "{Exif}"
+public let kCGImagePropertyTIFFDictionary: CFString = "{TIFF}"
+public let kCGImageDestinationLossyCompressionQuality: CFString = "kCGImageDestinationLossyCompressionQuality"
+public let kCGImageDestinationEmbedThumbnail: CFString = "kCGImageDestinationEmbedThumbnail"
+public let kCGImageDestinationImageMaxPixelSize: CFString = "kCGImageDestinationImageMaxPixelSize"

package/Sources/ImageIO/ImageTypes.swift

@@ -0,0 +1,28 @@
+// `CGImage.utType` (iOS 15): the type of the file an image was decoded
+// from. An image straight from a file (an image source's, a `UIImage(data:)`'s)
+// has its file's type; one drawn or filtered since has none, as on iOS.
+
+import SwiftUI
+
+extension CGImage {
+    /// The uniform type identifier of the file the image is (`public.png`,
+    /// `public.jpeg`, …); nil once it has been drawn or filtered.
+    public var utType: CFString? {
+        guard _recipe.steps.isEmpty, let mime = _recipe.source?.mime else { return nil }
+        return _uniformType(ofMIME: mime)
+    }
+}
+
+/// The identifier of an image MIME type.
+func _uniformType(ofMIME mime: String?) -> CFString? {
+    switch mime {
+    case "image/png": "public.png"
+    case "image/jpeg": "public.jpeg"
+    case "image/gif": "com.compuserve.gif"
+    case "image/webp": "org.webmproject.webp"
+    case "image/heic": "public.heic"
+    case "image/avif": "public.avif"
+    case "image/bmp": "com.microsoft.bmp"
+    default: nil
+    }
+}

package/Sources/LinkPresentation/LinkPresentation.swift

@@ -0,0 +1,249 @@
+// `import LinkPresentation` for the browser: link previews.
+//
+// `LPLinkMetadata` (declared in UIKit, which needs it for the share sheet's
+// item sources, and re-exported here) is a plain record of a link's title,
+// URL and pictures; an app that fills it in itself (Ice Cubes' share sheet
+// does) gets what it put there, and the share sheet uses its title.
+//
+// `LPMetadataProvider` fetches the page with the app's `URLSession` (the
+// page's `fetch`) and reads its title and Open Graph tags. A browser only
+// lets a page read another site's HTML when that site allows it (CORS), and
+// most do not, so for most links the fetch fails and the provider reports
+// `LPError.metadataFetchFailed`, as iOS does for a page it cannot load.
+// `LPLinkView` keeps its metadata and draws nothing (docs/ops-protocol.md,
+// "Sharing and media").
+
+@_exported import class UIKit.LPLinkMetadata
+import Foundation
+import FoundationBridge
+import SwiftUI
+import UIKit
+
+public let LPErrorDomain = "LPErrorDomain"
+
+/// Why fetching metadata failed, with LinkPresentation's codes.
+public struct LPError: Error, Hashable, Sendable, CustomNSError {
+    public enum Code: Int, Sendable {
+        case unknown = 1
+        case metadataFetchFailed = 2
+        case metadataFetchCancelled = 3
+        case metadataFetchTimedOut = 4
+        case metadataFetchNotAllowed = 5
+    }
+
+    public let code: Code
+    public init(_ code: Code) { self.code = code }
+
+    public static var unknown: Code { .unknown }
+    public static var metadataFetchFailed: Code { .metadataFetchFailed }
+    public static var metadataFetchCancelled: Code { .metadataFetchCancelled }
+    public static var metadataFetchTimedOut: Code { .metadataFetchTimedOut }
+    public static var metadataFetchNotAllowed: Code { .metadataFetchNotAllowed }
+
+    public static var errorDomain: String { LPErrorDomain }
+    public var errorCode: Int { code.rawValue }
+    public var errorUserInfo: [String: Any] { [:] }
+}
+
+/// `catch LPError.metadataFetchFailed`, as with an imported error.
+public func ~= (code: LPError.Code, error: any Error) -> Bool {
+    (error as? LPError)?.code == code
+}
+
+/// Fetches a link's metadata: the page's title and Open Graph tags, where
+/// the site lets the browser read it (see the top of the file). One fetch
+/// per provider, as on iOS.
+public final class LPMetadataProvider: @unchecked Sendable {
+    /// Whether to load the icon and image too. Kept: the metadata names
+    /// them by URL (`imageProvider` loads the picture on request).
+    public var shouldFetchSubresources = true
+    /// Seconds before the fetch gives up (`metadataFetchTimedOut`).
+    public var timeout: TimeInterval = 30
+
+    private var started = false
+    private var cancelled = false
+    private var task: Task<Void, Never>?
+
+    public init() {}
+
+    public func startFetchingMetadata(for url: URL, completionHandler: @escaping @Sendable (LPLinkMetadata?, (any Error)?) -> Void) {
+        guard !started else {
+            completionHandler(nil, LPError(.unknown))
+            return
+        }
+        started = true
+        task = Task { @MainActor [self] in
+            do {
+                let metadata = try await fetch(url)
+                completionHandler(cancelled ? nil : metadata, cancelled ? LPError(.metadataFetchCancelled) : nil)
+            } catch {
+                completionHandler(nil, error)
+            }
+        }
+    }
+
+    public func startFetchingMetadata(for url: URL) async throws -> LPLinkMetadata {
+        guard !started else { throw LPError(.unknown) }
+        started = true
+        let metadata = try await fetch(url)
+        if cancelled { throw LPError(.metadataFetchCancelled) }
+        return metadata
+    }
+
+    /// Stops a fetch: its handler hears `metadataFetchCancelled`.
+    public func cancel() {
+        cancelled = true
+        task?.cancel()
+    }
+
+    @MainActor
+    private func fetch(_ url: URL) async throws -> LPLinkMetadata {
+        guard let scheme = url.scheme?.lowercased(), scheme == "http" || scheme == "https" else { throw LPError(.metadataFetchNotAllowed) }
+        var request = FoundationBridge.URLRequest(url: url)
+        request.timeoutInterval = timeout
+        let data: Data
+        let response: FoundationBridge.URLResponse
+        do {
+            (data, response) = try await FoundationBridge.URLSession.shared.data(for: request)
+        } catch let error as FoundationBridge.URLError where error.code == .timedOut {
+            throw LPError(.metadataFetchTimedOut)
+        } catch {
+            throw LPError(.metadataFetchFailed)
+        }
+        if let http = response as? FoundationBridge.HTTPURLResponse, !(200..<300).contains(http.statusCode) { throw LPError(.metadataFetchFailed) }
+        return Self.metadata(html: String(decoding: data.prefix(512 * 1024), as: UTF8.self), originalURL: url, url: response.url ?? url)
+    }
+
+    /// The metadata in a page's HTML: `og:title` or `<title>`, `og:image`,
+    /// the icon `<link>`, `og:video`; relative URLs resolved against `url`.
+    static func metadata(html: String, originalURL: URL, url: URL) -> LPLinkMetadata {
+        let metadata = LPLinkMetadata()
+        metadata.originalURL = originalURL
+        metadata.url = url
+        let head = html.range(of: "</head>", options: .caseInsensitive).map { String(html[..<$0.lowerBound]) } ?? html
+        let tags = Self.tags(in: head)
+        func meta(_ names: String...) -> String? {
+            for name in names {
+                if let tag = tags.first(where: { $0.name == "meta" && ($0.attributes["property"] ?? $0.attributes["name"])?.lowercased() == name }),
+                   let content = tag.attributes["content"], !content.isEmpty {
+                    return content
+                }
+            }
+            return nil
+        }
+        metadata.title = meta("og:title", "twitter:title") ?? Self.title(in: head)
+        if let image = meta("og:image", "og:image:url", "twitter:image"), let imageURL = URL(string: image, relativeTo: url)?.absoluteURL {
+            metadata.imageProvider = Self.provider(for: imageURL)
+        }
+        if let icon = tags.first(where: { $0.name == "link" && ($0.attributes["rel"] ?? "").lowercased().split(separator: " ").contains("icon") }),
+           let href = icon.attributes["href"], let iconURL = URL(string: href, relativeTo: url)?.absoluteURL {
+            metadata.iconProvider = Self.provider(for: iconURL)
+        }
+        if let video = meta("og:video", "og:video:url"), let videoURL = URL(string: video, relativeTo: url)?.absoluteURL {
+            metadata.remoteVideoURL = videoURL
+        }
+        return metadata
+    }
+
+    /// A provider that downloads the picture at `url` when loaded.
+    private static func provider(for url: URL) -> NSItemProvider {
+        let provider = NSItemProvider()
+        let type = UTType(filenameExtension: url.pathExtension, conformingTo: .image) ?? .image
+        provider.registerDataRepresentation(for: type.conforms(to: .image) ? type : .image) { completion in
+            Task { @MainActor in
+                do { completion(try await FoundationBridge.URLSession.shared.data(from: url).0, nil) } catch { completion(nil, error) }
+            }
+            return nil
+        }
+        return provider
+    }
+
+    private static func title(in html: String) -> String? {
+        guard let open = html.range(of: "<title", options: .caseInsensitive),
+              let close = html.range(of: ">", range: open.upperBound..<html.endIndex),
+              let end = html.range(of: "</title>", options: .caseInsensitive, range: close.upperBound..<html.endIndex)
+        else { return nil }
+        let text = decodeEntities(String(html[close.upperBound..<end.lowerBound])).trimmingCharacters(in: .whitespacesAndNewlines)
+        return text.isEmpty ? nil : text
+    }
+
+    struct Tag {
+        let name: String
+        let attributes: [String: String]
+    }
+
+    /// The `<meta>` and `<link>` tags, with their attributes (names lower-cased, values decoded).
+    static func tags(in html: String) -> [Tag] {
+        var tags: [Tag] = []
+        var rest = html[...]
+        while let open = rest.range(of: "<") {
+            rest = rest[open.upperBound...]
+            guard let close = rest.range(of: ">") else { break }
+            let body = rest[..<close.lowerBound]
+            rest = rest[close.upperBound...]
+            let name = body.prefix { $0.isLetter }.lowercased()
+            guard name == "meta" || name == "link" else { continue }
+            tags.append(Tag(name: name, attributes: attributes(String(body.dropFirst(name.count)))))
+        }
+        return tags
+    }
+
+    private static func attributes(_ text: String) -> [String: String] {
+        var result: [String: String] = [:]
+        var scanner = text[...]
+        while true {
+            scanner = scanner.drop { $0.isWhitespace || $0 == "/" }
+            let key = scanner.prefix { !$0.isWhitespace && $0 != "=" && $0 != "/" }
+            guard !key.isEmpty else { break }
+            scanner = scanner.dropFirst(key.count).drop { $0.isWhitespace }
+            var value = ""
+            if scanner.first == "=" {
+                scanner = scanner.dropFirst().drop { $0.isWhitespace }
+                if let quote = scanner.first, quote == "\"" || quote == "'" {
+                    let inner = scanner.dropFirst().prefix { $0 != quote }
+                    value = String(inner)
+                    scanner = scanner.dropFirst(inner.count + 2)
+                } else {
+                    let bare = scanner.prefix { !$0.isWhitespace }
+                    value = String(bare)
+                    scanner = scanner.dropFirst(bare.count)
+                }
+            }
+            result[key.lowercased()] = decodeEntities(value)
+        }
+        return result
+    }
+
+    private static func decodeEntities(_ text: String) -> String {
+        guard text.contains("&") else { return text }
+        var result = text
+        for (entity, character) in [("&amp;", "&"), ("&lt;", "<"), ("&gt;", ">"), ("&quot;", "\""), ("&#39;", "'"), ("&apos;", "'"), ("&#x27;", "'")] {
+            result = result.replacingOccurrences(of: entity, with: character)
+        }
+        return result
+    }
+}
+
+/// A rich link preview. Kept with its metadata; it draws nothing (no
+/// representable translates it).
+@MainActor
+open class LPLinkView: UIView {
+    open var metadata: LPLinkMetadata
+
+    public init(metadata: LPLinkMetadata) {
+        self.metadata = metadata
+        super.init(frame: .zero)
+    }
+
+    public convenience init(url: URL) {
+        let metadata = LPLinkMetadata()
+        metadata.originalURL = url
+        metadata.url = url
+        self.init(metadata: metadata)
+    }
+
+    public required init?(coder: NSCoder) {
+        metadata = LPLinkMetadata()
+        super.init(coder: coder)
+    }
+}