@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/UIKit/ViewTranslation.swift

@@ -0,0 +1,311 @@
+// A representable's UIKit view tree as SwiftUI views, made again on every
+// pass of `_UIKitTranslationHost` (Representable.swift): the reconciler diffs
+// the result like any body, so an unchanged view sends no ops. Each view
+// becomes its content, its subviews placed by their frames, and its layer's
+// decorations:
+//
+// - content by class: `UIImageView` → `Image(uiImage:)` (a bitmap recipe,
+//   symbol or catalog image) scaled by `contentMode`; `UILabel` → `Text`
+//   (attributed runs, font, color, line limit, alignment); `UITextView` →
+//   `TextEditor` while editable (its focus bound to the first responder),
+//   else `Text` (in a `ScrollView` when it
+//   scrolls); `UIActivityIndicatorView` → `ProgressView` while it spins;
+//   `UIButton` → `Button` (image and title over the background image);
+//   `UIHostingController`'s view → its root view, inline; a view whose
+//   layer, or a sublayer of it, draws itself (AVFoundation's `AVPlayerLayer`:
+//   the player's `video` element) → that drawing, filling the view;
+// - subviews: a `ZStack` (top leading) of each subview at its frame's size,
+//   offset to its origin in the bounds; a `UIScrollView` whose content is
+//   larger than its bounds wraps them in a `ScrollView` of the content's
+//   size, and one zoomed draws its `viewForZooming` scaled;
+// - decorations: `backgroundColor` (the layer's when the view has none),
+//   `cornerRadius`, `clipsToBounds` / `masksToBounds`, the layer's border,
+//   `alpha` × the layer's opacity, `isUserInteractionEnabled`; a hidden
+//   view draws nothing.
+//
+// The root view fills what the representable is given, except a view that
+// sizes itself (a label, an image view with an image, a spinner, a text view
+// that neither edits nor scrolls, a hosting view) without subviews, which is
+// drawn at its natural size. Every other view is drawn at its frame. UIKit's
+// label colors follow the page's color scheme (`UIColor.label`, which is
+// black here, as `.primary`; the secondary and tertiary label colors as
+// `.secondary`); every other color is drawn as its components. Not drawn:
+// shadows, layer contents and other sublayers, transforms, `draw(_:)`, and the
+// controls (`UISwitch`, `UISlider`, … draw as plain views).
+
+import Foundation
+import SwiftUI
+
+@MainActor
+enum _UIViewTranslator {
+    /// One layer of a container: the view's own content or a subview, with
+    /// an identity that follows the UIKit view.
+    struct Layer: Identifiable {
+        let id: AnyHashable
+        let view: AnyView
+    }
+
+    /// What a view draws inside its bounds, and how.
+    struct Content {
+        var view: AnyView
+        /// Where the content sits in a larger box.
+        var alignment: Alignment = .topLeading
+        /// Whether a root view with this content (and no subviews) sizes itself.
+        var natural = false
+    }
+
+    /// The drawing of `view` and its subviews: at its frame's size, or as the
+    /// representable's root (see the top of the file).
+    static func view(for view: UIView, isRoot: Bool) -> AnyView {
+        guard !view.isHidden, !view.layer.isHidden else { return AnyView(EmptyView()) }
+        // iOS displays a view's layer before it first draws it (`display(_:)`).
+        if !view.layer._hasDisplayed { view.layer.display() }
+        let content = self.content(of: view)
+        let hasSubviews = view.subviews.contains { !$0.isHidden && !$0.layer.isHidden }
+        var body: AnyView
+        if isRoot, !hasSubviews, let content, content.natural {
+            body = content.view
+        } else {
+            var layers: [Layer] = []
+            if let content {
+                layers.append(Layer(id: "content", view: AnyView(content.view
+                    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: content.alignment))))
+            }
+            if hasSubviews, let scroll = view as? UIScrollView, !(view is UITextView), let scrolling = self.scrolling(scroll) {
+                layers.append(Layer(id: "scroll", view: scrolling))
+            } else if hasSubviews {
+                layers += self.layers(of: view)
+            }
+            switch layers.count {
+            case 0 where !isDecorated(view): return AnyView(EmptyView())
+            case 0: body = AnyView(Color.clear)
+            case 1 where layers[0].id == AnyHashable("content"): body = layers[0].view
+            default:
+                body = AnyView(ZStack(alignment: .topLeading) {
+                    ForEach(layers) { $0.view }
+                })
+            }
+            body = isRoot
+                ? AnyView(body.frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading))
+                : AnyView(body.frame(width: max(0, view.bounds.width), height: max(0, view.bounds.height), alignment: .topLeading))
+        }
+        return decorate(body, view)
+    }
+
+    // MARK: Content
+
+    static func content(of view: UIView) -> Content? {
+        switch view {
+        case let hosting as _UIHostingView:
+            return Content(view: hosting.rootView, alignment: .center, natural: true)
+        case let label as UILabel:
+            return labelContent(label)
+        case let imageView as UIImageView:
+            return imageContent(imageView)
+        case let textView as UITextView:
+            return textViewContent(textView)
+        case let button as UIButton:
+            return buttonContent(button)
+        case let spinner as UIActivityIndicatorView:
+            guard spinner.isAnimating || !spinner.hidesWhenStopped else { return nil }
+            let progress = AnyView(ProgressView().tint(spinner.color.map { Color(uiColor: $0) }))
+            return Content(view: progress, alignment: .center, natural: true)
+        default:
+            // A layer that draws itself (an `AVPlayerLayer`: the view's own
+            // layer or a sublayer of it) fills the view.
+            let drawing = view.layer._drawing ?? view.layer.sublayers?.lazy.compactMap(\._drawing).first
+            return drawing.map { Content(view: $0, alignment: .center) }
+        }
+    }
+
+    static func labelContent(_ label: UILabel) -> Content {
+        let text = label._hasAttributedText ? Text(_uiKit: label.attributedText ?? NSAttributedString(string: ""))
+            : Text(verbatim: label.text ?? "")
+        let alignment = textAlignment(label.textAlignment)
+        let drawn = text
+            .font(Font(label.font ?? .systemFont(ofSize: 17)))
+            .foregroundColor(textColor(label.isEnabled ? label.textColor : .tertiaryLabel))
+            .lineLimit(label.numberOfLines == 0 ? nil : label.numberOfLines)
+            .multilineTextAlignment(alignment.text)
+        return Content(view: AnyView(drawn), alignment: alignment.frame, natural: true)
+    }
+
+    static func imageContent(_ imageView: UIImageView) -> Content? {
+        let shown = imageView.isHighlighted ? (imageView.highlightedImage ?? imageView.image) : imageView.image
+        guard let image = shown else { return nil }
+        let base = Image(uiImage: image)
+        let tint = imageView.tintColor.map { Color(uiColor: $0) }
+        let drawn: AnyView
+        var alignment = Alignment.center
+        switch imageView.contentMode {
+        case .scaleToFill, .redraw:
+            drawn = AnyView(base.resizable())
+        case .scaleAspectFit:
+            drawn = AnyView(base.resizable().aspectRatio(contentMode: .fit))
+        case .scaleAspectFill:
+            drawn = AnyView(base.resizable().aspectRatio(contentMode: .fill))
+        case .center: drawn = AnyView(base)
+        case .top: (drawn, alignment) = (AnyView(base), .top)
+        case .bottom: (drawn, alignment) = (AnyView(base), .bottom)
+        case .left: (drawn, alignment) = (AnyView(base), .leading)
+        case .right: (drawn, alignment) = (AnyView(base), .trailing)
+        case .topLeft: (drawn, alignment) = (AnyView(base), .topLeading)
+        case .topRight: (drawn, alignment) = (AnyView(base), .topTrailing)
+        case .bottomLeft: (drawn, alignment) = (AnyView(base), .bottomLeading)
+        case .bottomRight: (drawn, alignment) = (AnyView(base), .bottomTrailing)
+        }
+        return Content(view: AnyView(drawn.foregroundColor(tint)), alignment: alignment, natural: true)
+    }
+
+    /// A `UIButton`: its image and title over its background image; a tap sends its actions.
+    static func buttonContent(_ button: UIButton) -> Content {
+        let title = button.currentTitle
+        let image = button.currentImage
+        let background = button.currentBackgroundImage
+        let color = textColor(button.titleColor(for: .normal)) ?? Color(uiColor: button.tintColor ?? .systemBlue)
+        let label = HStack(spacing: 6) {
+            if let image { Image(uiImage: image) }
+            if let title { Text(verbatim: title) }
+        }
+        .foregroundColor(color)
+        .padding(.horizontal, title == nil ? 0 : 8)
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .background {
+            if let background { Image(uiImage: background).resizable() }
+        }
+        let drawn = Button { button._tap() } label: { label }
+            .buttonStyle(.plain)
+            .disabled(!button.isEnabled)
+        return Content(view: AnyView(drawn), alignment: .center, natural: true)
+    }
+
+    static func textViewContent(_ textView: UITextView) -> Content {
+        let insets = textView.textContainerInset
+        let padding = textView.textContainer.lineFragmentPadding
+        let edges = EdgeInsets(top: insets.top, leading: insets.left + padding, bottom: insets.bottom, trailing: insets.right + padding)
+        let font = Font(textView.font ?? .preferredFont(forTextStyle: .body))
+        let color = textColor(textView.textColor)
+        let alignment = textAlignment(textView.textAlignment)
+        if textView.isEditable {
+            let editor = TextEditor(text: Binding(get: { textView.text ?? "" }, set: { textView._userEdited($0) }))
+                .font(font)
+                .foregroundColor(color)
+                .multilineTextAlignment(alignment.text)
+                ._focused(Binding(get: { textView.isFirstResponder },
+                                  set: { $0 ? textView.becomeFirstResponder() : textView.resignFirstResponder() }))
+                .padding(edges)
+            return Content(view: AnyView(editor))
+        }
+        let text = Text(_uiKit: textView.attributedText ?? NSAttributedString(string: ""))
+            .font(font)
+            .foregroundColor(color)
+            .multilineTextAlignment(alignment.text)
+            .textSelection(.enabled)
+            .frame(maxWidth: .infinity, alignment: alignment.frame)
+            .padding(edges)
+        let top = Alignment(horizontal: alignment.frame.horizontal, vertical: .top)
+        if textView.isScrollEnabled {
+            return Content(view: AnyView(ScrollView(.vertical, showsIndicators: textView.showsVerticalScrollIndicator) { text }), alignment: top)
+        }
+        return Content(view: AnyView(text), alignment: top, natural: true)
+    }
+
+    // MARK: Subviews
+
+    /// The visible subviews, each at its frame's size and offset to its
+    /// origin in the view's bounds (a scroll view's: its content offset).
+    static func layers(of view: UIView, scrolling: Bool = false) -> [Layer] {
+        let scroll = view as? UIScrollView
+        let origin = scrolling ? .zero : (scroll?.contentOffset ?? view.bounds.origin)
+        let zoomed = scroll.flatMap { $0.zoomScale != 1 ? $0._scrollDelegate?.viewForZooming(in: $0) : nil }
+        return view.subviews.compactMap { subview in
+            guard !subview.isHidden, !subview.layer.isHidden else { return nil }
+            var drawn = self.view(for: subview, isRoot: false)
+            if subview === zoomed, let scale = scroll?.zoomScale {
+                drawn = AnyView(drawn.scaleEffect(scale, anchor: .topLeading))
+            }
+            let frame = subview.frame
+            return Layer(id: ObjectIdentifier(subview),
+                         view: AnyView(drawn.offset(x: frame.minX - origin.x, y: frame.minY - origin.y)))
+        }
+    }
+
+    /// A scroll view whose content is larger than its bounds (on an axis
+    /// it may scroll) as a `ScrollView` over the content; nil otherwise.
+    static func scrolling(_ scroll: UIScrollView) -> AnyView? {
+        guard scroll.isScrollEnabled else { return nil }
+        var extent = CGSize(width: scroll.contentSize.width * scroll.zoomScale, height: scroll.contentSize.height * scroll.zoomScale)
+        if extent == .zero {
+            for subview in scroll.subviews where !subview.isHidden {
+                extent.width = max(extent.width, subview.frame.maxX)
+                extent.height = max(extent.height, subview.frame.maxY)
+            }
+        }
+        var axes: Axis.Set = []
+        if extent.width > scroll.bounds.width + 0.5 { axes.insert(.horizontal) }
+        if extent.height > scroll.bounds.height + 0.5 { axes.insert(.vertical) }
+        guard !axes.isEmpty else { return nil }
+        let content = layers(of: scroll, scrolling: true)
+        let indicators = axes.contains(.vertical) ? scroll.showsVerticalScrollIndicator : scroll.showsHorizontalScrollIndicator
+        return AnyView(ScrollView(axes, showsIndicators: indicators) {
+            ZStack(alignment: .topLeading) {
+                ForEach(content) { $0.view }
+            }
+            .frame(width: max(extent.width, scroll.bounds.width), height: max(extent.height, scroll.bounds.height), alignment: .topLeading)
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity))
+    }
+
+    // MARK: Decorations
+
+    static func isDecorated(_ view: UIView) -> Bool {
+        background(of: view) != nil || (view.layer.borderWidth > 0 && view.layer.borderColor != nil)
+    }
+
+    static func background(of view: UIView) -> UIColor? {
+        let color = view.backgroundColor ?? view.layer.backgroundColor.map { UIColor(cgColor: $0) }
+        guard let color, color.alpha > 0 else { return nil }
+        return color
+    }
+
+    static func decorate(_ body: AnyView, _ view: UIView) -> AnyView {
+        var body = body
+        let radius = view.layer.cornerRadius
+        if let color = background(of: view) {
+            body = radius > 0
+                ? AnyView(body.background(RoundedRectangle(cornerRadius: radius).fill(Color(uiColor: color))))
+                : AnyView(body.background(Color(uiColor: color)))
+        }
+        if view.clipsToBounds || view.layer.masksToBounds {
+            body = radius > 0 ? AnyView(body.clipShape(RoundedRectangle(cornerRadius: radius))) : AnyView(body.clipped())
+        }
+        if view.layer.borderWidth > 0, let border = view.layer.borderColor {
+            body = AnyView(body.overlay(RoundedRectangle(cornerRadius: radius)
+                .strokeBorder(Color(uiColor: UIColor(cgColor: border)), lineWidth: view.layer.borderWidth)))
+        }
+        let opacity = view.alpha * CGFloat(view.layer.opacity)
+        if opacity < 1 { body = AnyView(body.opacity(max(0, opacity))) }
+        if !view.isUserInteractionEnabled { body = AnyView(body.allowsHitTesting(false)) }
+        return body
+    }
+
+    // MARK: Text attributes
+
+    static func textAlignment(_ alignment: NSTextAlignment) -> (text: TextAlignment, frame: Alignment) {
+        switch alignment {
+        case .center: (.center, .center)
+        case .right: (.trailing, .trailing)
+        default: (.leading, .leading)
+        }
+    }
+
+    /// A text color: UIKit's label colors as the page's (see the top of the file).
+    static func textColor(_ color: UIColor?) -> Color? {
+        guard let color else { return nil }
+        if color == .label { return .primary }
+        if color == .secondaryLabel || color == .tertiaryLabel || color == .quaternaryLabel || color == .placeholderText {
+            return Color.secondary.opacity(color.alpha / UIColor.secondaryLabel.alpha)
+        }
+        return Color(uiColor: color)
+    }
+}

package/Sources/UniformTypeIdentifiers/UTType.swift

@@ -0,0 +1,196 @@
+// UniformTypeIdentifiers, as far as the browser needs it: `UTType` values
+// for the common image, movie and document types, matched against the MIME
+// types and file extensions the page reports (a picked file's `type` and
+// name). `PhotosPickerItem.supportedContentTypes` is the main user. Types
+// the table does not declare become dynamic types that carry the MIME type
+// or extension they were made from, as on Apple platforms.
+
+/// A uniform type identifier: `public.jpeg`, `public.movie`, …
+public struct UTType: Hashable, Sendable, CustomStringConvertible {
+    /// `public.jpeg`; `dyn.…` for a type made from an undeclared MIME type or extension.
+    public let identifier: String
+    /// For a dynamic type: the tag it was made from and the type it conforms to.
+    private let dynamicMIMEType: String?
+    private let dynamicExtension: String?
+    private let dynamicSupertype: String?
+
+    private init(declared identifier: String) {
+        self.identifier = identifier
+        dynamicMIMEType = nil
+        dynamicExtension = nil
+        dynamicSupertype = nil
+    }
+
+    private init(dynamicMIMEType mimeType: String?, filenameExtension: String?, conformingTo supertype: UTType) {
+        let tag = mimeType.map { "mime:\($0)" } ?? filenameExtension.map { "ext:\($0)" } ?? ""
+        identifier = "dyn.\(tag)"
+        dynamicMIMEType = mimeType
+        dynamicExtension = filenameExtension
+        dynamicSupertype = supertype.identifier
+    }
+
+    /// A declared type by its identifier; nil for one the table does not know.
+    public init?(_ identifier: String) {
+        guard Self.declarations[identifier] != nil else { return nil }
+        self.init(declared: identifier)
+    }
+
+    /// The declared type with this MIME type, or a dynamic one conforming to
+    /// `supertype`. Nil when a declared type has the MIME type but does not
+    /// conform to `supertype`.
+    public init?(mimeType: String, conformingTo supertype: UTType = .data) {
+        let mime = mimeType.lowercased()
+        if let match = Self.ordered.first(where: { $0.mimeTypes.contains(mime) }) {
+            let type = UTType(declared: match.identifier)
+            guard type.conforms(to: supertype) else { return nil }
+            self = type
+        } else {
+            self.init(dynamicMIMEType: mime, filenameExtension: nil, conformingTo: supertype)
+        }
+    }
+
+    /// The declared type with this file extension (no dot), or a dynamic one
+    /// conforming to `supertype`.
+    public init?(filenameExtension: String, conformingTo supertype: UTType = .data) {
+        let ext = filenameExtension.lowercased()
+        if let match = Self.ordered.first(where: { $0.extensions.contains(ext) }) {
+            let type = UTType(declared: match.identifier)
+            guard type.conforms(to: supertype) else { return nil }
+            self = type
+        } else {
+            self.init(dynamicMIMEType: nil, filenameExtension: ext, conformingTo: supertype)
+        }
+    }
+
+    public var preferredMIMEType: String? { dynamicMIMEType ?? declaration?.mimeTypes.first }
+    public var preferredFilenameExtension: String? { dynamicExtension ?? declaration?.extensions.first }
+    public var localizedDescription: String? { declaration?.description }
+    public var isDynamic: Bool { identifier.hasPrefix("dyn.") }
+    public var isDeclared: Bool { !isDynamic }
+    public var isPublic: Bool { identifier.hasPrefix("public.") }
+    public var description: String { identifier }
+
+    /// Every type this one conforms to, itself excluded.
+    public var supertypes: Set<UTType> {
+        var result = Set<UTType>()
+        var pending = parents
+        while let next = pending.popLast() {
+            let type = UTType(declared: next)
+            if result.insert(type).inserted { pending.append(contentsOf: type.parents) }
+        }
+        return result
+    }
+
+    public func conforms(to type: UTType) -> Bool { self == type || supertypes.contains(type) }
+    public func isSupertype(of type: UTType) -> Bool { type.conforms(to: self) }
+    public func isSubtype(of type: UTType) -> Bool { self != type && conforms(to: type) }
+
+    public static func == (lhs: UTType, rhs: UTType) -> Bool { lhs.identifier == rhs.identifier }
+    public func hash(into hasher: inout Hasher) { hasher.combine(identifier) }
+
+    private var declaration: Declaration? { Self.declarations[identifier] }
+    private var parents: [String] { dynamicSupertype.map { [$0] } ?? declaration?.parents ?? [] }
+
+    // MARK: The declared types
+
+    struct Declaration: Sendable {
+        let identifier: String
+        let parents: [String]
+        let mimeTypes: [String]
+        let extensions: [String]
+        let description: String
+    }
+
+    /// In lookup order: the first type with a MIME type or extension wins.
+    static let ordered: [Declaration] = [
+        Declaration(identifier: "public.item", parents: [], mimeTypes: [], extensions: [], description: "item"),
+        Declaration(identifier: "public.content", parents: ["public.item"], mimeTypes: [], extensions: [], description: "content"),
+        Declaration(identifier: "public.data", parents: ["public.item"], mimeTypes: ["application/octet-stream"], extensions: [], description: "data"),
+        Declaration(identifier: "public.image", parents: ["public.data", "public.content"], mimeTypes: [], extensions: [], description: "image"),
+        Declaration(identifier: "public.jpeg", parents: ["public.image"], mimeTypes: ["image/jpeg", "image/jpg"], extensions: ["jpeg", "jpg", "jpe"], description: "JPEG image"),
+        Declaration(identifier: "public.png", parents: ["public.image"], mimeTypes: ["image/png"], extensions: ["png"], description: "PNG image"),
+        Declaration(identifier: "com.compuserve.gif", parents: ["public.image"], mimeTypes: ["image/gif"], extensions: ["gif"], description: "GIF image"),
+        Declaration(identifier: "public.heic", parents: ["public.heif-standard"], mimeTypes: ["image/heic"], extensions: ["heic"], description: "HEIC image"),
+        Declaration(identifier: "public.heif", parents: ["public.heif-standard"], mimeTypes: ["image/heif"], extensions: ["heif"], description: "HEIF image"),
+        Declaration(identifier: "public.heif-standard", parents: ["public.image"], mimeTypes: [], extensions: [], description: "HEIF image"),
+        Declaration(identifier: "org.webmproject.webp", parents: ["public.image"], mimeTypes: ["image/webp"], extensions: ["webp"], description: "WebP image"),
+        Declaration(identifier: "public.tiff", parents: ["public.image"], mimeTypes: ["image/tiff"], extensions: ["tiff", "tif"], description: "TIFF image"),
+        Declaration(identifier: "com.microsoft.bmp", parents: ["public.image"], mimeTypes: ["image/bmp"], extensions: ["bmp"], description: "Windows bitmap image"),
+        Declaration(identifier: "public.svg-image", parents: ["public.image"], mimeTypes: ["image/svg+xml"], extensions: ["svg"], description: "SVG image"),
+        Declaration(identifier: "public.audiovisual-content", parents: ["public.data", "public.content"], mimeTypes: [], extensions: [], description: "audiovisual content"),
+        Declaration(identifier: "public.movie", parents: ["public.audiovisual-content"], mimeTypes: [], extensions: [], description: "movie"),
+        Declaration(identifier: "public.video", parents: ["public.movie"], mimeTypes: [], extensions: [], description: "video"),
+        Declaration(identifier: "public.mpeg-4", parents: ["public.movie"], mimeTypes: ["video/mp4"], extensions: ["mp4", "mpeg4"], description: "MPEG-4 movie"),
+        Declaration(identifier: "com.apple.quicktime-movie", parents: ["public.movie"], mimeTypes: ["video/quicktime"], extensions: ["mov", "qt"], description: "QuickTime movie"),
+        Declaration(identifier: "public.audio", parents: ["public.audiovisual-content"], mimeTypes: [], extensions: [], description: "audio"),
+        Declaration(identifier: "public.mp3", parents: ["public.audio"], mimeTypes: ["audio/mpeg"], extensions: ["mp3"], description: "MP3 audio"),
+        Declaration(identifier: "public.text", parents: ["public.data", "public.content"], mimeTypes: [], extensions: [], description: "text"),
+        Declaration(identifier: "public.plain-text", parents: ["public.text"], mimeTypes: ["text/plain"], extensions: ["txt", "text"], description: "plain text"),
+        Declaration(identifier: "public.json", parents: ["public.text"], mimeTypes: ["application/json"], extensions: ["json"], description: "JSON"),
+        Declaration(identifier: "public.utf8-plain-text", parents: ["public.plain-text"], mimeTypes: [], extensions: [], description: "Unicode text (UTF-8)"),
+        Declaration(identifier: "public.utf16-plain-text", parents: ["public.plain-text"], mimeTypes: [], extensions: [], description: "Unicode text (UTF-16)"),
+        Declaration(identifier: "public.html", parents: ["public.text"], mimeTypes: ["text/html"], extensions: ["html", "htm"], description: "HTML text"),
+        Declaration(identifier: "public.rtf", parents: ["public.text"], mimeTypes: ["text/rtf"], extensions: ["rtf"], description: "rich text"),
+        Declaration(identifier: "public.xml", parents: ["public.text"], mimeTypes: ["application/xml", "text/xml"], extensions: ["xml"], description: "XML"),
+        Declaration(identifier: "com.apple.property-list", parents: ["public.data"], mimeTypes: [], extensions: ["plist"], description: "property list"),
+        Declaration(identifier: "public.url", parents: ["public.data"], mimeTypes: [], extensions: [], description: "URL"),
+        Declaration(identifier: "public.file-url", parents: ["public.url"], mimeTypes: [], extensions: [], description: "file URL"),
+        Declaration(identifier: "public.folder", parents: ["public.item"], mimeTypes: [], extensions: [], description: "folder"),
+        Declaration(identifier: "public.zip-archive", parents: ["public.data"], mimeTypes: ["application/zip"], extensions: ["zip"], description: "ZIP archive"),
+        Declaration(identifier: "public.mpeg-4-audio", parents: ["public.audio"], mimeTypes: ["audio/mp4", "audio/m4a"], extensions: ["m4a"], description: "MPEG-4 audio"),
+        Declaration(identifier: "com.adobe.pdf", parents: ["public.data", "public.content"], mimeTypes: ["application/pdf"], extensions: ["pdf"], description: "PDF document"),
+    ]
+
+    static let declarations: [String: Declaration] = Dictionary(uniqueKeysWithValues: ordered.map { ($0.identifier, $0) })
+
+    public static let item = UTType(declared: "public.item")
+    public static let content = UTType(declared: "public.content")
+    public static let data = UTType(declared: "public.data")
+    public static let image = UTType(declared: "public.image")
+    public static let jpeg = UTType(declared: "public.jpeg")
+    public static let png = UTType(declared: "public.png")
+    public static let gif = UTType(declared: "com.compuserve.gif")
+    public static let heic = UTType(declared: "public.heic")
+    public static let heif = UTType(declared: "public.heif")
+    public static let webP = UTType(declared: "org.webmproject.webp")
+    public static let tiff = UTType(declared: "public.tiff")
+    public static let bmp = UTType(declared: "com.microsoft.bmp")
+    public static let svg = UTType(declared: "public.svg-image")
+    public static let audiovisualContent = UTType(declared: "public.audiovisual-content")
+    public static let movie = UTType(declared: "public.movie")
+    public static let video = UTType(declared: "public.video")
+    public static let mpeg4Movie = UTType(declared: "public.mpeg-4")
+    public static let quickTimeMovie = UTType(declared: "com.apple.quicktime-movie")
+    public static let audio = UTType(declared: "public.audio")
+    public static let mp3 = UTType(declared: "public.mp3")
+    public static let text = UTType(declared: "public.text")
+    public static let plainText = UTType(declared: "public.plain-text")
+    public static let json = UTType(declared: "public.json")
+    public static let pdf = UTType(declared: "com.adobe.pdf")
+    public static let utf8PlainText = UTType(declared: "public.utf8-plain-text")
+    public static let utf16PlainText = UTType(declared: "public.utf16-plain-text")
+    public static let html = UTType(declared: "public.html")
+    public static let rtf = UTType(declared: "public.rtf")
+    public static let xml = UTType(declared: "public.xml")
+    public static let propertyList = UTType(declared: "com.apple.property-list")
+    public static let url = UTType(declared: "public.url")
+    public static let fileURL = UTType(declared: "public.file-url")
+    public static let folder = UTType(declared: "public.folder")
+    public static let zip = UTType(declared: "public.zip-archive")
+    public static let mpeg4Audio = UTType(declared: "public.mpeg-4-audio")
+
+    /// An app's own type, declared (on iOS) in its Info.plist: here it is
+    /// known by identifier alone, conforming to `supertype` (`Transferable`
+    /// types use one with `CodableRepresentation`).
+    public init(exportedAs identifier: String, conformingTo supertype: UTType? = nil) {
+        self.identifier = identifier
+        dynamicMIMEType = nil
+        dynamicExtension = nil
+        dynamicSupertype = Self.declarations[identifier] == nil ? (supertype ?? .data).identifier : nil
+    }
+
+    /// Another app's type, as `init(exportedAs:conformingTo:)`.
+    public init(importedAs identifier: String, conformingTo supertype: UTType? = nil) {
+        self.init(exportedAs: identifier, conformingTo: supertype)
+    }
+}