Use *nontrivial* node span rather than visible node span for provenance

Sources/PterodactylElaborator/Elaborator.swift

···
 }
 
 extension SyntaxTreeCursor: HasProvenance {
-	public var provenance: Range<Int>? { visibleUtf16Range }
+	public var provenance: Range<Int>? { nontrivialUtf16Range }
 }
 
 extension SyntaxTreeCursor: ElabType {

Sources/PterodactylSyntax/VisibleNodeSearching.swift

···
 	}
 }
 
-public protocol VisibleNodeSearching {
-	func firstVisibleNode(under symmetry: ArraySymmetry) -> SyntaxTreeCursor.Child?
+public protocol NodeSearching {
+	func firstToken(under symmetry: ArraySymmetry, satisfying predicate: (Token) -> Bool) -> SyntaxTokenCursor?
 }
 
-extension VisibleNodeSearching {
-	public var visibleUtf16Range: Range<Int>? {
+extension NodeSearching {
+	public func utf16RangeClamped(to predicate: (Token) -> Bool) -> Range<Int>? {
 		guard
-			let firstNode = firstVisibleNode(under: .identity),
-			let lastNode = firstVisibleNode(under: .reverse)
+			let first = firstToken(under: .identity, satisfying: predicate),
+			let last = firstToken(under: .reverse, satisfying: predicate)
 		else { return nil }
-		return firstNode.utf16Range.lowerBound..<lastNode.utf16Range.upperBound
+		return first.utf16Range.lowerBound..<last.utf16Range.upperBound
+	}
+
+	public var visibleUtf16Range: Range<Int>? {
+		utf16RangeClamped(to: \.kind.isVisible)
 	}
-}
 
-extension SyntaxTreeCursor: VisibleNodeSearching {
-	public func firstVisibleNode(under symmetry: ArraySymmetry) -> SyntaxTreeCursor.Child? {
-		for child in children.apply(symmetry: symmetry) {
-			if let visibleChild = child.firstVisibleNode(under: symmetry) { return visibleChild }
+	public var nontrivialUtf16Range: Range<Int>? {
+		utf16RangeClamped { token in
+			!token.kind.isTrivia
 		}
+	}
+}
 
-		return nil
+extension SyntaxTokenCursor: NodeSearching {
+	public func firstToken(under symmetry: ArraySymmetry, satisfying predicate: (Token) -> Bool) -> SyntaxTokenCursor? {
+		if predicate(token) { self } else { nil }
 	}
 }
 
-extension SyntaxTokenCursor: VisibleNodeSearching {
-	public func firstVisibleNode(under symmetry: ArraySymmetry) -> SyntaxTreeCursor.Child? {
-		token.kind.isVisible ? .token(self) : nil
+extension SyntaxTreeCursor.Child: NodeSearching {
+	public func firstToken(under symmetry: ArraySymmetry, satisfying predicate: (Token) -> Bool) -> SyntaxTokenCursor? {
+		switch self {
+		case .token(let syntaxTokenCursor): syntaxTokenCursor.firstToken(under: symmetry, satisfying: predicate)
+		case .tree(let syntaxTreeCursor): syntaxTreeCursor.firstToken(under: symmetry, satisfying: predicate)
+		}
 	}
 }
 
-extension SyntaxTreeCursor.Child {
-	public func firstVisibleNode(under symmetry: ArraySymmetry) -> SyntaxTreeCursor.Child? {
-		switch self {
-		case .token(let syntaxTokenCursor): syntaxTokenCursor.firstVisibleNode(under: symmetry)
-		case .tree(let syntaxTreeCursor): syntaxTreeCursor.firstVisibleNode(under: symmetry)
+extension SyntaxTreeCursor: NodeSearching {
+	public func firstToken(under symmetry: ArraySymmetry, satisfying predicate: (Token) -> Bool) -> SyntaxTokenCursor? {
+		for child in children.apply(symmetry: symmetry) {
+			if let first = child.firstToken(under: symmetry, satisfying: predicate) { return first }
 		}
+
+		return nil
 	}
 }
+