ASDK 与文本

if #available(iOS 16.0, *) {
    installEditMenuInteraction()
}
// We deliberately do NOT add a `UITextSelectionDisplayInteraction`.
// The canvas draws ALL of its own selection visuals.
// ...
// on iOS 18+/26 the interaction installs its OWN default selection chrome.
// assigning custom no-draw views no longer suppresses default lollipops.
// ...
// Not creating the interaction at all removes that leak at the source.
// ...
// A FRESH interaction is created per loupe drag and torn down on release.

func legacyPlainText(globalFrom: Int, globalTo: Int) -> String? {
    let lo = clamp(min(globalFrom, globalTo))
    let hi = clamp(max(globalFrom, globalTo))
    var result = ""
    forEachLeafRegionInRange(lo, hi) { region, needsSeparator in
        if needsSeparator { result += "\n" }
        let rStart = region.globalStart
        let rEnd = region.globalStart + region.length
        let a = max(lo, rStart)
        let b = min(hi, rEnd)
        guard a < b else { return }
        let attr = region.layout.attributedString
        let ns = attr.string as NSString
        let slice = NSRange(location: a - rStart, length: b - a)
        attr.enumerateAttribute(.attachment, in: slice, options: []) { value, sub, _ in
            if let att = value as? EmojiTextAttachment {
                result += att.ref.altText ?? ""
            } else if let att = value as? FormulaTextAttachment {
                result += att.latex
            } else { result += ns.substring(with: sub) }
        }
    }
    return result
}

if markedRange == nil {
    inputBackend.setCompositionSnapshot(
        RichTextCompositionSnapshot(blocks: currentBlocks(), anchor: anchor, head: head))
}
inputBackend.notifyingContentChange {
    applyCaretOutcome(applyReplaceOutcome(globalFrom: lo, globalTo: hi, text: text))
    bumpDocumentRevision()
}
let newLen = (text as NSString).length
if newLen == 0 {
    inputBackend.setCompositionMarkedRange(nil, isPrediction: false)
    inputBackend.setCompositionSnapshot(nil)
} else {
    inputBackend.setCompositionMarkedRange(
        NSRange(location: lo, length: newLen),
        isPrediction: selectedRange.location == 0 && selectedRange.length == 0)
}
refreshPredictionStyling()
inputBackend.notifyingSelectionChangeIgnoringCoalescing {
    let selStart = clampGlobal(lo + selectedRange.location)
    applyCaretOutcome(.range(selStart, clampGlobal(selStart + selectedRange.length)))
}

final class EmojiTextAttachment: NSTextAttachment {
    let ref: EmojiRef
    let scale: CGFloat
    let renderBoost: CGFloat
    private static let spacerImage: UIImage =
        UIGraphicsImageRenderer(size: CGSize(width: 1, height: 1)).image { _ in }

    init(ref: EmojiRef, scale: CGFloat, renderBoost: CGFloat = 0) {
        self.ref = ref
        self.scale = scale
        self.renderBoost = renderBoost
        super.init(data: nil, ofType: nil)
        self.image = Self.spacerImage
    }

    private func box(for font: UIFont?) -> CGRect {
        let f = font ?? UIFont.preferredFont(forTextStyle: .body)
        let side = (f.ascender - f.descender) * scale
        return CGRect(x: 0, y: f.descender, width: side, height: side)
    }

let updatedSubstring = NSMutableAttributedString(string: "&")
let replacementRange = NSRange(location: 0, length: updatedSubstring.length)
updatedSubstring.addAttributes(string.attributes(at: range.location, effectiveRange: nil),
                               range: replacementRange)
updatedSubstring.addAttribute(NSAttributedString.Key("Attribute__EmbeddedItem"),
    value: InlineStickerItem(emoji: value, file: value.file,
                             fontSize: font.pointSize, enableAnimation: value.enableAnimation),
    range: replacementRange)
let itemSize = (font.pointSize * 24.0 / 17.0)
let runDelegateData = RunDelegateData(ascent: font.ascender,
                                      descent: font.descender, width: itemSize)
var callbacks = CTRunDelegateCallbacks(
    version: kCTRunDelegateCurrentVersion,
    dealloc: { dataRef in Unmanaged<RunDelegateData>.fromOpaque(dataRef).release() },
    getAscent: { dataRef in
        Unmanaged<RunDelegateData>.fromOpaque(dataRef).takeUnretainedValue().ascent
    },
    getDescent: { dataRef in
        Unmanaged<RunDelegateData>.fromOpaque(dataRef).takeUnretainedValue().descent,
    getWidth: { dataRef in
        Unmanaged<RunDelegateData>.fromOpaque(dataRef).takeUnretainedValue().width
    })

asdisplaynode_iscancelled_block_t isCancelledBlock = nil;
if (asynchronously) {
  uint displaySentinelValue = ++_displaySentinel;
  __weak ASDisplayNode *weakSelf = self;
  isCancelledBlock = ^BOOL{
    __strong ASDisplayNode *self = weakSelf;
    return self == nil || (displaySentinelValue != self->_displaySentinel.load());
  };
} else {
  isCancelledBlock = ^BOOL{ return NO; };
}
asyncdisplaykit_async_transaction_operation_block_t displayBlock =
  [self _displayBlockWithAsynchronous:asynchronously
                     isCancelledBlock:isCancelledBlock rasterizing:NO];
if (!displayBlock) { return; }

if layout.displaySpoilers && !line.spoilers.isEmpty {
    context.saveGState()
    var clipRects: [CGRect] = []
    for spoiler in line.spoilerWords {
        var rect = spoiler.frame.offsetBy(dx: lineFrame.minX,
                                          dy: lineFrame.minY - UIScreenPixel)
        rect.size.height += 1.0 + UIScreenPixel
        clipRects.append(rect)
    }
    context.clip(to: clipRects)
}
let glyphRuns = CTLineGetGlyphRuns(line.line) as NSArray
for run in glyphRuns {
    let run = run as! CTRun
    // ...
    CTRunDraw(run, context, CFRangeMake(0, glyphCount))
}
// ...
if !line.spoilers.isEmpty {
    if layout.displaySpoilers { context.restoreGState() }
    else { clearRects.append(contentsOf: line.spoilerWords.map { $0.frame }) }
}

func caretRect(atOffset offset: Int) -> CGRect {
    if length == 0, emptyTextCaretDirection == .rightToLeft {
        return CGRect(x: container.size.width - 2, y: 0, width: 2, height: 20)
    }
    guard let range = textRange(offset, offset) else {
        return CGRect(x: 0, y: 0, width: 2, height: 20)
    }
    var rect = CGRect(x: 0, y: 0, width: 2, height: 20)
    layoutManager.enumerateTextSegments(in: range, type: .selection, options: []) {
        _, frame, _, _ in
        rect = CGRect(x: frame.minX, y: frame.minY, width: 2,
                      height: max(frame.height, 20))
        return false
    }
    return rect
}

- (BOOL)scrollEnabled { return _shouldBlockPanGesture; }

- (void)setScrollEnabled:(BOOL)scrollEnabled
{
  _shouldBlockPanGesture = !scrollEnabled;
  self.scrollsToTop = scrollEnabled;
  [super setScrollEnabled:YES];
}

- (void)setContentSize:(CGSize)contentSize {
  if (_shouldBlockPanGesture) { return; }
  [super setContentSize:contentSize];
}

- (void)setContentOffset:(CGPoint)contentOffset {
  if (_shouldBlockPanGesture) { return; }
  [super setContentOffset:contentOffset];
}

- (void)setContentOffset:(CGPoint)contentOffset animated:(BOOL)animated {
  if (_shouldBlockPanGesture) { return; }
  [super setContentOffset:contentOffset animated:animated];
}

let truncationToken = CTLineCreateWithAttributedString(truncatedTokenString)
let truncationTokenWidth = CTLineGetTypographicBounds(truncationToken, nil, nil, nil)
    - CTLineGetTrailingWhitespaceWidth(truncationToken)
var effectiveLineRange = brokenLineRange
var measureFitWidth = CTLineGetTypographicBounds(originalLine, nil, nil, nil)
    - CTLineGetTrailingWhitespaceWidth(originalLine)
if customTruncationToken != nil && lineRange.location + lineRange.length < attributedString.length {
    measureFitWidth += truncationTokenWidth
}
// ...
let coreTextLine1 = CTLineCreateTruncatedLine(originalLine,
    max(1.0, Double(lineConstrainedSize.width)), truncationType, truncationToken)
    ?? truncationToken
let runs = (CTLineGetGlyphRuns(coreTextLine1) as [AnyObject]) as! [CTRun]
var hasTruncationToken = false
for run in runs {
    let runRange = CTRunGetStringRange(run)
    if runRange.location + runRange.length >= nsString.length {
        hasTruncationToken = true
        break
    }
}

if let topLeft = cutout?.topLeft {
    cutoutMinY = -fontLineSpacing
    cutoutMaxY = topLeft.height + fontLineSpacing
    cutoutWidth = topLeft.width
    cutoutOffset = cutoutWidth
    cutoutEnabled = true
} else if let topRight = cutout?.topRight {
    cutoutMinY = -fontLineSpacing
    cutoutMaxY = topRight.height + fontLineSpacing
    cutoutWidth = topRight.width
    cutoutEnabled = true
}
// ...
if cutoutEnabled {
    if lineOriginY - fontLineHeight < cutoutMaxY &&
       lineOriginY + fontLineHeight > cutoutMinY {
        lineConstrainedWidth = max(1.0, lineConstrainedWidth - cutoutWidth)
        lineConstrainedWidthDelta = -cutoutWidth
        lineCutoutOffset = cutoutOffset
        lineAdditionalWidth = cutoutWidth
    }
}
let lineCharacterCount = CTTypesetterSuggestLineBreak(
    typesetter, lastLineCharacterIndex, Double(lineConstrainedWidth))

if (_flags.layerBacked) {
  _layer = [self _locked_layerToLoad];
  static int ASLayerDelegateAssociationKey;
  /**
   * CALayer's .delegate property is documented to be weak,
   * but the implementation is actually assign.
   */
  ASWeakProxy *instance = [ASWeakProxy weakProxyWithTarget:self];
  _layer.delegate = (id<CALayerDelegate>)instance;
  objc_setAssociatedObject(_layer, &ASLayerDelegateAssociationKey, instance,
                           OBJC_ASSOCIATION_RETAIN_NONATOMIC);
} else {
  _view = [self _locked_viewToLoad];
  _view.asyncdisplaykit_node = self;
  _layer = _view.layer;
}
_layer.asyncdisplaykit_node = self;
self._locked_asyncLayer.asyncDelegate = self;

if (action == @selector(paste:)) {
  NSArray *items = [UIMenuController sharedMenuController].menuItems;
  if (((UIMenuItem *)items.firstObject).action == @selector(toggleBoldface:)) {
    return false;
  }
  return true;
}
static SEL promptForReplaceSelector;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
  promptForReplaceSelector = NSSelectorFromString(@"_promptForReplace:");
});
if (action == promptForReplaceSelector) { return false; }
if (action == @selector(toggleUnderline:)) { return false; }
return [super canPerformAction:action withSender:sender];
// ...
promptClass = NSClassFromString([[NSString alloc]
  initWithFormat:@"%@AutocorrectInlinePrompt", @"UI"]);
if (result != nil && [result class] == promptClass) {
  [self dropAutocorrection];
}

self.isUserInteractionEnabled = false
self.maskContentsView.mask = self.maskHighlightNode.view
self.maskContentsView.addSubview(self.backgroundView)
self.addSubview(self.maskContentsView)
self.maskBorderContentsView.mask = self.maskBorderHighlightNode.view
self.maskBorderContentsView.addSubview(self.borderBackgroundView)
self.addSubview(self.maskBorderContentsView)
// ...
private func updateAnimations(size: CGSize) {
    if self.backgroundView.layer.animation(forKey: "shimmer") != nil { return }
    let animation = self.backgroundView.layer.makeAnimation(
        from: 0.0 as NSNumber,
        to: (size.width + self.gradientWidth) as NSNumber,
        keyPath: "position.x", timingFunction: CAMediaTimingFunctionName.easeOut.rawValue,
        duration: self.duration, delay: 0.0, mediaTimingFunction: nil,
        removeOnCompletion: true, additive: true)
    animation.repeatCount = Float.infinity
    self.backgroundView.layer.add(animation, forKey: "shimmer")
    self.borderBackgroundView.layer.add(animation, forKey: "shimmer")
}

func syncSpoilers() {
    guard documentHasSpoilers || !spoilerRuns.isEmpty || !spoilerDustViews.isEmpty else { return }
    let runs = computeSpoilerRuns()
    spoilerRuns = runs
    let hideChanged = applySpoilerHiding(runs)
    reconcileSpoilerDust(runs)
    if hideChanged { setNeedsLayout() }
}
// ...
func setSpoilerHidden(_ ranges: [NSRange]) -> Bool {
    let effective = ranges.filter { $0.length > 0 }
    if effective == spoilerLocalRanges { return false }
    for prev in spoilerRanges {
        layoutManager.removeRenderingAttribute(.foregroundColor, for: prev)
    }
    spoilerRanges = []
    renderVersion &+= 1
    for r in effective {
        guard let tr = textRange(r.location, r.location + r.length) else { continue }
        layoutManager.addRenderingAttribute(.foregroundColor, value: UIColor.clear, for: tr)
        spoilerRanges.append(tr)
    }
    spoilerLocalRanges = effective
    return true
}

func pasteMarkdownTwoStep(plainText: String, rich: Document) {
    guard !rich.blocks.isEmpty else { return }
    let plain = plainTextFragment(plainText)
    guard !plain.blocks.isEmpty else { return }
    var range = (start: 0, end: 0)
    suppressHostChangeNotification = true
    editing {
        range = spliceFragmentInEditing(plain)
        return .unchanged
    }
    suppressHostChangeNotification = false
    DispatchQueue.main.async { [weak self] in
        guard let self else { return }
        let size = self.documentSize
        let lo = max(0, min(range.start, size))
        let hi = max(lo, min(range.end, size))
        guard lo < hi else { return }
        self.replaceRange(globalFrom: lo, globalTo: hi, with: rich)
    }
}

var combinedRects: [[CGRect]] = []
var currentRects: [CGRect] = []
for rect in rects {
    if rect.width.isZero {
        if !currentRects.isEmpty { combinedRects.append(currentRects) }
        currentRects.removeAll()
    } else {
        if let last = currentRects.last,
           !last.insetBy(dx: -1.0, dy: -1.0).intersects(rect) {
            combinedRects.append(currentRects)
            currentRects.removeAll()
        }
        currentRects.append(rect)
    }
}
if !currentRects.isEmpty { combinedRects.append(currentRects) }
for rects in combinedRects {
    var rects = rects.map {
        $0.insetBy(dx: -inset, dy: -inset).offsetBy(dx: -topLeft.x, dy: -topLeft.y)
    }
    let minRadius: CGFloat = 2.0
    // ... snap near-equal left and right edges before stitching the path.
}

let existingLayout: TextNodeLayout? = maybeNode?.cachedLayout
return { arguments in
    let layout: TextNodeLayout
    var updated = false
    if let existingLayout = existingLayout,
       existingLayout.constrainedSize == arguments.constrainedSize,
       existingLayout.maximumNumberOfLines == arguments.maximumNumberOfLines,
       existingLayout.truncationType == arguments.truncationType,
       existingLayout.cutout == arguments.cutout,
       existingLayout.explicitAlignment == arguments.alignment,
       existingLayout.lineSpacing.isEqual(to: arguments.lineSpacing) {
        // ... compare background color and attributed string.
        if stringMatch { layout = existingLayout }
        else {
            layout = TextNode.calculateLayout(attributedString: arguments.attributedString,
                minimumNumberOfLines: arguments.minimumNumberOfLines,
                maximumNumberOfLines: arguments.maximumNumberOfLines,
                truncationType: arguments.truncationType,
                backgroundColor: arguments.backgroundColor,
                constrainedSize: arguments.constrainedSize, alignment: arguments.alignment)
            updated = true
        }
    // ...

private final class MultiScaleTextStateNode: ASDisplayNode {
    let tintTextNode: ImmediateTextNode
    let noTintTextNode: ImmediateTextNode

    override init() {
        self.tintTextNode = ImmediateTextNode()
        self.tintTextNode.displaysAsynchronously = false
        self.tintTextNode.renderContentTypes =
            TextNode.RenderContentTypes.all.subtracting(TextNode.RenderContentTypes.emoji)

        self.noTintTextNode = ImmediateTextNode()
        self.noTintTextNode.displaysAsynchronously = false
        self.noTintTextNode.renderContentTypes = .emoji

        super.init()
        self.addSubnode(self.tintTextNode)
        self.addSubnode(self.noTintTextNode)
    }
}

- (BOOL)isSimpleRectangularTextContainer { return false; }

- (CGRect)lineFragmentRectForProposedRect:(CGRect)proposedRect
    atIndex:(NSUInteger)characterIndex
    writingDirection:(NSWritingDirection)baseWritingDirection
    remainingRect:(nullable CGRect *)remainingRect
{
  CGRect result = [super lineFragmentRectForProposedRect:proposedRect
      atIndex:characterIndex writingDirection:baseWritingDirection remainingRect:remainingRect];
  NSTextStorage *textStorage = self.layoutManager.textStorage;
  // ... inspect `Attribute__Blockquote` and whether this is its first line.
  if (isFirstLine) { result.size.width -= 100.0f; }
  return result;
}

- (void)showCGGlyphs:(const CGGlyph *)glyphs positions:(const CGPoint *)positions
    count:(NSUInteger)glyphCount font:(UIFont *)font matrix:(CGAffineTransform)textMatrix
    attributes:(NSDictionary<NSAttributedStringKey,id> *)attributes inContext:(CGContextRef)graphicsContext
{
  for (NSUInteger i = 0; i < glyphCount; i++) {
    if (attributes[@"Attribute__CustomEmoji"] != nil) { continue; }
    [super showCGGlyphs:&glyphs[i] positions:&positions[i] count:1 font:font
                 matrix:textMatrix attributes:attributes inContext:graphicsContext];
  }
}