refactor: Optimize invisible text property handling using Emacs built-in functions

Author: LemonBreezes

evil-easymotion.el

@@ -213,33 +213,33 @@ This is a safety measure to prevent infinite loops."
                                                (seq-some (lambda (ov) 
                                                            (overlay-get ov 'invisible))
                                                          ovs))))
-                                ;; Skip over the invisible area in the appropriate direction
+                                ;; Skip over the invisible area efficiently
                                 (let* ((pos (point))
-                                       ;; Find extent of invisibility
-                                       (invisible-beg pos)
-                                       (invisible-end pos)
-                                       ;; Find overlays that might cause invisibility
-                                       (overlays (overlays-at pos)))
+                                       (next-change nil)
+                                       (prev-change nil))
 
-                                  ;; Process text properties first (they're often faster)
-                                  (while (and (> invisible-beg (point-min))
-                                              (invisible-p (1- invisible-beg)))
-                                    (setq invisible-beg (1- invisible-beg)))
+                                  ;; Find next visible position using text properties
+                                  (setq next-change (next-single-property-change pos 'invisible nil (point-max)))
+                                  (setq next-change (or next-change (point-max)))
 
-                                  (while (and (< invisible-end (point-max))
-                                              (invisible-p (1+ invisible-end)))
-                                    (setq invisible-end (1+ invisible-end)))
+                                  ;; Find previous visible position using text properties
+                                  (setq prev-change (previous-single-property-change pos 'invisible nil (point-min)))
+                                  (setq prev-change (or prev-change (point-min)))
 
-                                  ;; Then check overlays to see if they extend the invisible region
-                                  (dolist (ov overlays)
-                                    (when (overlay-get ov 'invisible)
-                                      (setq invisible-beg (min invisible-beg (overlay-start ov))
-                                            invisible-end (max invisible-end (overlay-end ov)))))
+                                  ;; Check overlays for invisibility boundaries
+                                  (let ((next-ov-change (next-overlay-change pos))
+                                        (prev-ov-change (previous-overlay-change pos)))
+                                    
+                                    ;; Update boundaries if overlay changes are closer
+                                    (when (< next-ov-change next-change)
+                                      (setq next-change next-ov-change))
+                                    (when (> prev-ov-change prev-change)
+                                      (setq prev-change prev-ov-change)))
 
-                                  ;; Now jump past the invisible region based on direction
+                                  ;; Jump in the appropriate direction
                                   (goto-char (if (eq direction 'backward)
-                                                 (max (point-min) (1- invisible-beg))
-                                               (min (point-max) (1+ invisible-end))))
+                                                 prev-change
+                                               next-change))
 
                                   ;; Rerun the motion for consistency
                                   (call-interactively func)))
@@ -630,4 +630,4 @@ This is a safety measure to prevent infinite loops."
 (define-key evilem-map "+" #'evilem-motion-next-line-first-non-blank)
 
 (provide 'evil-easymotion)
-;;; evil-easymotion.el ends here
+;;; evil-easymotion.el ends here