@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/CoreTransferable/CoreTransferable.swift

@@ -0,0 +1,606 @@
+// `import CoreTransferable` for the browser: `Transferable`, the protocol a
+// type adopts to say how it turns into bytes or a file of some content type
+// and back, and the representations it says it with (`DataRepresentation`,
+// `FileRepresentation`, `ProxyRepresentation`, `CodableRepresentation`).
+// On iOS SwiftUI re-exports this module, and so does the shim's SwiftUI
+// (this module sits under it), so `struct Photo: Transferable` compiles with
+// `import SwiftUI` alone.
+//
+// The representations are real: they run. A value exports through the first
+// representation that can (`ShareLink` sends the bytes or the file to the
+// page, which shares them with the Web Share API or downloads them), and a
+// type imports through the first one that accepts the content type offered
+// (`PhotosPickerItem.loadTransferable`, `NSItemProvider.loadTransferable`).
+// A received file is a copy in the temporary directory that is removed once
+// the importing closure returns, as on iOS. What the browser has no use for
+// is kept and ignored: visibility (there is no other app or process to hide
+// from) and `shouldAttemptToOpenInPlace` beyond reporting `isOriginalFile`.
+// docs/ops-protocol.md, "Sharing and media".
+
+@_exported import UniformTypeIdentifiers
+import Foundation
+
+// MARK: - Transferable
+
+/// A type that can be shared, dragged, pasted or picked: it lists the
+/// representations it exports and imports, in order of preference.
+public protocol Transferable {
+    associatedtype Representation: TransferRepresentation
+    @TransferRepresentationBuilder<Self> static var transferRepresentation: Representation { get }
+}
+
+/// One way of turning an `Item` into content of some type, or back.
+/// Compose them with the builder; your own representation is a `body` of others.
+public protocol TransferRepresentation<Item> {
+    associatedtype Item: Transferable
+    associatedtype Body: TransferRepresentation
+    @TransferRepresentationBuilder<Item> var body: Body { get }
+}
+
+extension Never: Transferable {
+    public static var transferRepresentation: Never { return fatalError("Never has no representation") }
+}
+
+extension Never: TransferRepresentation {
+    public typealias Item = Never
+    public var body: Never { return fatalError("Never has no representation") }
+}
+
+/// Who may see a representation. Kept: in the browser the app is alone, so
+/// every representation is visible to it.
+public struct TransferRepresentationVisibility: Hashable, Sendable {
+    let name: String
+    public static let all = TransferRepresentationVisibility(name: "all")
+    public static let team = TransferRepresentationVisibility(name: "team")
+    public static let group = TransferRepresentationVisibility(name: "group")
+    public static let ownProcess = TransferRepresentationVisibility(name: "ownProcess")
+}
+
+// MARK: - Files
+
+/// A file a value exports (`FileRepresentation`'s exporting closure returns one).
+public struct SentTransferredFile: Sendable {
+    public let file: URL
+    public let allowAccessingOriginalFile: Bool
+
+    public init(_ file: URL, allowAccessingOriginalFile: Bool = false) {
+        self.file = file
+        self.allowAccessingOriginalFile = allowAccessingOriginalFile
+    }
+}
+
+/// A file handed to `FileRepresentation`'s importing closure: a copy in the
+/// temporary directory (removed once the closure returns; copy it to keep
+/// it), or the original when the representation asked to open in place and
+/// the content was a file.
+public struct ReceivedTransferredFile: Sendable {
+    public let file: URL
+    public let isOriginalFile: Bool
+
+    public init(_file file: URL, isOriginalFile: Bool) {
+        self.file = file
+        self.isOriginalFile = isOriginalFile
+    }
+}
+
+// MARK: - The representations
+
+/// The value as bytes of one content type.
+public struct DataRepresentation<Item: Transferable>: TransferRepresentation, _TransferPrimitive {
+    public typealias Body = Never
+    public var body: Never { return fatalError("a primitive representation has no body") }
+    let node: _TransferNode
+
+    public init(contentType: UTType,
+                exporting: @escaping (Item) async throws -> Data,
+                importing: @escaping (Data) async throws -> Item) {
+        node = _TransferNode(exportType: contentType, importType: contentType,
+                             exporter: Self.exporter(contentType, exporting), importer: Self.importer(importing))
+    }
+
+    public init(exportedContentType: UTType, exporting: @escaping (Item) async throws -> Data) {
+        node = _TransferNode(exportType: exportedContentType, importType: nil,
+                             exporter: Self.exporter(exportedContentType, exporting), importer: nil)
+    }
+
+    public init(importedContentType: UTType, importing: @escaping (Data) async throws -> Item) {
+        node = _TransferNode(exportType: nil, importType: importedContentType, exporter: nil, importer: Self.importer(importing))
+    }
+
+    private static func exporter(_ type: UTType, _ exporting: @escaping (Item) async throws -> Data) -> _TransferNode.Exporter {
+        { item, _ in
+            nonisolated(unsafe) let value = item as! Item
+            return _TransferContent(contentType: type, data: try await exporting(value))
+        }
+    }
+
+    private static func importer(_ importing: @escaping (Data) async throws -> Item) -> _TransferNode.Importer {
+        { content in try await importing(try content.loadData()) }
+    }
+
+    public var _transferNodes: [_TransferNode] { [node] }
+}
+
+/// The value as a file of one content type.
+public struct FileRepresentation<Item: Transferable>: TransferRepresentation, _TransferPrimitive {
+    public typealias Body = Never
+    public var body: Never { return fatalError("a primitive representation has no body") }
+    let node: _TransferNode
+
+    public init(contentType: UTType, shouldAttemptToOpenInPlace: Bool = false,
+                exporting: @escaping (Item) async throws -> SentTransferredFile,
+                importing: @escaping (ReceivedTransferredFile) async throws -> Item) {
+        node = _TransferNode(exportType: contentType, importType: contentType,
+                             exporter: Self.exporter(contentType, exporting),
+                             importer: Self.importer(inPlace: shouldAttemptToOpenInPlace, importing))
+    }
+
+    public init(exportedContentType: UTType, shouldAllowToOpenInPlace: Bool = false,
+                exporting: @escaping (Item) async throws -> SentTransferredFile) {
+        node = _TransferNode(exportType: exportedContentType, importType: nil,
+                             exporter: Self.exporter(exportedContentType, exporting), importer: nil)
+    }
+
+    public init(importedContentType: UTType, shouldAttemptToOpenInPlace: Bool = false,
+                importing: @escaping (ReceivedTransferredFile) async throws -> Item) {
+        node = _TransferNode(exportType: nil, importType: importedContentType, exporter: nil,
+                             importer: Self.importer(inPlace: shouldAttemptToOpenInPlace, importing))
+    }
+
+    private static func exporter(_ type: UTType, _ exporting: @escaping (Item) async throws -> SentTransferredFile) -> _TransferNode.Exporter {
+        { item, _ in
+            nonisolated(unsafe) let value = item as! Item
+            let sent = try await exporting(value)
+            return _TransferContent(contentType: type, file: sent.file, isOriginalFile: sent.allowAccessingOriginalFile,
+                                    suggestedName: sent.file.deletingPathExtension().lastPathComponent)
+        }
+    }
+
+    private static func importer(inPlace: Bool, _ importing: @escaping (ReceivedTransferredFile) async throws -> Item) -> _TransferNode.Importer {
+        { content in
+            let received = try content.receivedFile(inPlace: inPlace)
+            defer { if !received.isOriginalFile { try? FileManager.default.removeItem(at: received.file) } }
+            return try await importing(received)
+        }
+    }
+
+    public var _transferNodes: [_TransferNode] { [node] }
+}
+
+/// The value as another `Transferable` value (a `URL`, a `String`…), which
+/// carries the content types.
+public struct ProxyRepresentation<Item: Transferable, ProxyRepresentation: Transferable>: TransferRepresentation, _TransferPrimitive {
+    public typealias Body = Never
+    public var body: Never { return fatalError("a primitive representation has no body") }
+    let node: _TransferNode
+
+    public init(exporting: @escaping (Item) async throws -> ProxyRepresentation,
+                importing: @escaping (ProxyRepresentation) async throws -> Item) {
+        node = Self.node(exporting: exporting, importing: importing)
+    }
+
+    public init(exporting: @escaping (Item) async throws -> ProxyRepresentation) {
+        node = Self.node(exporting: exporting, importing: nil)
+    }
+
+    public init(importing: @escaping (ProxyRepresentation) async throws -> Item) {
+        node = Self.node(exporting: nil, importing: importing)
+    }
+
+    private static func node(exporting: ((Item) async throws -> ProxyRepresentation)?,
+                             importing: ((ProxyRepresentation) async throws -> Item)?) -> _TransferNode {
+        var exporter: _TransferNode.Exporter?
+        if let exporting {
+            exporter = { item, wanted in
+                nonisolated(unsafe) let value = item as! Item
+                return try await _Transfer.export(try await exporting(value), as: wanted)
+            }
+        }
+        var importer: _TransferNode.Importer?
+        if let importing {
+            importer = { content in
+                guard let proxy = try await _Transfer.import(ProxyRepresentation.self, from: content) else { return nil }
+                nonisolated(unsafe) let value = proxy
+                return try await importing(value)
+            }
+        }
+        var node = _TransferNode(exportType: nil, importType: nil, exporter: exporter, importer: importer)
+        node.proxyExportTypes = exporting == nil ? nil : { _Transfer.exportedContentTypes(ProxyRepresentation.self) }
+        node.proxyImportTypes = importing == nil ? nil : { _Transfer.importedContentTypes(ProxyRepresentation.self) }
+        return node
+    }
+
+    public var _transferNodes: [_TransferNode] { [node] }
+}
+
+/// What `CodableRepresentation` encodes with: `JSONEncoder` and
+/// `PropertyListEncoder` (Combine's `TopLevelEncoder`, which the browser's
+/// Foundation does not have, for this purpose).
+public protocol _TransferTopLevelEncoder {
+    func encode<T: Encodable>(_ value: T) throws -> Data
+}
+
+/// What `CodableRepresentation` decodes with.
+public protocol _TransferTopLevelDecoder {
+    func decode<T: Decodable>(_ type: T.Type, from data: Data) throws -> T
+}
+
+extension JSONEncoder: _TransferTopLevelEncoder {}
+extension JSONDecoder: _TransferTopLevelDecoder {}
+extension PropertyListEncoder: _TransferTopLevelEncoder {}
+extension PropertyListDecoder: _TransferTopLevelDecoder {}
+
+/// The value encoded with `Codable`, as JSON unless you pass a coder.
+public struct CodableRepresentation<Item: Transferable & Codable, Encoder: _TransferTopLevelEncoder, Decoder: _TransferTopLevelDecoder>:
+    TransferRepresentation, _TransferPrimitive {
+    public typealias Body = Never
+    public var body: Never { return fatalError("a primitive representation has no body") }
+    let node: _TransferNode
+
+    public init(for itemType: Item.Type = Item.self, contentType: UTType, encoder: Encoder, decoder: Decoder) {
+        let encode = Self.encoding(encoder)
+        let decode = Self.decoding(decoder)
+        node = _TransferNode(
+            exportType: contentType, importType: contentType,
+            exporter: { item, _ in _TransferContent(contentType: contentType, data: try encode(item as! Item)) },
+            importer: { content in try decode(try content.loadData()) })
+    }
+
+    private static func encoding(_ encoder: Encoder) -> (Item) throws -> Data {
+        let box = _UncheckedBox(encoder)
+        return { item in try box.value.encode(item) }
+    }
+
+    private static func decoding(_ decoder: Decoder) -> (Data) throws -> Item {
+        let box = _UncheckedBox(decoder)
+        return { data in try box.value.decode(Item.self, from: data) }
+    }
+
+    public var _transferNodes: [_TransferNode] { [node] }
+}
+
+extension CodableRepresentation where Encoder == JSONEncoder, Decoder == JSONDecoder {
+    public init(for itemType: Item.Type = Item.self, contentType: UTType) {
+        self.init(for: itemType, contentType: contentType, encoder: JSONEncoder(), decoder: JSONDecoder())
+    }
+}
+
+// MARK: - Modifiers
+
+extension TransferRepresentation {
+    /// The file name the exported content is offered under (the page uses
+    /// it for the shared or downloaded file).
+    public func suggestedFileName(_ fileName: String) -> _TransferRepresentationList<Item> {
+        modified { $0.suggestedFileName = { _ in fileName } }
+    }
+
+    public func suggestedFileName(_ fileName: @escaping (Item) -> String?) -> _TransferRepresentationList<Item> {
+        modified { $0.suggestedFileName = { fileName($0 as! Item) } }
+    }
+
+    /// Exports only the values for which `condition` holds.
+    public func exportingCondition(_ condition: @escaping (Item) -> Bool) -> _TransferRepresentationList<Item> {
+        modified { $0.exportingCondition = { condition($0 as! Item) } }
+    }
+
+    /// Kept, with nothing to apply it to: the app is alone in the browser.
+    public func visibility(_ visibility: TransferRepresentationVisibility) -> _TransferRepresentationList<Item> {
+        modified { $0.visibility = visibility }
+    }
+
+    private func modified(_ change: (inout _TransferNode) -> Void) -> _TransferRepresentationList<Item> {
+        var nodes = _Transfer.nodes(of: self)
+        for index in nodes.indices { change(&nodes[index]) }
+        return _TransferRepresentationList(nodes: nodes)
+    }
+}
+
+// MARK: - Builder
+
+/// Several representations, in order of preference: what the builder makes.
+public struct _TransferRepresentationList<Item: Transferable>: TransferRepresentation, _TransferPrimitive {
+    public typealias Body = Never
+    public var body: Never { return fatalError("a primitive representation has no body") }
+    public let _transferNodes: [_TransferNode]
+
+    public init(nodes: [_TransferNode]) { _transferNodes = nodes }
+}
+
+@resultBuilder
+public enum TransferRepresentationBuilder<Item: Transferable> {
+    public static func buildExpression<R: TransferRepresentation>(_ representation: R) -> _TransferRepresentationList<Item> where R.Item == Item {
+        _TransferRepresentationList(nodes: _Transfer.nodes(of: representation))
+    }
+
+    public static func buildBlock() -> _TransferRepresentationList<Item> {
+        _TransferRepresentationList(nodes: [])
+    }
+
+    public static func buildBlock(_ components: _TransferRepresentationList<Item>...) -> _TransferRepresentationList<Item> {
+        _TransferRepresentationList(nodes: components.flatMap(\._transferNodes))
+    }
+
+    public static func buildOptional(_ component: _TransferRepresentationList<Item>?) -> _TransferRepresentationList<Item> {
+        component ?? _TransferRepresentationList(nodes: [])
+    }
+
+    public static func buildEither(first component: _TransferRepresentationList<Item>) -> _TransferRepresentationList<Item> { component }
+    public static func buildEither(second component: _TransferRepresentationList<Item>) -> _TransferRepresentationList<Item> { component }
+    public static func buildLimitedAvailability(_ component: _TransferRepresentationList<Item>) -> _TransferRepresentationList<Item> { component }
+    public static func buildArray(_ components: [_TransferRepresentationList<Item>]) -> _TransferRepresentationList<Item> {
+        _TransferRepresentationList(nodes: components.flatMap(\._transferNodes))
+    }
+}
+
+// MARK: - Exporting and importing
+
+extension Transferable {
+    /// The content types the type exports, in order of preference.
+    public static func exportedContentTypes(_ visibility: TransferRepresentationVisibility = .all) -> [UTType] {
+        _Transfer.exportedContentTypes(Self.self)
+    }
+
+    /// The content types the type imports, in order of preference.
+    public static func importedContentTypes(_ visibility: TransferRepresentationVisibility = .all) -> [UTType] {
+        _Transfer.importedContentTypes(Self.self)
+    }
+
+    /// The value's bytes as `contentType` (or a type conforming to it), from
+    /// the first representation that exports it.
+    nonisolated(nonsending) public func exported(as contentType: UTType) async throws -> Data {
+        guard let content = try await _Transfer.export(self, as: contentType) else {
+            throw _TransferError.noRepresentation(contentType)
+        }
+        return try content.loadData()
+    }
+
+    /// A value made from `data` by the first representation that imports
+    /// `contentType` (with no type: the first that imports anything).
+    nonisolated(nonsending) public init(importing data: Data, contentType: UTType?) async throws {
+        let types = contentType.map { [$0] } ?? Self.importedContentTypes()
+        for type in types {
+            if let value = try await _Transfer.import(Self.self, from: _TransferContent(contentType: type, data: data)) {
+                self = value
+                return
+            }
+        }
+        throw _TransferError.noRepresentation(contentType ?? .data)
+    }
+}
+
+/// Why a transfer failed.
+public enum _TransferError: Error, CustomStringConvertible {
+    case noRepresentation(UTType)
+    case noContent
+
+    public var description: String {
+        switch self {
+        case .noRepresentation(let type): "no representation for \(type.identifier)"
+        case .noContent: "the content has no data"
+        }
+    }
+}
+
+/// Content on its way out of a value or into one: bytes or a file, of a type.
+public struct _TransferContent: @unchecked Sendable {
+    public var contentType: UTType
+    public var data: Data?
+    public var file: URL?
+    /// Whether `file` is the exporter's own (not a copy made for the transfer).
+    public var isOriginalFile: Bool
+    /// The file name (without extension) to offer the content under.
+    public var suggestedName: String?
+    /// A `Transferable` value exported through a `ProxyRepresentation` to a
+    /// `String` or `URL` (the page shares those as text and links).
+    public var value: Any?
+
+    public init(contentType: UTType, data: Data? = nil, file: URL? = nil, isOriginalFile: Bool = false,
+                suggestedName: String? = nil, value: Any? = nil) {
+        self.contentType = contentType
+        self.data = data
+        self.file = file
+        self.isOriginalFile = isOriginalFile
+        self.suggestedName = suggestedName
+        self.value = value
+    }
+
+    /// The bytes: `data`, or the file's contents.
+    public func loadData() throws -> Data {
+        if let data { return data }
+        if let file { return try Data(contentsOf: file) }
+        throw _TransferError.noContent
+    }
+
+    /// A file name with the content type's extension.
+    public var fileName: String {
+        let base = suggestedName.flatMap { $0.isEmpty ? nil : $0 } ?? file?.deletingPathExtension().lastPathComponent ?? "Shared"
+        if let file, !file.pathExtension.isEmpty { return "\(base).\(file.pathExtension)" }
+        guard let ext = contentType.preferredFilenameExtension else { return base }
+        return "\(base).\(ext)"
+    }
+
+    /// The file an importing `FileRepresentation` receives: the original in
+    /// place when asked for and there is one, else a copy (or the bytes
+    /// written) in the temporary directory.
+    func receivedFile(inPlace: Bool) throws -> ReceivedTransferredFile {
+        if let file, inPlace { return ReceivedTransferredFile(_file: file, isOriginalFile: true) }
+        let folder = FileManager.default.temporaryDirectory.appendingPathComponent("Transfers-\(UUID().uuidString)", isDirectory: true)
+        try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
+        let copy = folder.appendingPathComponent(fileName)
+        if let file { try FileManager.default.copyItem(at: file, to: copy) } else { try loadData().write(to: copy) }
+        return ReceivedTransferredFile(_file: copy, isOriginalFile: false)
+    }
+}
+
+/// One representation, with the item type erased: what the shim's
+/// `ShareLink`, `NSItemProvider` and `PhotosPickerItem` walk.
+public struct _TransferNode: @unchecked Sendable {
+    // Not `@Sendable`: the browser runs one thread, and the nodes are
+    // `@unchecked Sendable`. The app's closures are not `@Sendable` either,
+    // so a closure written in a main-actor type (a package with main-actor
+    // default isolation, as Ice Cubes' are) stays on the main actor and may
+    // call that type's initializers; being async, it hops there when called.
+    public typealias Exporter = nonisolated(nonsending) (Any, UTType?) async throws -> _TransferContent?
+    public typealias Importer = nonisolated(nonsending) (_TransferContent) async throws -> Any?
+
+    let exportType: UTType?
+    let importType: UTType?
+    let exporter: Exporter?
+    let importer: Importer?
+    var proxyExportTypes: (() -> [UTType])?
+    var proxyImportTypes: (() -> [UTType])?
+    var suggestedFileName: ((Any) -> String?)?
+    var exportingCondition: ((Any) -> Bool)?
+    var visibility = TransferRepresentationVisibility.all
+
+    /// A representation of the shim's own (SwiftUI's `Image`, whose bytes
+    /// know their type): `exporter` returns nil when it has nothing to give.
+    public init(exportType: UTType?, importType: UTType?, exporter: Exporter?, importer: Importer?) {
+        self.exportType = exportType
+        self.importType = importType
+        self.exporter = exporter
+        self.importer = importer
+    }
+
+    var exportedContentTypes: [UTType] {
+        guard exporter != nil else { return [] }
+        return proxyExportTypes?() ?? exportType.map { [$0] } ?? []
+    }
+
+    var importedContentTypes: [UTType] {
+        guard importer != nil else { return [] }
+        return proxyImportTypes?() ?? importType.map { [$0] } ?? []
+    }
+
+    /// Whether this representation exports something `wanted` takes (anything, for nil).
+    func exports(_ wanted: UTType?) -> Bool {
+        guard exporter != nil else { return false }
+        guard let wanted else { return true }
+        return exportedContentTypes.contains { $0.conforms(to: wanted) }
+    }
+
+    /// Whether this representation imports content of `type`.
+    func imports(_ type: UTType) -> Bool {
+        importedContentTypes.contains { type.conforms(to: $0) }
+    }
+}
+
+/// A representation the shim builds from nodes directly.
+public protocol _TransferPrimitive {
+    var _transferNodes: [_TransferNode] { get }
+}
+
+struct _UncheckedBox<Value>: @unchecked Sendable {
+    let value: Value
+    init(_ value: Value) { self.value = value }
+}
+
+/// Walks representations: what sharing, item providers and pickers use.
+public enum _Transfer {
+    /// A representation's nodes: its own, or its body's.
+    public static func nodes<R: TransferRepresentation>(of representation: R) -> [_TransferNode] {
+        if let primitive = representation as? any _TransferPrimitive { return primitive._transferNodes }
+        return nodes(of: representation.body)
+    }
+
+    public static func nodes<T: Transferable>(_ type: T.Type) -> [_TransferNode] {
+        nodes(of: T.transferRepresentation)
+    }
+
+    public static func exportedContentTypes<T: Transferable>(_ type: T.Type) -> [UTType] {
+        unique(nodes(type).flatMap(\.exportedContentTypes))
+    }
+
+    public static func importedContentTypes<T: Transferable>(_ type: T.Type) -> [UTType] {
+        unique(nodes(type).flatMap(\.importedContentTypes))
+    }
+
+    /// Whether `type` imports content of `contentType`.
+    public static func canImport<T: Transferable>(_ type: T.Type, contentType: UTType) -> Bool {
+        nodes(type).contains { $0.imports(contentType) }
+    }
+
+    /// The item's content from the first representation that exports
+    /// `wanted` (anything, for nil) and whose condition holds; nil if none does.
+    nonisolated(nonsending) public static func export<T: Transferable>(_ item: T, as wanted: UTType? = nil) async throws -> _TransferContent? {
+        // `String` and `URL` are leaves the page shares as text and links.
+        for node in nodes(T.self) where node.exports(wanted) {
+            if let condition = node.exportingCondition, !condition(item) { continue }
+            guard var content = try await node.exporter?(item, wanted) else { continue }
+            if let name = node.suggestedFileName?(item) {
+                content.suggestedName = (name as NSString).deletingPathExtension
+            }
+            if content.value == nil, wanted == nil, T.self == String.self || T.self == URL.self { content.value = item }
+            return content
+        }
+        return nil
+    }
+
+    /// A value of `type` from `content`, through the first representation
+    /// that imports its content type; nil if none does.
+    nonisolated(nonsending) public static func `import`<T: Transferable>(_ type: T.Type, from content: _TransferContent) async throws -> T? {
+        for node in nodes(type) where node.imports(content.contentType) {
+            if let value = try await node.importer?(content) as? T { return value }
+        }
+        return nil
+    }
+
+    private static func unique(_ types: [UTType]) -> [UTType] {
+        var seen = Set<UTType>()
+        return types.filter { seen.insert($0).inserted }
+    }
+}
+
+// MARK: - Foundation's types
+
+extension String: Transferable {
+    public static var transferRepresentation: _TransferRepresentationList<String> {
+        return _TransferRepresentationList(nodes: [
+            _TransferNode(exportType: .utf8PlainText, importType: .text,
+                          exporter: { item, _ in _TransferContent(contentType: .utf8PlainText, data: Data((item as! String).utf8)) },
+                          importer: { content in String(decoding: try content.loadData(), as: UTF8.self) }),
+        ])
+    }
+}
+
+extension Data: Transferable {
+    public static var transferRepresentation: _TransferRepresentationList<Data> {
+        return _TransferRepresentationList(nodes: [
+            _TransferNode(exportType: .data, importType: .data,
+                          exporter: { item, _ in _TransferContent(contentType: .data, data: item as? Data) },
+                          importer: { content in try content.loadData() }),
+        ])
+    }
+}
+
+extension URL: Transferable {
+    /// A link as `public.url` (its string), or a file as `public.file-url`.
+    public static var transferRepresentation: _TransferRepresentationList<URL> {
+        return _TransferRepresentationList(nodes: [
+            _TransferNode(exportType: .url, importType: .url,
+                          exporter: { item, _ in
+                              let url = item as! URL
+                              return _TransferContent(contentType: url.isFileURL ? .fileURL : .url, data: Data(url.absoluteString.utf8))
+                          },
+                          importer: { content in
+                              if content.contentType.conforms(to: .url), let data = content.data {
+                                  return URL(string: String(decoding: data, as: UTF8.self).trimmingCharacters(in: .whitespacesAndNewlines))
+                              }
+                              return content.file
+                          }),
+        ])
+    }
+}
+
+extension AttributedString: Transferable {
+    /// As its plain text: the browser's share sheet and clipboard take text.
+    public static var transferRepresentation: _TransferRepresentationList<AttributedString> {
+        return _TransferRepresentationList(nodes: [
+            _TransferNode(exportType: .utf8PlainText, importType: .text,
+                          exporter: { item, _ in
+                              _TransferContent(contentType: .utf8PlainText, data: Data(String((item as! AttributedString).characters).utf8))
+                          },
+                          importer: { content in AttributedString(String(decoding: try content.loadData(), as: UTF8.self)) }),
+        ])
+    }
+}