@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/UIKit/TextView.swift

@@ -0,0 +1,538 @@
+// UIKit's text views and the attributed strings they show. A representable's
+// `UILabel` is drawn as a `text`, a `UITextView` as a `texteditor` while it is
+// editable and as a `text` (with the rich text `runs`) when it is not
+// (ViewTranslation.swift). What the user types reaches the text view as
+// UIKit's typing would: the delegate is asked
+// `textView(_:shouldChangeTextIn:replacementText:)` for the edit (the
+// range and replacement found by comparing the old and new text), the text
+// changes, the caret moves to the end of the replacement, and the delegate
+// hears `textViewDidChange` and `textViewDidChangeSelection`. Focus is
+// shared both ways: `becomeFirstResponder` focuses the page's text area, and
+// a tap into it (or out) makes the view first responder (or resigns). The
+// page does not report the caret itself, so `selectedRange` is that guess; typing
+// attributes, keyboard settings, data detectors, input accessory views and
+// the like are kept and not used. Sizes (`sizeThatFits`,
+// `intrinsicContentSize`) are estimates from the font's size: Swift has no
+// text metrics, so a label or text view whose size matters is better left
+// to the page (a representable sizes them by measuring what it draws).
+//
+// Corelibs Foundation has `NSAttributedString` without UIKit's attribute
+// keys, and without the conversions from and to `AttributedString` that
+// Apple's Foundation has; both are here, as `import SwiftUI` brings UIKit.
+
+import Foundation
+import FoundationBridge
+import SwiftUI
+
+// MARK: - Attributed strings
+
+extension NSAttributedString.Key {
+    public static let font = NSAttributedString.Key("NSFont")
+    public static let foregroundColor = NSAttributedString.Key("NSColor")
+    public static let backgroundColor = NSAttributedString.Key("NSBackgroundColor")
+    public static let link = NSAttributedString.Key("NSLink")
+    public static let underlineStyle = NSAttributedString.Key("NSUnderline")
+    public static let underlineColor = NSAttributedString.Key("NSUnderlineColor")
+    public static let strikethroughStyle = NSAttributedString.Key("NSStrikethrough")
+    public static let strikethroughColor = NSAttributedString.Key("NSStrikethroughColor")
+    public static let kern = NSAttributedString.Key("NSKern")
+    public static let baselineOffset = NSAttributedString.Key("NSBaselineOffset")
+    public static let paragraphStyle = NSAttributedString.Key("NSParagraphStyle")
+    public static let attachment = NSAttributedString.Key("NSAttachment")
+    public static let shadow = NSAttributedString.Key("NSShadow")
+    public static let obliqueness = NSAttributedString.Key("NSObliqueness")
+    public static let inlinePresentationIntent = NSAttributedString.Key("NSInlinePresentationIntent")
+}
+
+/// How text is underlined or struck through.
+public struct NSUnderlineStyle: OptionSet, Hashable, Sendable {
+    public let rawValue: Int
+    public init(rawValue: Int) { self.rawValue = rawValue }
+    public static let single = NSUnderlineStyle(rawValue: 0x01)
+    public static let thick = NSUnderlineStyle(rawValue: 0x02)
+    public static let double = NSUnderlineStyle(rawValue: 0x09)
+    public static let patternDot = NSUnderlineStyle(rawValue: 0x0100)
+    public static let patternDash = NSUnderlineStyle(rawValue: 0x0200)
+    public static let byWord = NSUnderlineStyle(rawValue: 0x8000)
+}
+
+public enum NSTextAlignment: Int, Sendable {
+    case left = 0, center = 1, right = 2, justified = 3, natural = 4
+}
+
+public enum NSLineBreakMode: Int, Sendable {
+    case byWordWrapping = 0, byCharWrapping, byClipping, byTruncatingHead, byTruncatingTail, byTruncatingMiddle
+}
+
+extension NSAttributedString {
+    /// The runs of an `AttributedString`: their links and inline
+    /// presentation intents (Markdown's emphasis), the attributes the browser
+    /// build's `AttributedString` carries.
+    public convenience init(_ attributedString: AttributedString) {
+        self.init(attributedString: _nsAttributedString(attributedString))
+    }
+}
+
+extension AttributedString {
+    /// The string's runs with their links and inline presentation intents;
+    /// UIKit's attributes (font, color) have no place in it here and are dropped.
+    public init(_ nsAttributedString: NSAttributedString) {
+        var result = AttributedString()
+        nsAttributedString.enumerateAttributes(in: NSRange(location: 0, length: nsAttributedString.length)) { attributes, range, _ in
+            var piece = AttributedString(nsAttributedString.attributedSubstring(from: range).string)
+            if let link = _url(attributes[.link]) { piece.link = link }
+            if let intent = attributes[.inlinePresentationIntent] as? InlinePresentationIntent { piece.inlinePresentationIntent = intent }
+            result += piece
+        }
+        self = result
+    }
+}
+
+private func _nsAttributedString(_ attributedString: AttributedString) -> NSAttributedString {
+    let result = NSMutableAttributedString(string: "")
+    for run in attributedString.runs {
+        var attributes: [NSAttributedString.Key: Any] = [:]
+        if let link = run.link { attributes[.link] = link }
+        if let intent = run.inlinePresentationIntent { attributes[.inlinePresentationIntent] = intent }
+        result.append(NSAttributedString(string: String(attributedString[run.range].characters), attributes: attributes))
+    }
+    return result
+}
+
+/// A link attribute's URL: a `URL` or a string.
+func _url(_ value: Any?) -> URL? {
+    if let url = value as? URL { return url }
+    if let string = value as? String { return URL(string: string) }
+    return nil
+}
+
+extension Text {
+    /// An attributed string as styled text: each run's font, color,
+    /// underline, strikethrough, kerning, baseline offset, link and inline
+    /// presentation intent. Runs without a font or color take the view's.
+    init(_uiKit attributed: NSAttributedString) {
+        var result: Text?
+        attributed.enumerateAttributes(in: NSRange(location: 0, length: attributed.length)) { attributes, range, _ in
+            var piece = Text(verbatim: attributed.attributedSubstring(from: range).string)
+            if let font = attributes[.font] as? UIFont { piece = piece.font(Font(font)) }
+            if let color = attributes[.foregroundColor] as? UIColor { piece = piece.foregroundColor(Color(uiColor: color)) }
+            if let style = attributes[.underlineStyle] as? Int, style != 0 {
+                piece = piece.underline(true, color: (attributes[.underlineColor] as? UIColor).map { Color(uiColor: $0) })
+            }
+            if let style = attributes[.strikethroughStyle] as? Int, style != 0 {
+                piece = piece.strikethrough(true, color: (attributes[.strikethroughColor] as? UIColor).map { Color(uiColor: $0) })
+            }
+            if let kern = attributes[.kern] as? CGFloat { piece = piece.kerning(kern) }
+            if let kern = attributes[.kern] as? Double { piece = piece.kerning(CGFloat(kern)) }
+            if let offset = attributes[.baselineOffset] as? CGFloat { piece = piece.baselineOffset(offset) }
+            if let intent = attributes[.inlinePresentationIntent] as? InlinePresentationIntent {
+                if intent.contains(.stronglyEmphasized) { piece = piece.bold() }
+                if intent.contains(.emphasized) { piece = piece.italic() }
+                if intent.contains(.code) { piece = piece.monospaced() }
+                if intent.contains(.strikethrough) { piece = piece.strikethrough() }
+            }
+            if let link = _url(attributes[.link]) { piece = piece._link(link.absoluteString) }
+            result = result.map { $0 + piece } ?? piece
+        }
+        self = result ?? Text(verbatim: "")
+    }
+}
+
+// MARK: - Size estimates
+
+/// Text sizes from a font's point size alone: an average character is a
+/// little over half the size wide, and paragraphs wrap at `width`.
+enum _TextEstimate {
+    static func size(of string: String, font: UIFont, width: CGFloat?, maximumLines: Int = 0) -> CGSize {
+        let characterWidth = font.pointSize * 0.52
+        let paragraphs = string.split(separator: "\n", omittingEmptySubsequences: false)
+        var lines = 0
+        var widest: CGFloat = 0
+        for paragraph in paragraphs {
+            let natural = CGFloat(paragraph.count) * characterWidth
+            widest = max(widest, natural)
+            if let width, width > 0, width.isFinite {
+                lines += max(1, Int((natural / width).rounded(.up)))
+            } else {
+                lines += 1
+            }
+        }
+        if maximumLines > 0 { lines = min(lines, maximumLines) }
+        let resolvedWidth = width.flatMap { $0 > 0 && $0.isFinite ? min($0, widest) : nil } ?? widest
+        return CGSize(width: resolvedWidth.rounded(.up), height: CGFloat(max(1, lines)) * font.lineHeight)
+    }
+}
+
+// MARK: - Labels
+
+/// A label: drawn as a `text` with its font, color, alignment and line limit.
+@MainActor
+open class UILabel: UIView {
+    private var plainText: String?
+    private var attributed: NSAttributedString?
+
+    open var text: String? {
+        get { attributed?.string ?? plainText }
+        set {
+            plainText = newValue
+            attributed = nil
+            _setNeedsTranslation()
+        }
+    }
+    open var attributedText: NSAttributedString? {
+        get {
+            if let attributed { return attributed }
+            guard let plainText else { return nil }
+            var attributes: [NSAttributedString.Key: Any] = [:]
+            if let font { attributes[.font] = font }
+            if let textColor { attributes[.foregroundColor] = textColor }
+            return NSAttributedString(string: plainText, attributes: attributes)
+        }
+        set {
+            attributed = newValue.map { NSAttributedString(attributedString: $0) }
+            plainText = newValue?.string
+            _setNeedsTranslation()
+        }
+    }
+    /// Whether the text was set as an attributed string (drawn with its runs).
+    var _hasAttributedText: Bool { attributed != nil }
+    open var font: UIFont! = .systemFont(ofSize: 17) { didSet { _setNeedsTranslation() } }
+    open var textColor: UIColor! = .label { didSet { _setNeedsTranslation() } }
+    open var textAlignment: NSTextAlignment = .natural { didSet { _setNeedsTranslation() } }
+    open var numberOfLines = 1 { didSet { _setNeedsTranslation() } }
+    open var lineBreakMode: NSLineBreakMode = .byTruncatingTail
+    open var isEnabled = true { didSet { _setNeedsTranslation() } }
+    open var isHighlighted = false
+    open var highlightedTextColor: UIColor?
+    open var adjustsFontSizeToFitWidth = false
+    open var adjustsFontForContentSizeCategory = false
+    open var minimumScaleFactor: CGFloat = 0
+    open var allowsDefaultTighteningForTruncation = false
+    open var preferredMaxLayoutWidth: CGFloat = 0
+
+    public override init(frame: CGRect) { super.init(frame: frame) }
+    public required init?(coder: NSCoder) { super.init(coder: coder) }
+
+    open override var intrinsicContentSize: CGSize {
+        _TextEstimate.size(of: text ?? "", font: font, width: preferredMaxLayoutWidth > 0 ? preferredMaxLayoutWidth : nil,
+                           maximumLines: numberOfLines)
+    }
+
+    open override func sizeThatFits(_ size: CGSize) -> CGSize {
+        _TextEstimate.size(of: text ?? "", font: font, width: size.width > 0 ? size.width : nil, maximumLines: numberOfLines)
+    }
+}
+
+// MARK: - Text views
+
+/// A text container's settings, kept (the page lays the text out).
+@MainActor
+open class NSTextContainer {
+    open var size: CGSize
+    open var lineFragmentPadding: CGFloat = 5
+    open var maximumNumberOfLines = 0
+    open var lineBreakMode: NSLineBreakMode = .byWordWrapping
+    open var widthTracksTextView = true
+    open var heightTracksTextView = false
+
+    public init(size: CGSize = .zero) { self.size = size }
+}
+
+/// A position in a text input's text, as a UTF-16 offset.
+@MainActor
+open class UITextPosition {
+    let offset: Int
+    init(offset: Int) { self.offset = offset }
+}
+
+/// A range of a text input's text.
+@MainActor
+open class UITextRange {
+    public let start: UITextPosition
+    public let end: UITextPosition
+    open var isEmpty: Bool { start.offset == end.offset }
+    init(start: UITextPosition, end: UITextPosition) {
+        self.start = start
+        self.end = end
+    }
+}
+
+public enum UITextAutocapitalizationType: Int, Sendable { case none, words, sentences, allCharacters }
+public enum UITextAutocorrectionType: Int, Sendable { case `default`, no, yes }
+public enum UITextSpellCheckingType: Int, Sendable { case `default`, no, yes }
+public enum UITextSmartQuotesType: Int, Sendable { case `default`, no, yes }
+public enum UITextSmartDashesType: Int, Sendable { case `default`, no, yes }
+public enum UITextInlinePredictionType: Int, Sendable { case `default`, no, yes }
+public enum UIReturnKeyType: Int, Sendable {
+    case `default`, go, google, join, next, route, search, send, yahoo, done, emergencyCall, `continue`
+}
+public enum UITextItemInteraction: Int, Sendable { case invokeDefaultAction, presentActions, preview }
+
+public struct UIDataDetectorTypes: OptionSet, Sendable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+    public static let phoneNumber = UIDataDetectorTypes(rawValue: 1 << 0)
+    public static let link = UIDataDetectorTypes(rawValue: 1 << 1)
+    public static let address = UIDataDetectorTypes(rawValue: 1 << 2)
+    public static let calendarEvent = UIDataDetectorTypes(rawValue: 1 << 3)
+    public static let all = UIDataDetectorTypes(rawValue: UInt.max)
+}
+
+/// What a text view tells its delegate. Every method has a default (they are
+/// `@objc optional` on iOS); `delegate?.textViewDidChange?(textView)`, the
+/// Objective-C way to call one, works through the properties below.
+@MainActor
+public protocol UITextViewDelegate: UIScrollViewDelegate {
+    func textViewShouldBeginEditing(_ textView: UITextView) -> Bool
+    func textViewShouldEndEditing(_ textView: UITextView) -> Bool
+    func textViewDidBeginEditing(_ textView: UITextView)
+    func textViewDidEndEditing(_ textView: UITextView)
+    func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool
+    func textViewDidChange(_ textView: UITextView)
+    func textViewDidChangeSelection(_ textView: UITextView)
+    func textView(_ textView: UITextView, shouldInteractWith URL: URL, in characterRange: NSRange,
+                  interaction: UITextItemInteraction) -> Bool
+}
+
+extension UITextViewDelegate {
+    public func textViewShouldBeginEditing(_ textView: UITextView) -> Bool { true }
+    public func textViewShouldEndEditing(_ textView: UITextView) -> Bool { true }
+    public func textViewDidBeginEditing(_ textView: UITextView) {}
+    public func textViewDidEndEditing(_ textView: UITextView) {}
+    public func textView(_ textView: UITextView, shouldChangeTextIn range: NSRange, replacementText text: String) -> Bool { true }
+    public func textViewDidChange(_ textView: UITextView) {}
+    public func textViewDidChangeSelection(_ textView: UITextView) {}
+    public func textView(_ textView: UITextView, shouldInteractWith URL: URL, in characterRange: NSRange,
+                         interaction: UITextItemInteraction) -> Bool { true }
+
+    // `delegate?.textViewDidChange?(textView)`: an optional requirement's
+    // call on iOS. A property of optional function type with the method's
+    // base name lets the same expression call the (always present) method.
+    public var textViewDidChange: ((UITextView) -> Void)? { { self.textViewDidChange($0) } }
+    public var textViewDidChangeSelection: ((UITextView) -> Void)? { { self.textViewDidChangeSelection($0) } }
+    public var textViewDidBeginEditing: ((UITextView) -> Void)? { { self.textViewDidBeginEditing($0) } }
+    public var textViewDidEndEditing: ((UITextView) -> Void)? { { self.textViewDidEndEditing($0) } }
+}
+
+/// A multi-line text view: editable, drawn as a `texteditor`; read-only, as
+/// a `text` (see the top of the file).
+@MainActor
+open class UITextView: UIScrollView {
+    private var storage = NSMutableAttributedString(string: "")
+
+    /// The text; setting it gives all of it the view's font and color.
+    open var text: String! {
+        get { storage.string }
+        set {
+            storage = NSMutableAttributedString(string: newValue ?? "", attributes: baseAttributes)
+            clampSelection()
+            _setNeedsTranslation()
+        }
+    }
+    open var attributedText: NSAttributedString! {
+        get { NSAttributedString(attributedString: storage) }
+        set {
+            storage = NSMutableAttributedString(attributedString: newValue ?? NSAttributedString(string: ""))
+            clampSelection()
+            _setNeedsTranslation()
+        }
+    }
+    /// The font of all the text (setting it restyles the text, as on iOS).
+    open var font: UIFont? {
+        didSet {
+            if let font { storage.addAttribute(.font, value: font, range: NSRange(location: 0, length: storage.length)) }
+            _setNeedsTranslation()
+        }
+    }
+    open var textColor: UIColor? {
+        didSet {
+            if let textColor { storage.addAttribute(.foregroundColor, value: textColor, range: NSRange(location: 0, length: storage.length)) }
+            _setNeedsTranslation()
+        }
+    }
+    open var textAlignment: NSTextAlignment = .natural { didSet { _setNeedsTranslation() } }
+    open var isEditable = true { didSet { _setNeedsTranslation() } }
+    open var isSelectable = true { didSet { _setNeedsTranslation() } }
+    /// The selection: where the app put it, else the end of the last edit.
+    open var selectedRange = NSRange(location: 0, length: 0)
+    open var typingAttributes: [NSAttributedString.Key: Any] = [:]
+    open var linkTextAttributes: [NSAttributedString.Key: Any] = [:]
+    open var textContainerInset = UIEdgeInsets(top: 8, left: 0, bottom: 8, right: 0) { didSet { _setNeedsTranslation() } }
+    public let textContainer = NSTextContainer()
+    open var keyboardType: UIKeyboardType = .default
+    open var autocapitalizationType: UITextAutocapitalizationType = .sentences
+    open var autocorrectionType: UITextAutocorrectionType = .default
+    open var spellCheckingType: UITextSpellCheckingType = .default
+    open var smartQuotesType: UITextSmartQuotesType = .default
+    open var smartDashesType: UITextSmartDashesType = .default
+    open var inlinePredictionType: UITextInlinePredictionType = .default
+    open var returnKeyType: UIReturnKeyType = .default
+    open var dataDetectorTypes: UIDataDetectorTypes = []
+    open var allowsEditingTextAttributes = false
+    open var adjustsFontForContentSizeCategory = false
+    open var clearsOnInsertion = false
+    open var isFindInteractionEnabled = false
+    open var inputAccessoryView: UIView?
+    open var inputView: UIView?
+    /// No marked (composing) text reaches Swift: the page commits it first.
+    open var markedTextRange: UITextRange? { nil }
+    /// Also the scroll view's delegate (`UITextViewDelegate` refines it).
+    open weak var delegate: UITextViewDelegate? { didSet { _scrollDelegate = delegate } }
+    /// Asked to transform pasted items (TextPaste.swift). The page pastes
+    /// text into the text area itself, so it is not consulted yet.
+    open weak var pasteDelegate: (any UITextPasteDelegate)?
+    /// What the view accepts when pasted or dropped into; kept.
+    open var pasteConfiguration: UIPasteConfiguration?
+    public private(set) var isFirstResponder = false
+
+    public override init(frame: CGRect) {
+        super.init(frame: frame)
+        isScrollEnabled = true
+    }
+
+    public convenience init(frame: CGRect, textContainer: NSTextContainer?) {
+        self.init(frame: frame)
+    }
+
+    public required init?(coder: NSCoder) { super.init(coder: coder) }
+
+    private var baseAttributes: [NSAttributedString.Key: Any] {
+        var attributes = typingAttributes
+        if let font { attributes[.font] = font }
+        if let textColor { attributes[.foregroundColor] = textColor }
+        return attributes
+    }
+
+    open var hasText: Bool { storage.length > 0 }
+
+    /// Takes the keyboard focus: the page focuses the text area, and the
+    /// delegate hears that editing began.
+    @discardableResult open func becomeFirstResponder() -> Bool {
+        guard !isFirstResponder else { return true }
+        guard isEditable, delegate?.textViewShouldBeginEditing(self) ?? true else { return false }
+        isFirstResponder = true
+        _setNeedsTranslation()
+        delegate?.textViewDidBeginEditing(self)
+        return true
+    }
+
+    @discardableResult open func resignFirstResponder() -> Bool {
+        guard isFirstResponder else { return true }
+        guard delegate?.textViewShouldEndEditing(self) ?? true else { return false }
+        isFirstResponder = false
+        _setNeedsTranslation()
+        delegate?.textViewDidEndEditing(self)
+        return true
+    }
+
+    open func select(_ sender: Any?) {}
+    open func selectAll(_ sender: Any?) { selectedRange = NSRange(location: 0, length: storage.length) }
+    open func scrollRangeToVisible(_ range: NSRange) {}
+
+    /// Typing: replaces the selection with `text` (as the keyboard would).
+    open func insertText(_ text: String) {
+        _replace(selectedRange, with: text)
+    }
+
+    open func deleteBackward() {
+        let range = selectedRange.length > 0 ? selectedRange
+            : NSRange(location: max(0, selectedRange.location - 1), length: selectedRange.location > 0 ? 1 : 0)
+        guard range.length > 0 else { return }
+        _replace(range, with: "")
+    }
+
+    // MARK: Positions and ranges
+
+    public var beginningOfDocument: UITextPosition { UITextPosition(offset: 0) }
+    public var endOfDocument: UITextPosition { UITextPosition(offset: storage.length) }
+    open var selectedTextRange: UITextRange? {
+        get {
+            UITextRange(start: UITextPosition(offset: selectedRange.location),
+                        end: UITextPosition(offset: selectedRange.location + selectedRange.length))
+        }
+        set {
+            guard let newValue else { return }
+            selectedRange = NSRange(location: newValue.start.offset, length: max(0, newValue.end.offset - newValue.start.offset))
+        }
+    }
+    public func position(from position: UITextPosition, offset: Int) -> UITextPosition? {
+        let target = position.offset + offset
+        return (0...storage.length).contains(target) ? UITextPosition(offset: target) : nil
+    }
+    public func offset(from: UITextPosition, to toPosition: UITextPosition) -> Int { toPosition.offset - from.offset }
+    public func textRange(from fromPosition: UITextPosition, to toPosition: UITextPosition) -> UITextRange? {
+        UITextRange(start: fromPosition, end: toPosition)
+    }
+    public func text(in range: UITextRange) -> String? {
+        let nsRange = NSRange(location: range.start.offset, length: range.end.offset - range.start.offset)
+        guard nsRange.location >= 0, nsRange.length >= 0, nsRange.location + nsRange.length <= storage.length else { return nil }
+        return storage.attributedSubstring(from: nsRange).string
+    }
+    public func replace(_ range: UITextRange, withText text: String) {
+        _replace(NSRange(location: range.start.offset, length: range.end.offset - range.start.offset), with: text)
+    }
+
+    // MARK: Sizes
+
+    /// An estimate: the text wrapped at `size.width` less the insets, at
+    /// the font's line height (Swift has no text metrics).
+    open override func sizeThatFits(_ size: CGSize) -> CGSize {
+        let insets = textContainerInset
+        let padding = textContainer.lineFragmentPadding * 2 + insets.left + insets.right
+        let width = size.width.isFinite && size.width > 0 ? max(1, size.width - padding) : nil
+        let font = self.font ?? .preferredFont(forTextStyle: .body)
+        let text = _TextEstimate.size(of: storage.string, font: font, width: width)
+        return CGSize(width: width.map { $0 + padding } ?? text.width + padding,
+                      height: text.height + insets.top + insets.bottom)
+    }
+
+    open override var intrinsicContentSize: CGSize {
+        isScrollEnabled ? CGSize(width: UIView.noIntrinsicMetric, height: UIView.noIntrinsicMetric)
+            : sizeThatFits(CGSize(width: bounds.width, height: .greatestFiniteMagnitude))
+    }
+
+    // MARK: Editing
+
+    /// The page's text area now shows `newText`: works out the edit, asks
+    /// the delegate, applies it and reports it (see the top of the file).
+    func _userEdited(_ newText: String) {
+        let old = Array(storage.string)
+        let new = Array(newText)
+        guard old != new else { return }
+        var prefix = 0
+        while prefix < old.count, prefix < new.count, old[prefix] == new[prefix] { prefix += 1 }
+        var suffix = 0
+        while suffix < old.count - prefix, suffix < new.count - prefix,
+              old[old.count - 1 - suffix] == new[new.count - 1 - suffix] { suffix += 1 }
+        let location = String(old[..<prefix]).utf16.count
+        let length = String(old[prefix..<(old.count - suffix)]).utf16.count
+        let replacement = String(new[prefix..<(new.count - suffix)])
+        let range = NSRange(location: location, length: length)
+        if !isFirstResponder { becomeFirstResponder() }
+        // A refused edit stays on the page until the text next changes: the
+        // text area is only told about text that differs from what it was sent.
+        guard delegate?.textView(self, shouldChangeTextIn: range, replacementText: replacement) ?? true else { return }
+        _replace(range, with: replacement)
+    }
+
+    private func _replace(_ range: NSRange, with replacement: String) {
+        let clamped = NSRange(location: min(range.location, storage.length),
+                              length: max(0, min(range.length, storage.length - min(range.location, storage.length))))
+        var attributes = baseAttributes
+        if clamped.location > 0, typingAttributes.isEmpty {
+            // Typed text continues the attributes before it, as on iOS.
+            attributes.merge(storage.attributes(at: clamped.location - 1, effectiveRange: nil)) { _, previous in previous }
+        }
+        storage.replaceCharacters(in: clamped, with: NSAttributedString(string: replacement, attributes: attributes))
+        selectedRange = NSRange(location: clamped.location + replacement.utf16.count, length: 0)
+        _setNeedsTranslation()
+        delegate?.textViewDidChange(self)
+        delegate?.textViewDidChangeSelection(self)
+    }
+
+    private func clampSelection() {
+        let length = storage.length
+        let location = min(selectedRange.location, length)
+        selectedRange = NSRange(location: location, length: min(selectedRange.length, length - location))
+    }
+}