thing-after-point-utils.el 1.0

;;; thing-after-point-utils.el  --- more thing-at-point edit functions

;; Version: 1.0

;; Copyright (C) 2006, 2007 Andreas Roehler

;; Author: Andreas Roehler <andreas.roehler@xxxxxxxxxxxxx>

;; Keywords: convenience, lisp

;; This file is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.

;; This file is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.

;;; Commentary:

;; Information is given with thingatpt-utils-base.el

(require 'thingatpt-utils-base)



;;;###autoload
(defsubst list-afpt (&optional arg ispec) 
  "Returns list after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'list arg ispec))))

;;;###autoload
(defsubst bounds-of-list-afpt (&optional arg ispec) 
  "Returns border of list after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'list arg ispec))))

;;;###autoload
(defsubst list-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of list after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'list arg ispec))))

;;;###autoload
(defsubst list-afpt-end-position (&optional arg ispec) 
  "Returns end position of list after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'list arg ispec))))

;;;###autoload
(defsubst copy-list-afpt (&optional arg ispec) 
  "Returns a copy of list after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'list arg ispec))))

;;;###autoload
(defsubst separate-list-afpt (&optional arg ispec) 
  "Returns a copy of list after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'list arg ispec))))

;;;###autoload
(defsubst comment-list-afpt (&optional arg ispec) 
  "Returns a copy of list after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'list arg ispec))))

;;;###autoload
(defsubst doublequote-list-afpt (&optional arg ispec) 
  "Doublequotes list after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'list 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-list-afpt (&optional arg ispec) 
  "Singlequotes list after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'list 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-list-afpt (&optional arg ispec) 
  "Parentizes list after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'list 'parentize arg ispec))))

;;;###autoload
(defsubst brace-list-afpt (&optional arg ispec) 
  "Braces list after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'list 'brace arg ispec))))

;;;###autoload
(defsubst bracket-list-afpt (&optional arg ispec) 
  "Brackets list after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'list 'bracket arg ispec))))

;;;###autoload
(defsubst kill-list-afpt ()
  "Kills list after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'list))))

;;;###autoload
(defsubst forward-list-afpt (&optional arg ispec) 
  "Moves forward over list after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'list arg ispec)))
;;;###autoload
(defsubst symbol-afpt (&optional arg ispec) 
  "Returns symbol after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'symbol arg ispec))))

;;;###autoload
(defsubst bounds-of-symbol-afpt (&optional arg ispec) 
  "Returns border of symbol after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'symbol arg ispec))))

;;;###autoload
(defsubst symbol-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of symbol after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'symbol arg ispec))))

;;;###autoload
(defsubst symbol-afpt-end-position (&optional arg ispec) 
  "Returns end position of symbol after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'symbol arg ispec))))

;;;###autoload
(defsubst copy-symbol-afpt (&optional arg ispec) 
  "Returns a copy of symbol after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'symbol arg ispec))))

;;;###autoload
(defsubst separate-symbol-afpt (&optional arg ispec) 
  "Returns a copy of symbol after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'symbol arg ispec))))

;;;###autoload
(defsubst comment-symbol-afpt (&optional arg ispec) 
  "Returns a copy of symbol after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'symbol arg ispec))))

;;;###autoload
(defsubst doublequote-symbol-afpt (&optional arg ispec) 
  "Doublequotes symbol after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'symbol 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-symbol-afpt (&optional arg ispec) 
  "Singlequotes symbol after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'symbol 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-symbol-afpt (&optional arg ispec) 
  "Parentizes symbol after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'symbol 'parentize arg ispec))))

;;;###autoload
(defsubst brace-symbol-afpt (&optional arg ispec) 
  "Braces symbol after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'symbol 'brace arg ispec))))

;;;###autoload
(defsubst bracket-symbol-afpt (&optional arg ispec) 
  "Brackets symbol after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'symbol 'bracket arg ispec))))

;;;###autoload
(defsubst kill-symbol-afpt ()
  "Kills symbol after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'symbol))))

;;;###autoload
(defsubst forward-symbol-afpt (&optional arg ispec) 
  "Moves forward over symbol after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'symbol arg ispec)))
;;;###autoload
(defsubst word-afpt (&optional arg ispec) 
  "Returns word after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:word:]")
    (thatpt 'word arg ispec))))

;;;###autoload
(defsubst bounds-of-word-afpt (&optional arg ispec) 
  "Returns border of word after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:word:]")
     (thatpt-bounds 'word arg ispec))))

;;;###autoload
(defsubst word-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of word after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (thatpt-beginning 'word arg ispec))))

;;;###autoload
(defsubst word-afpt-end-position (&optional arg ispec) 
  "Returns end position of word after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (thatpt-end 'word arg ispec))))

;;;###autoload
(defsubst copy-word-afpt (&optional arg ispec) 
  "Returns a copy of word after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (thatpt-copy 'word arg ispec))))

;;;###autoload
(defsubst separate-word-afpt (&optional arg ispec) 
  "Returns a copy of word after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (thatpt-separate 'word arg ispec))))

;;;###autoload
(defsubst comment-word-afpt (&optional arg ispec) 
  "Returns a copy of word after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (thatpt-comment 'word arg ispec))))

;;;###autoload
(defsubst doublequote-word-afpt (&optional arg ispec) 
  "Doublequotes word after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (unless (eobp)
    (thatpt-delim 'word 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-word-afpt (&optional arg ispec) 
  "Singlequotes word after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (unless (eobp)
    (thatpt-delim 'word 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-word-afpt (&optional arg ispec) 
  "Parentizes word after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (unless (eobp)
    (thatpt-delim 'word 'parentize arg ispec))))

;;;###autoload
(defsubst brace-word-afpt (&optional arg ispec) 
  "Braces word after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (unless (eobp)
    (thatpt-delim 'word 'brace arg ispec))))

;;;###autoload
(defsubst bracket-word-afpt (&optional arg ispec) 
  "Brackets word after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (unless (eobp)
    (thatpt-delim 'word 'bracket arg ispec))))

;;;###autoload
(defsubst kill-word-afpt ()
  "Kills word after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:word:]")
      (thatpt-kill 'word))))

;;;###autoload
(defsubst forward-word-afpt (&optional arg ispec) 
  "Moves forward over word after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:word:]")
     ;; (forward-char 1)
  (thatpt-forward 'word arg ispec)))
;;;###autoload
(defsubst sexp-afpt (&optional arg ispec) 
  "Returns sexp after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'sexp arg ispec))))

;;;###autoload
(defsubst bounds-of-sexp-afpt (&optional arg ispec) 
  "Returns border of sexp after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'sexp arg ispec))))

;;;###autoload
(defsubst sexp-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of sexp after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'sexp arg ispec))))

;;;###autoload
(defsubst sexp-afpt-end-position (&optional arg ispec) 
  "Returns end position of sexp after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'sexp arg ispec))))

;;;###autoload
(defsubst copy-sexp-afpt (&optional arg ispec) 
  "Returns a copy of sexp after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'sexp arg ispec))))

;;;###autoload
(defsubst separate-sexp-afpt (&optional arg ispec) 
  "Returns a copy of sexp after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'sexp arg ispec))))

;;;###autoload
(defsubst comment-sexp-afpt (&optional arg ispec) 
  "Returns a copy of sexp after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'sexp arg ispec))))

;;;###autoload
(defsubst doublequote-sexp-afpt (&optional arg ispec) 
  "Doublequotes sexp after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'sexp 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-sexp-afpt (&optional arg ispec) 
  "Singlequotes sexp after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'sexp 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-sexp-afpt (&optional arg ispec) 
  "Parentizes sexp after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'sexp 'parentize arg ispec))))

;;;###autoload
(defsubst brace-sexp-afpt (&optional arg ispec) 
  "Braces sexp after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'sexp 'brace arg ispec))))

;;;###autoload
(defsubst bracket-sexp-afpt (&optional arg ispec) 
  "Brackets sexp after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'sexp 'bracket arg ispec))))

;;;###autoload
(defsubst kill-sexp-afpt ()
  "Kills sexp after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'sexp))))

;;;###autoload
(defsubst forward-sexp-afpt (&optional arg ispec) 
  "Moves forward over sexp after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'sexp arg ispec)))
;;;###autoload
(defsubst paragraph-afpt (&optional arg ispec) 
  "Returns paragraph after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'paragraph arg ispec))))

;;;###autoload
(defsubst bounds-of-paragraph-afpt (&optional arg ispec) 
  "Returns border of paragraph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'paragraph arg ispec))))

;;;###autoload
(defsubst paragraph-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of paragraph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'paragraph arg ispec))))

;;;###autoload
(defsubst paragraph-afpt-end-position (&optional arg ispec) 
  "Returns end position of paragraph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'paragraph arg ispec))))

;;;###autoload
(defsubst copy-paragraph-afpt (&optional arg ispec) 
  "Returns a copy of paragraph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'paragraph arg ispec))))

;;;###autoload
(defsubst separate-paragraph-afpt (&optional arg ispec) 
  "Returns a copy of paragraph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'paragraph arg ispec))))

;;;###autoload
(defsubst comment-paragraph-afpt (&optional arg ispec) 
  "Returns a copy of paragraph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'paragraph arg ispec))))

;;;###autoload
(defsubst doublequote-paragraph-afpt (&optional arg ispec) 
  "Doublequotes paragraph after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'paragraph 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-paragraph-afpt (&optional arg ispec) 
  "Singlequotes paragraph after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'paragraph 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-paragraph-afpt (&optional arg ispec) 
  "Parentizes paragraph after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'paragraph 'parentize arg ispec))))

;;;###autoload
(defsubst brace-paragraph-afpt (&optional arg ispec) 
  "Braces paragraph after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'paragraph 'brace arg ispec))))

;;;###autoload
(defsubst bracket-paragraph-afpt (&optional arg ispec) 
  "Brackets paragraph after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'paragraph 'bracket arg ispec))))

;;;###autoload
(defsubst kill-paragraph-afpt ()
  "Kills paragraph after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'paragraph))))

;;;###autoload
(defsubst forward-paragraph-afpt (&optional arg ispec) 
  "Moves forward over paragraph after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'paragraph arg ispec)))
;;;###autoload
(defsubst string-afpt (&optional arg ispec) 
  "Returns string after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'string arg ispec))))

;;;###autoload
(defsubst bounds-of-string-afpt (&optional arg ispec) 
  "Returns border of string after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'string arg ispec))))

;;;###autoload
(defsubst string-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of string after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'string arg ispec))))

;;;###autoload
(defsubst string-afpt-end-position (&optional arg ispec) 
  "Returns end position of string after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'string arg ispec))))

;;;###autoload
(defsubst copy-string-afpt (&optional arg ispec) 
  "Returns a copy of string after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'string arg ispec))))

;;;###autoload
(defsubst separate-string-afpt (&optional arg ispec) 
  "Returns a copy of string after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'string arg ispec))))

;;;###autoload
(defsubst comment-string-afpt (&optional arg ispec) 
  "Returns a copy of string after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'string arg ispec))))

;;;###autoload
(defsubst doublequote-string-afpt (&optional arg ispec) 
  "Doublequotes string after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'string 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-string-afpt (&optional arg ispec) 
  "Singlequotes string after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'string 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-string-afpt (&optional arg ispec) 
  "Parentizes string after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'string 'parentize arg ispec))))

;;;###autoload
(defsubst brace-string-afpt (&optional arg ispec) 
  "Braces string after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'string 'brace arg ispec))))

;;;###autoload
(defsubst bracket-string-afpt (&optional arg ispec) 
  "Brackets string after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'string 'bracket arg ispec))))

;;;###autoload
(defsubst kill-string-afpt ()
  "Kills string after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'string))))

;;;###autoload
(defsubst forward-string-afpt (&optional arg ispec) 
  "Moves forward over string after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'string arg ispec)))
;;;###autoload
(defsubst line-afpt (&optional arg ispec) 
  "Returns line after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'line arg ispec))))

;;;###autoload
(defsubst bounds-of-line-afpt (&optional arg ispec) 
  "Returns border of line after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'line arg ispec))))

;;;###autoload
(defsubst line-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of line after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'line arg ispec))))

;;;###autoload
(defsubst line-afpt-end-position (&optional arg ispec) 
  "Returns end position of line after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'line arg ispec))))

;;;###autoload
(defsubst copy-line-afpt (&optional arg ispec) 
  "Returns a copy of line after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'line arg ispec))))

;;;###autoload
(defsubst separate-line-afpt (&optional arg ispec) 
  "Returns a copy of line after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'line arg ispec))))

;;;###autoload
(defsubst comment-line-afpt (&optional arg ispec) 
  "Returns a copy of line after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'line arg ispec))))

;;;###autoload
(defsubst doublequote-line-afpt (&optional arg ispec) 
  "Doublequotes line after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'line 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-line-afpt (&optional arg ispec) 
  "Singlequotes line after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'line 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-line-afpt (&optional arg ispec) 
  "Parentizes line after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'line 'parentize arg ispec))))

;;;###autoload
(defsubst brace-line-afpt (&optional arg ispec) 
  "Braces line after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'line 'brace arg ispec))))

;;;###autoload
(defsubst bracket-line-afpt (&optional arg ispec) 
  "Brackets line after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'line 'bracket arg ispec))))

;;;###autoload
(defsubst kill-line-afpt ()
  "Kills line after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'line))))

;;;###autoload
(defsubst forward-line-afpt (&optional arg ispec) 
  "Moves forward over line after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'line arg ispec)))
;;;###autoload
(defsubst sentence-afpt (&optional arg ispec) 
  "Returns sentence after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'sentence arg ispec))))

;;;###autoload
(defsubst bounds-of-sentence-afpt (&optional arg ispec) 
  "Returns border of sentence after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'sentence arg ispec))))

;;;###autoload
(defsubst sentence-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of sentence after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'sentence arg ispec))))

;;;###autoload
(defsubst sentence-afpt-end-position (&optional arg ispec) 
  "Returns end position of sentence after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'sentence arg ispec))))

;;;###autoload
(defsubst copy-sentence-afpt (&optional arg ispec) 
  "Returns a copy of sentence after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'sentence arg ispec))))

;;;###autoload
(defsubst separate-sentence-afpt (&optional arg ispec) 
  "Returns a copy of sentence after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'sentence arg ispec))))

;;;###autoload
(defsubst comment-sentence-afpt (&optional arg ispec) 
  "Returns a copy of sentence after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'sentence arg ispec))))

;;;###autoload
(defsubst doublequote-sentence-afpt (&optional arg ispec) 
  "Doublequotes sentence after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'sentence 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-sentence-afpt (&optional arg ispec) 
  "Singlequotes sentence after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'sentence 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-sentence-afpt (&optional arg ispec) 
  "Parentizes sentence after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'sentence 'parentize arg ispec))))

;;;###autoload
(defsubst brace-sentence-afpt (&optional arg ispec) 
  "Braces sentence after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'sentence 'brace arg ispec))))

;;;###autoload
(defsubst bracket-sentence-afpt (&optional arg ispec) 
  "Brackets sentence after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'sentence 'bracket arg ispec))))

;;;###autoload
(defsubst kill-sentence-afpt ()
  "Kills sentence after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'sentence))))

;;;###autoload
(defsubst forward-sentence-afpt (&optional arg ispec) 
  "Moves forward over sentence after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'sentence arg ispec)))
;;;###autoload
(defsubst defun-afpt (&optional arg ispec) 
  "Returns defun after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'defun arg ispec))))

;;;###autoload
(defsubst bounds-of-defun-afpt (&optional arg ispec) 
  "Returns border of defun after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'defun arg ispec))))

;;;###autoload
(defsubst defun-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of defun after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'defun arg ispec))))

;;;###autoload
(defsubst defun-afpt-end-position (&optional arg ispec) 
  "Returns end position of defun after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'defun arg ispec))))

;;;###autoload
(defsubst copy-defun-afpt (&optional arg ispec) 
  "Returns a copy of defun after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'defun arg ispec))))

;;;###autoload
(defsubst separate-defun-afpt (&optional arg ispec) 
  "Returns a copy of defun after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'defun arg ispec))))

;;;###autoload
(defsubst comment-defun-afpt (&optional arg ispec) 
  "Returns a copy of defun after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'defun arg ispec))))

;;;###autoload
(defsubst doublequote-defun-afpt (&optional arg ispec) 
  "Doublequotes defun after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'defun 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-defun-afpt (&optional arg ispec) 
  "Singlequotes defun after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'defun 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-defun-afpt (&optional arg ispec) 
  "Parentizes defun after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'defun 'parentize arg ispec))))

;;;###autoload
(defsubst brace-defun-afpt (&optional arg ispec) 
  "Braces defun after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'defun 'brace arg ispec))))

;;;###autoload
(defsubst bracket-defun-afpt (&optional arg ispec) 
  "Brackets defun after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'defun 'bracket arg ispec))))

;;;###autoload
(defsubst kill-defun-afpt ()
  "Kills defun after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'defun))))

;;;###autoload
(defsubst forward-defun-afpt (&optional arg ispec) 
  "Moves forward over defun after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'defun arg ispec)))
;;;###autoload
(defsubst email-afpt (&optional arg ispec) 
  "Returns email after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'email arg ispec))))

;;;###autoload
(defsubst bounds-of-email-afpt (&optional arg ispec) 
  "Returns border of email after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'email arg ispec))))

;;;###autoload
(defsubst email-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of email after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'email arg ispec))))

;;;###autoload
(defsubst email-afpt-end-position (&optional arg ispec) 
  "Returns end position of email after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'email arg ispec))))

;;;###autoload
(defsubst copy-email-afpt (&optional arg ispec) 
  "Returns a copy of email after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'email arg ispec))))

;;;###autoload
(defsubst separate-email-afpt (&optional arg ispec) 
  "Returns a copy of email after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'email arg ispec))))

;;;###autoload
(defsubst comment-email-afpt (&optional arg ispec) 
  "Returns a copy of email after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'email arg ispec))))

;;;###autoload
(defsubst doublequote-email-afpt (&optional arg ispec) 
  "Doublequotes email after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'email 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-email-afpt (&optional arg ispec) 
  "Singlequotes email after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'email 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-email-afpt (&optional arg ispec) 
  "Parentizes email after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'email 'parentize arg ispec))))

;;;###autoload
(defsubst brace-email-afpt (&optional arg ispec) 
  "Braces email after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'email 'brace arg ispec))))

;;;###autoload
(defsubst bracket-email-afpt (&optional arg ispec) 
  "Brackets email after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'email 'bracket arg ispec))))

;;;###autoload
(defsubst kill-email-afpt ()
  "Kills email after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'email))))

;;;###autoload
(defsubst forward-email-afpt (&optional arg ispec) 
  "Moves forward over email after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'email arg ispec)))
;;;###autoload
(defsubst csv-afpt (&optional arg ispec) 
  "Returns csv after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'csv arg ispec))))

;;;###autoload
(defsubst bounds-of-csv-afpt (&optional arg ispec) 
  "Returns border of csv after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'csv arg ispec))))

;;;###autoload
(defsubst csv-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of csv after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'csv arg ispec))))

;;;###autoload
(defsubst csv-afpt-end-position (&optional arg ispec) 
  "Returns end position of csv after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'csv arg ispec))))

;;;###autoload
(defsubst copy-csv-afpt (&optional arg ispec) 
  "Returns a copy of csv after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'csv arg ispec))))

;;;###autoload
(defsubst separate-csv-afpt (&optional arg ispec) 
  "Returns a copy of csv after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'csv arg ispec))))

;;;###autoload
(defsubst comment-csv-afpt (&optional arg ispec) 
  "Returns a copy of csv after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'csv arg ispec))))

;;;###autoload
(defsubst doublequote-csv-afpt (&optional arg ispec) 
  "Doublequotes csv after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'csv 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-csv-afpt (&optional arg ispec) 
  "Singlequotes csv after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'csv 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-csv-afpt (&optional arg ispec) 
  "Parentizes csv after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'csv 'parentize arg ispec))))

;;;###autoload
(defsubst brace-csv-afpt (&optional arg ispec) 
  "Braces csv after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'csv 'brace arg ispec))))

;;;###autoload
(defsubst bracket-csv-afpt (&optional arg ispec) 
  "Brackets csv after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'csv 'bracket arg ispec))))

;;;###autoload
(defsubst kill-csv-afpt ()
  "Kills csv after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'csv))))

;;;###autoload
(defsubst forward-csv-afpt (&optional arg ispec) 
  "Moves forward over csv after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'csv arg ispec)))
;;;###autoload
(defsubst phone-afpt (&optional arg ispec) 
  "Returns phone after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'phone arg ispec))))

;;;###autoload
(defsubst bounds-of-phone-afpt (&optional arg ispec) 
  "Returns border of phone after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'phone arg ispec))))

;;;###autoload
(defsubst phone-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of phone after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'phone arg ispec))))

;;;###autoload
(defsubst phone-afpt-end-position (&optional arg ispec) 
  "Returns end position of phone after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'phone arg ispec))))

;;;###autoload
(defsubst copy-phone-afpt (&optional arg ispec) 
  "Returns a copy of phone after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'phone arg ispec))))

;;;###autoload
(defsubst separate-phone-afpt (&optional arg ispec) 
  "Returns a copy of phone after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'phone arg ispec))))

;;;###autoload
(defsubst comment-phone-afpt (&optional arg ispec) 
  "Returns a copy of phone after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'phone arg ispec))))

;;;###autoload
(defsubst doublequote-phone-afpt (&optional arg ispec) 
  "Doublequotes phone after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'phone 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-phone-afpt (&optional arg ispec) 
  "Singlequotes phone after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'phone 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-phone-afpt (&optional arg ispec) 
  "Parentizes phone after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'phone 'parentize arg ispec))))

;;;###autoload
(defsubst brace-phone-afpt (&optional arg ispec) 
  "Braces phone after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'phone 'brace arg ispec))))

;;;###autoload
(defsubst bracket-phone-afpt (&optional arg ispec) 
  "Brackets phone after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'phone 'bracket arg ispec))))

;;;###autoload
(defsubst kill-phone-afpt ()
  "Kills phone after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'phone))))

;;;###autoload
(defsubst forward-phone-afpt (&optional arg ispec) 
  "Moves forward over phone after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'phone arg ispec)))
;;;###autoload
(defsubst ml-text-afpt (&optional arg ispec) 
  "Returns ml-text after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'ml-text arg ispec))))

;;;###autoload
(defsubst bounds-of-ml-text-afpt (&optional arg ispec) 
  "Returns border of ml-text after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'ml-text arg ispec))))

;;;###autoload
(defsubst ml-text-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of ml-text after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'ml-text arg ispec))))

;;;###autoload
(defsubst ml-text-afpt-end-position (&optional arg ispec) 
  "Returns end position of ml-text after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'ml-text arg ispec))))

;;;###autoload
(defsubst copy-ml-text-afpt (&optional arg ispec) 
  "Returns a copy of ml-text after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'ml-text arg ispec))))

;;;###autoload
(defsubst separate-ml-text-afpt (&optional arg ispec) 
  "Returns a copy of ml-text after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'ml-text arg ispec))))

;;;###autoload
(defsubst comment-ml-text-afpt (&optional arg ispec) 
  "Returns a copy of ml-text after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'ml-text arg ispec))))

;;;###autoload
(defsubst doublequote-ml-text-afpt (&optional arg ispec) 
  "Doublequotes ml-text after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'ml-text 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-ml-text-afpt (&optional arg ispec) 
  "Singlequotes ml-text after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'ml-text 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-ml-text-afpt (&optional arg ispec) 
  "Parentizes ml-text after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'ml-text 'parentize arg ispec))))

;;;###autoload
(defsubst brace-ml-text-afpt (&optional arg ispec) 
  "Braces ml-text after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'ml-text 'brace arg ispec))))

;;;###autoload
(defsubst bracket-ml-text-afpt (&optional arg ispec) 
  "Brackets ml-text after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'ml-text 'bracket arg ispec))))

;;;###autoload
(defsubst kill-ml-text-afpt ()
  "Kills ml-text after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'ml-text))))

;;;###autoload
(defsubst forward-ml-text-afpt (&optional arg ispec) 
  "Moves forward over ml-text after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'ml-text arg ispec)))
;;;###autoload
(defsubst filename-afpt (&optional arg ispec) 
  "Returns filename after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'filename arg ispec))))

;;;###autoload
(defsubst bounds-of-filename-afpt (&optional arg ispec) 
  "Returns border of filename after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'filename arg ispec))))

;;;###autoload
(defsubst filename-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of filename after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'filename arg ispec))))

;;;###autoload
(defsubst filename-afpt-end-position (&optional arg ispec) 
  "Returns end position of filename after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'filename arg ispec))))

;;;###autoload
(defsubst copy-filename-afpt (&optional arg ispec) 
  "Returns a copy of filename after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'filename arg ispec))))

;;;###autoload
(defsubst separate-filename-afpt (&optional arg ispec) 
  "Returns a copy of filename after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'filename arg ispec))))

;;;###autoload
(defsubst comment-filename-afpt (&optional arg ispec) 
  "Returns a copy of filename after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'filename arg ispec))))

;;;###autoload
(defsubst doublequote-filename-afpt (&optional arg ispec) 
  "Doublequotes filename after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'filename 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-filename-afpt (&optional arg ispec) 
  "Singlequotes filename after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'filename 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-filename-afpt (&optional arg ispec) 
  "Parentizes filename after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'filename 'parentize arg ispec))))

;;;###autoload
(defsubst brace-filename-afpt (&optional arg ispec) 
  "Braces filename after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'filename 'brace arg ispec))))

;;;###autoload
(defsubst bracket-filename-afpt (&optional arg ispec) 
  "Brackets filename after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'filename 'bracket arg ispec))))

;;;###autoload
(defsubst kill-filename-afpt ()
  "Kills filename after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'filename))))

;;;###autoload
(defsubst forward-filename-afpt (&optional arg ispec) 
  "Moves forward over filename after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'filename arg ispec)))
;;;###autoload
(defsubst url-afpt (&optional arg ispec) 
  "Returns url after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'url arg ispec))))

;;;###autoload
(defsubst bounds-of-url-afpt (&optional arg ispec) 
  "Returns border of url after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'url arg ispec))))

;;;###autoload
(defsubst url-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of url after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'url arg ispec))))

;;;###autoload
(defsubst url-afpt-end-position (&optional arg ispec) 
  "Returns end position of url after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'url arg ispec))))

;;;###autoload
(defsubst copy-url-afpt (&optional arg ispec) 
  "Returns a copy of url after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'url arg ispec))))

;;;###autoload
(defsubst separate-url-afpt (&optional arg ispec) 
  "Returns a copy of url after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'url arg ispec))))

;;;###autoload
(defsubst comment-url-afpt (&optional arg ispec) 
  "Returns a copy of url after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'url arg ispec))))

;;;###autoload
(defsubst doublequote-url-afpt (&optional arg ispec) 
  "Doublequotes url after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'url 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-url-afpt (&optional arg ispec) 
  "Singlequotes url after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'url 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-url-afpt (&optional arg ispec) 
  "Parentizes url after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'url 'parentize arg ispec))))

;;;###autoload
(defsubst brace-url-afpt (&optional arg ispec) 
  "Braces url after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'url 'brace arg ispec))))

;;;###autoload
(defsubst bracket-url-afpt (&optional arg ispec) 
  "Brackets url after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'url 'bracket arg ispec))))

;;;###autoload
(defsubst kill-url-afpt ()
  "Kills url after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'url))))

;;;###autoload
(defsubst forward-url-afpt (&optional arg ispec) 
  "Moves forward over url after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'url arg ispec)))
;;;###autoload
(defsubst number-afpt (&optional arg ispec) 
  "Returns number after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'number arg ispec))))

;;;###autoload
(defsubst bounds-of-number-afpt (&optional arg ispec) 
  "Returns border of number after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'number arg ispec))))

;;;###autoload
(defsubst number-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of number after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'number arg ispec))))

;;;###autoload
(defsubst number-afpt-end-position (&optional arg ispec) 
  "Returns end position of number after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'number arg ispec))))

;;;###autoload
(defsubst copy-number-afpt (&optional arg ispec) 
  "Returns a copy of number after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'number arg ispec))))

;;;###autoload
(defsubst separate-number-afpt (&optional arg ispec) 
  "Returns a copy of number after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'number arg ispec))))

;;;###autoload
(defsubst comment-number-afpt (&optional arg ispec) 
  "Returns a copy of number after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'number arg ispec))))

;;;###autoload
(defsubst doublequote-number-afpt (&optional arg ispec) 
  "Doublequotes number after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'number 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-number-afpt (&optional arg ispec) 
  "Singlequotes number after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'number 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-number-afpt (&optional arg ispec) 
  "Parentizes number after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'number 'parentize arg ispec))))

;;;###autoload
(defsubst brace-number-afpt (&optional arg ispec) 
  "Braces number after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'number 'brace arg ispec))))

;;;###autoload
(defsubst bracket-number-afpt (&optional arg ispec) 
  "Brackets number after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'number 'bracket arg ispec))))

;;;###autoload
(defsubst kill-number-afpt ()
  "Kills number after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'number))))

;;;###autoload
(defsubst forward-number-afpt (&optional arg ispec) 
  "Moves forward over number after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'number arg ispec)))
;;;###autoload
(defsubst float-afpt (&optional arg ispec) 
  "Returns float after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'float arg ispec))))

;;;###autoload
(defsubst bounds-of-float-afpt (&optional arg ispec) 
  "Returns border of float after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'float arg ispec))))

;;;###autoload
(defsubst float-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of float after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'float arg ispec))))

;;;###autoload
(defsubst float-afpt-end-position (&optional arg ispec) 
  "Returns end position of float after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'float arg ispec))))

;;;###autoload
(defsubst copy-float-afpt (&optional arg ispec) 
  "Returns a copy of float after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'float arg ispec))))

;;;###autoload
(defsubst separate-float-afpt (&optional arg ispec) 
  "Returns a copy of float after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'float arg ispec))))

;;;###autoload
(defsubst comment-float-afpt (&optional arg ispec) 
  "Returns a copy of float after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'float arg ispec))))

;;;###autoload
(defsubst doublequote-float-afpt (&optional arg ispec) 
  "Doublequotes float after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'float 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-float-afpt (&optional arg ispec) 
  "Singlequotes float after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'float 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-float-afpt (&optional arg ispec) 
  "Parentizes float after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'float 'parentize arg ispec))))

;;;###autoload
(defsubst brace-float-afpt (&optional arg ispec) 
  "Braces float after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'float 'brace arg ispec))))

;;;###autoload
(defsubst bracket-float-afpt (&optional arg ispec) 
  "Brackets float after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'float 'bracket arg ispec))))

;;;###autoload
(defsubst kill-float-afpt ()
  "Kills float after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'float))))

;;;###autoload
(defsubst forward-float-afpt (&optional arg ispec) 
  "Moves forward over float after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'float arg ispec)))
;;;###autoload
(defsubst page-afpt (&optional arg ispec) 
  "Returns page after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'page arg ispec))))

;;;###autoload
(defsubst bounds-of-page-afpt (&optional arg ispec) 
  "Returns border of page after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'page arg ispec))))

;;;###autoload
(defsubst page-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of page after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'page arg ispec))))

;;;###autoload
(defsubst page-afpt-end-position (&optional arg ispec) 
  "Returns end position of page after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'page arg ispec))))

;;;###autoload
(defsubst copy-page-afpt (&optional arg ispec) 
  "Returns a copy of page after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'page arg ispec))))

;;;###autoload
(defsubst separate-page-afpt (&optional arg ispec) 
  "Returns a copy of page after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'page arg ispec))))

;;;###autoload
(defsubst comment-page-afpt (&optional arg ispec) 
  "Returns a copy of page after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'page arg ispec))))

;;;###autoload
(defsubst doublequote-page-afpt (&optional arg ispec) 
  "Doublequotes page after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'page 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-page-afpt (&optional arg ispec) 
  "Singlequotes page after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'page 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-page-afpt (&optional arg ispec) 
  "Parentizes page after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'page 'parentize arg ispec))))

;;;###autoload
(defsubst brace-page-afpt (&optional arg ispec) 
  "Braces page after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'page 'brace arg ispec))))

;;;###autoload
(defsubst bracket-page-afpt (&optional arg ispec) 
  "Brackets page after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'page 'bracket arg ispec))))

;;;###autoload
(defsubst kill-page-afpt ()
  "Kills page after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'page))))

;;;###autoload
(defsubst forward-page-afpt (&optional arg ispec) 
  "Moves forward over page after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'page arg ispec)))
;;;###autoload
(defsubst whitespace-afpt (&optional arg ispec) 
  "Returns whitespace after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
     (thatpt 'whitespace arg ispec))))

;;;###autoload
(defsubst bounds-of-whitespace-afpt (&optional arg ispec) 
  "Returns border of whitespace after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
      (thatpt-bounds 'whitespace arg ispec))))

;;;###autoload
(defsubst whitespace-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of whitespace after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-beginning 'whitespace arg ispec))))

;;;###autoload
(defsubst whitespace-afpt-end-position (&optional arg ispec) 
  "Returns end position of whitespace after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-end 'whitespace arg ispec))))

;;;###autoload
(defsubst copy-whitespace-afpt (&optional arg ispec) 
  "Returns a copy of whitespace after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-copy 'whitespace arg ispec))))

;;;###autoload
(defsubst separate-whitespace-afpt (&optional arg ispec) 
  "Returns a copy of whitespace after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-separate 'whitespace arg ispec))))

;;;###autoload
(defsubst comment-whitespace-afpt (&optional arg ispec) 
  "Returns a copy of whitespace after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-comment 'whitespace arg ispec))))

;;;###autoload
(defsubst doublequote-whitespace-afpt (&optional arg ispec) 
  "Doublequotes whitespace after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'whitespace 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-whitespace-afpt (&optional arg ispec) 
  "Singlequotes whitespace after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'whitespace 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-whitespace-afpt (&optional arg ispec) 
  "Parentizes whitespace after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'whitespace 'parentize arg ispec))))

;;;###autoload
(defsubst brace-whitespace-afpt (&optional arg ispec) 
  "Braces whitespace after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'whitespace 'brace arg ispec))))

;;;###autoload
(defsubst bracket-whitespace-afpt (&optional arg ispec) 
  "Brackets whitespace after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (unless (eobp)
    (thatpt-delim 'whitespace 'bracket arg ispec))))

;;;###autoload
(defsubst kill-whitespace-afpt ()
  "Kills whitespace after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward " \t\n\r\f")
       (thatpt-kill 'whitespace))))

;;;###autoload
(defsubst forward-whitespace-afpt (&optional arg ispec) 
  "Moves forward over whitespace after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward " \t\n\r\f")
      ;; (forward-char 1)
  (thatpt-forward 'whitespace arg ispec)))
;;;###autoload
(defsubst alnum-afpt (&optional arg ispec) 
  "Returns alnum after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
    (thatpt 'alnum arg ispec))))

;;;###autoload
(defsubst bounds-of-alnum-afpt (&optional arg ispec) 
  "Returns border of alnum after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
     (thatpt-bounds 'alnum arg ispec))))

;;;###autoload
(defsubst alnum-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of alnum after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (thatpt-beginning 'alnum arg ispec))))

;;;###autoload
(defsubst alnum-afpt-end-position (&optional arg ispec) 
  "Returns end position of alnum after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (thatpt-end 'alnum arg ispec))))

;;;###autoload
(defsubst copy-alnum-afpt (&optional arg ispec) 
  "Returns a copy of alnum after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (thatpt-copy 'alnum arg ispec))))

;;;###autoload
(defsubst separate-alnum-afpt (&optional arg ispec) 
  "Returns a copy of alnum after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (thatpt-separate 'alnum arg ispec))))

;;;###autoload
(defsubst comment-alnum-afpt (&optional arg ispec) 
  "Returns a copy of alnum after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (thatpt-comment 'alnum arg ispec))))

;;;###autoload
(defsubst doublequote-alnum-afpt (&optional arg ispec) 
  "Doublequotes alnum after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (unless (eobp)
    (thatpt-delim 'alnum 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-alnum-afpt (&optional arg ispec) 
  "Singlequotes alnum after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (unless (eobp)
    (thatpt-delim 'alnum 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-alnum-afpt (&optional arg ispec) 
  "Parentizes alnum after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (unless (eobp)
    (thatpt-delim 'alnum 'parentize arg ispec))))

;;;###autoload
(defsubst brace-alnum-afpt (&optional arg ispec) 
  "Braces alnum after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (unless (eobp)
    (thatpt-delim 'alnum 'brace arg ispec))))

;;;###autoload
(defsubst bracket-alnum-afpt (&optional arg ispec) 
  "Brackets alnum after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (unless (eobp)
    (thatpt-delim 'alnum 'bracket arg ispec))))

;;;###autoload
(defsubst kill-alnum-afpt ()
  "Kills alnum after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alnum:]")
      (thatpt-kill 'alnum))))

;;;###autoload
(defsubst forward-alnum-afpt (&optional arg ispec) 
  "Moves forward over alnum after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:alnum:]")
     ;; (forward-char 1)
  (thatpt-forward 'alnum arg ispec)))
;;;###autoload
(defsubst alpha-afpt (&optional arg ispec) 
  "Returns alpha after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
    (thatpt 'alpha arg ispec))))

;;;###autoload
(defsubst bounds-of-alpha-afpt (&optional arg ispec) 
  "Returns border of alpha after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
     (thatpt-bounds 'alpha arg ispec))))

;;;###autoload
(defsubst alpha-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of alpha after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (thatpt-beginning 'alpha arg ispec))))

;;;###autoload
(defsubst alpha-afpt-end-position (&optional arg ispec) 
  "Returns end position of alpha after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (thatpt-end 'alpha arg ispec))))

;;;###autoload
(defsubst copy-alpha-afpt (&optional arg ispec) 
  "Returns a copy of alpha after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (thatpt-copy 'alpha arg ispec))))

;;;###autoload
(defsubst separate-alpha-afpt (&optional arg ispec) 
  "Returns a copy of alpha after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (thatpt-separate 'alpha arg ispec))))

;;;###autoload
(defsubst comment-alpha-afpt (&optional arg ispec) 
  "Returns a copy of alpha after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (thatpt-comment 'alpha arg ispec))))

;;;###autoload
(defsubst doublequote-alpha-afpt (&optional arg ispec) 
  "Doublequotes alpha after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (unless (eobp)
    (thatpt-delim 'alpha 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-alpha-afpt (&optional arg ispec) 
  "Singlequotes alpha after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (unless (eobp)
    (thatpt-delim 'alpha 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-alpha-afpt (&optional arg ispec) 
  "Parentizes alpha after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (unless (eobp)
    (thatpt-delim 'alpha 'parentize arg ispec))))

;;;###autoload
(defsubst brace-alpha-afpt (&optional arg ispec) 
  "Braces alpha after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (unless (eobp)
    (thatpt-delim 'alpha 'brace arg ispec))))

;;;###autoload
(defsubst bracket-alpha-afpt (&optional arg ispec) 
  "Brackets alpha after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (unless (eobp)
    (thatpt-delim 'alpha 'bracket arg ispec))))

;;;###autoload
(defsubst kill-alpha-afpt ()
  "Kills alpha after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:alpha:]")
      (thatpt-kill 'alpha))))

;;;###autoload
(defsubst forward-alpha-afpt (&optional arg ispec) 
  "Moves forward over alpha after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:alpha:]")
     ;; (forward-char 1)
  (thatpt-forward 'alpha arg ispec)))
;;;###autoload
(defsubst ascii-afpt (&optional arg ispec) 
  "Returns ascii after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
    (thatpt 'ascii arg ispec))))

;;;###autoload
(defsubst bounds-of-ascii-afpt (&optional arg ispec) 
  "Returns border of ascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
     (thatpt-bounds 'ascii arg ispec))))

;;;###autoload
(defsubst ascii-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of ascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (thatpt-beginning 'ascii arg ispec))))

;;;###autoload
(defsubst ascii-afpt-end-position (&optional arg ispec) 
  "Returns end position of ascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (thatpt-end 'ascii arg ispec))))

;;;###autoload
(defsubst copy-ascii-afpt (&optional arg ispec) 
  "Returns a copy of ascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (thatpt-copy 'ascii arg ispec))))

;;;###autoload
(defsubst separate-ascii-afpt (&optional arg ispec) 
  "Returns a copy of ascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (thatpt-separate 'ascii arg ispec))))

;;;###autoload
(defsubst comment-ascii-afpt (&optional arg ispec) 
  "Returns a copy of ascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (thatpt-comment 'ascii arg ispec))))

;;;###autoload
(defsubst doublequote-ascii-afpt (&optional arg ispec) 
  "Doublequotes ascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (unless (eobp)
    (thatpt-delim 'ascii 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-ascii-afpt (&optional arg ispec) 
  "Singlequotes ascii after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (unless (eobp)
    (thatpt-delim 'ascii 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-ascii-afpt (&optional arg ispec) 
  "Parentizes ascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (unless (eobp)
    (thatpt-delim 'ascii 'parentize arg ispec))))

;;;###autoload
(defsubst brace-ascii-afpt (&optional arg ispec) 
  "Braces ascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (unless (eobp)
    (thatpt-delim 'ascii 'brace arg ispec))))

;;;###autoload
(defsubst bracket-ascii-afpt (&optional arg ispec) 
  "Brackets ascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (unless (eobp)
    (thatpt-delim 'ascii 'bracket arg ispec))))

;;;###autoload
(defsubst kill-ascii-afpt ()
  "Kills ascii after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:ascii:]")
      (thatpt-kill 'ascii))))

;;;###autoload
(defsubst forward-ascii-afpt (&optional arg ispec) 
  "Moves forward over ascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:ascii:]")
     ;; (forward-char 1)
  (thatpt-forward 'ascii arg ispec)))
;;;###autoload
(defsubst blank-afpt (&optional arg ispec) 
  "Returns blank after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
    (thatpt 'blank arg ispec))))

;;;###autoload
(defsubst bounds-of-blank-afpt (&optional arg ispec) 
  "Returns border of blank after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
     (thatpt-bounds 'blank arg ispec))))

;;;###autoload
(defsubst blank-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of blank after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (thatpt-beginning 'blank arg ispec))))

;;;###autoload
(defsubst blank-afpt-end-position (&optional arg ispec) 
  "Returns end position of blank after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (thatpt-end 'blank arg ispec))))

;;;###autoload
(defsubst copy-blank-afpt (&optional arg ispec) 
  "Returns a copy of blank after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (thatpt-copy 'blank arg ispec))))

;;;###autoload
(defsubst separate-blank-afpt (&optional arg ispec) 
  "Returns a copy of blank after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (thatpt-separate 'blank arg ispec))))

;;;###autoload
(defsubst comment-blank-afpt (&optional arg ispec) 
  "Returns a copy of blank after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (thatpt-comment 'blank arg ispec))))

;;;###autoload
(defsubst doublequote-blank-afpt (&optional arg ispec) 
  "Doublequotes blank after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (unless (eobp)
    (thatpt-delim 'blank 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-blank-afpt (&optional arg ispec) 
  "Singlequotes blank after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (unless (eobp)
    (thatpt-delim 'blank 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-blank-afpt (&optional arg ispec) 
  "Parentizes blank after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (unless (eobp)
    (thatpt-delim 'blank 'parentize arg ispec))))

;;;###autoload
(defsubst brace-blank-afpt (&optional arg ispec) 
  "Braces blank after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (unless (eobp)
    (thatpt-delim 'blank 'brace arg ispec))))

;;;###autoload
(defsubst bracket-blank-afpt (&optional arg ispec) 
  "Brackets blank after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (unless (eobp)
    (thatpt-delim 'blank 'bracket arg ispec))))

;;;###autoload
(defsubst kill-blank-afpt ()
  "Kills blank after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:blank:]")
      (thatpt-kill 'blank))))

;;;###autoload
(defsubst forward-blank-afpt (&optional arg ispec) 
  "Moves forward over blank after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:blank:]")
     ;; (forward-char 1)
  (thatpt-forward 'blank arg ispec)))
;;;###autoload
(defsubst cntrl-afpt (&optional arg ispec) 
  "Returns cntrl after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
    (thatpt 'cntrl arg ispec))))

;;;###autoload
(defsubst bounds-of-cntrl-afpt (&optional arg ispec) 
  "Returns border of cntrl after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
     (thatpt-bounds 'cntrl arg ispec))))

;;;###autoload
(defsubst cntrl-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of cntrl after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (thatpt-beginning 'cntrl arg ispec))))

;;;###autoload
(defsubst cntrl-afpt-end-position (&optional arg ispec) 
  "Returns end position of cntrl after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (thatpt-end 'cntrl arg ispec))))

;;;###autoload
(defsubst copy-cntrl-afpt (&optional arg ispec) 
  "Returns a copy of cntrl after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (thatpt-copy 'cntrl arg ispec))))

;;;###autoload
(defsubst separate-cntrl-afpt (&optional arg ispec) 
  "Returns a copy of cntrl after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (thatpt-separate 'cntrl arg ispec))))

;;;###autoload
(defsubst comment-cntrl-afpt (&optional arg ispec) 
  "Returns a copy of cntrl after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (thatpt-comment 'cntrl arg ispec))))

;;;###autoload
(defsubst doublequote-cntrl-afpt (&optional arg ispec) 
  "Doublequotes cntrl after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (unless (eobp)
    (thatpt-delim 'cntrl 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-cntrl-afpt (&optional arg ispec) 
  "Singlequotes cntrl after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (unless (eobp)
    (thatpt-delim 'cntrl 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-cntrl-afpt (&optional arg ispec) 
  "Parentizes cntrl after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (unless (eobp)
    (thatpt-delim 'cntrl 'parentize arg ispec))))

;;;###autoload
(defsubst brace-cntrl-afpt (&optional arg ispec) 
  "Braces cntrl after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (unless (eobp)
    (thatpt-delim 'cntrl 'brace arg ispec))))

;;;###autoload
(defsubst bracket-cntrl-afpt (&optional arg ispec) 
  "Brackets cntrl after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (unless (eobp)
    (thatpt-delim 'cntrl 'bracket arg ispec))))

;;;###autoload
(defsubst kill-cntrl-afpt ()
  "Kills cntrl after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:cntrl:]")
      (thatpt-kill 'cntrl))))

;;;###autoload
(defsubst forward-cntrl-afpt (&optional arg ispec) 
  "Moves forward over cntrl after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:cntrl:]")
     ;; (forward-char 1)
  (thatpt-forward 'cntrl arg ispec)))
;;;###autoload
(defsubst digit-afpt (&optional arg ispec) 
  "Returns digit after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
    (thatpt 'digit arg ispec))))

;;;###autoload
(defsubst bounds-of-digit-afpt (&optional arg ispec) 
  "Returns border of digit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
     (thatpt-bounds 'digit arg ispec))))

;;;###autoload
(defsubst digit-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of digit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (thatpt-beginning 'digit arg ispec))))

;;;###autoload
(defsubst digit-afpt-end-position (&optional arg ispec) 
  "Returns end position of digit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (thatpt-end 'digit arg ispec))))

;;;###autoload
(defsubst copy-digit-afpt (&optional arg ispec) 
  "Returns a copy of digit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (thatpt-copy 'digit arg ispec))))

;;;###autoload
(defsubst separate-digit-afpt (&optional arg ispec) 
  "Returns a copy of digit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (thatpt-separate 'digit arg ispec))))

;;;###autoload
(defsubst comment-digit-afpt (&optional arg ispec) 
  "Returns a copy of digit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (thatpt-comment 'digit arg ispec))))

;;;###autoload
(defsubst doublequote-digit-afpt (&optional arg ispec) 
  "Doublequotes digit after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (unless (eobp)
    (thatpt-delim 'digit 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-digit-afpt (&optional arg ispec) 
  "Singlequotes digit after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (unless (eobp)
    (thatpt-delim 'digit 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-digit-afpt (&optional arg ispec) 
  "Parentizes digit after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (unless (eobp)
    (thatpt-delim 'digit 'parentize arg ispec))))

;;;###autoload
(defsubst brace-digit-afpt (&optional arg ispec) 
  "Braces digit after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (unless (eobp)
    (thatpt-delim 'digit 'brace arg ispec))))

;;;###autoload
(defsubst bracket-digit-afpt (&optional arg ispec) 
  "Brackets digit after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (unless (eobp)
    (thatpt-delim 'digit 'bracket arg ispec))))

;;;###autoload
(defsubst kill-digit-afpt ()
  "Kills digit after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:digit:]")
      (thatpt-kill 'digit))))

;;;###autoload
(defsubst forward-digit-afpt (&optional arg ispec) 
  "Moves forward over digit after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:digit:]")
     ;; (forward-char 1)
  (thatpt-forward 'digit arg ispec)))
;;;###autoload
(defsubst graph-afpt (&optional arg ispec) 
  "Returns graph after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
    (thatpt 'graph arg ispec))))

;;;###autoload
(defsubst bounds-of-graph-afpt (&optional arg ispec) 
  "Returns border of graph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
     (thatpt-bounds 'graph arg ispec))))

;;;###autoload
(defsubst graph-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of graph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (thatpt-beginning 'graph arg ispec))))

;;;###autoload
(defsubst graph-afpt-end-position (&optional arg ispec) 
  "Returns end position of graph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (thatpt-end 'graph arg ispec))))

;;;###autoload
(defsubst copy-graph-afpt (&optional arg ispec) 
  "Returns a copy of graph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (thatpt-copy 'graph arg ispec))))

;;;###autoload
(defsubst separate-graph-afpt (&optional arg ispec) 
  "Returns a copy of graph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (thatpt-separate 'graph arg ispec))))

;;;###autoload
(defsubst comment-graph-afpt (&optional arg ispec) 
  "Returns a copy of graph after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (thatpt-comment 'graph arg ispec))))

;;;###autoload
(defsubst doublequote-graph-afpt (&optional arg ispec) 
  "Doublequotes graph after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (unless (eobp)
    (thatpt-delim 'graph 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-graph-afpt (&optional arg ispec) 
  "Singlequotes graph after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (unless (eobp)
    (thatpt-delim 'graph 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-graph-afpt (&optional arg ispec) 
  "Parentizes graph after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (unless (eobp)
    (thatpt-delim 'graph 'parentize arg ispec))))

;;;###autoload
(defsubst brace-graph-afpt (&optional arg ispec) 
  "Braces graph after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (unless (eobp)
    (thatpt-delim 'graph 'brace arg ispec))))

;;;###autoload
(defsubst bracket-graph-afpt (&optional arg ispec) 
  "Brackets graph after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (unless (eobp)
    (thatpt-delim 'graph 'bracket arg ispec))))

;;;###autoload
(defsubst kill-graph-afpt ()
  "Kills graph after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:graph:]")
      (thatpt-kill 'graph))))

;;;###autoload
(defsubst forward-graph-afpt (&optional arg ispec) 
  "Moves forward over graph after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:graph:]")
     ;; (forward-char 1)
  (thatpt-forward 'graph arg ispec)))
;;;###autoload
(defsubst lower-afpt (&optional arg ispec) 
  "Returns lower after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
    (thatpt 'lower arg ispec))))

;;;###autoload
(defsubst bounds-of-lower-afpt (&optional arg ispec) 
  "Returns border of lower after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
     (thatpt-bounds 'lower arg ispec))))

;;;###autoload
(defsubst lower-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of lower after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (thatpt-beginning 'lower arg ispec))))

;;;###autoload
(defsubst lower-afpt-end-position (&optional arg ispec) 
  "Returns end position of lower after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (thatpt-end 'lower arg ispec))))

;;;###autoload
(defsubst copy-lower-afpt (&optional arg ispec) 
  "Returns a copy of lower after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (thatpt-copy 'lower arg ispec))))

;;;###autoload
(defsubst separate-lower-afpt (&optional arg ispec) 
  "Returns a copy of lower after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (thatpt-separate 'lower arg ispec))))

;;;###autoload
(defsubst comment-lower-afpt (&optional arg ispec) 
  "Returns a copy of lower after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (thatpt-comment 'lower arg ispec))))

;;;###autoload
(defsubst doublequote-lower-afpt (&optional arg ispec) 
  "Doublequotes lower after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (unless (eobp)
    (thatpt-delim 'lower 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-lower-afpt (&optional arg ispec) 
  "Singlequotes lower after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (unless (eobp)
    (thatpt-delim 'lower 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-lower-afpt (&optional arg ispec) 
  "Parentizes lower after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (unless (eobp)
    (thatpt-delim 'lower 'parentize arg ispec))))

;;;###autoload
(defsubst brace-lower-afpt (&optional arg ispec) 
  "Braces lower after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (unless (eobp)
    (thatpt-delim 'lower 'brace arg ispec))))

;;;###autoload
(defsubst bracket-lower-afpt (&optional arg ispec) 
  "Brackets lower after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (unless (eobp)
    (thatpt-delim 'lower 'bracket arg ispec))))

;;;###autoload
(defsubst kill-lower-afpt ()
  "Kills lower after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:lower:]")
      (thatpt-kill 'lower))))

;;;###autoload
(defsubst forward-lower-afpt (&optional arg ispec) 
  "Moves forward over lower after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:lower:]")
     ;; (forward-char 1)
  (thatpt-forward 'lower arg ispec)))
;;;###autoload
(defsubst multibyte-afpt (&optional arg ispec) 
  "Returns multibyte after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
    (thatpt 'multibyte arg ispec))))

;;;###autoload
(defsubst bounds-of-multibyte-afpt (&optional arg ispec) 
  "Returns border of multibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
     (thatpt-bounds 'multibyte arg ispec))))

;;;###autoload
(defsubst multibyte-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of multibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (thatpt-beginning 'multibyte arg ispec))))

;;;###autoload
(defsubst multibyte-afpt-end-position (&optional arg ispec) 
  "Returns end position of multibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (thatpt-end 'multibyte arg ispec))))

;;;###autoload
(defsubst copy-multibyte-afpt (&optional arg ispec) 
  "Returns a copy of multibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (thatpt-copy 'multibyte arg ispec))))

;;;###autoload
(defsubst separate-multibyte-afpt (&optional arg ispec) 
  "Returns a copy of multibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (thatpt-separate 'multibyte arg ispec))))

;;;###autoload
(defsubst comment-multibyte-afpt (&optional arg ispec) 
  "Returns a copy of multibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (thatpt-comment 'multibyte arg ispec))))

;;;###autoload
(defsubst doublequote-multibyte-afpt (&optional arg ispec) 
  "Doublequotes multibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (unless (eobp)
    (thatpt-delim 'multibyte 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-multibyte-afpt (&optional arg ispec) 
  "Singlequotes multibyte after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (unless (eobp)
    (thatpt-delim 'multibyte 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-multibyte-afpt (&optional arg ispec) 
  "Parentizes multibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (unless (eobp)
    (thatpt-delim 'multibyte 'parentize arg ispec))))

;;;###autoload
(defsubst brace-multibyte-afpt (&optional arg ispec) 
  "Braces multibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (unless (eobp)
    (thatpt-delim 'multibyte 'brace arg ispec))))

;;;###autoload
(defsubst bracket-multibyte-afpt (&optional arg ispec) 
  "Brackets multibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (unless (eobp)
    (thatpt-delim 'multibyte 'bracket arg ispec))))

;;;###autoload
(defsubst kill-multibyte-afpt ()
  "Kills multibyte after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:multibyte:]")
      (thatpt-kill 'multibyte))))

;;;###autoload
(defsubst forward-multibyte-afpt (&optional arg ispec) 
  "Moves forward over multibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:multibyte:]")
     ;; (forward-char 1)
  (thatpt-forward 'multibyte arg ispec)))
;;;###autoload
(defsubst nonascii-afpt (&optional arg ispec) 
  "Returns nonascii after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
    (thatpt 'nonascii arg ispec))))

;;;###autoload
(defsubst bounds-of-nonascii-afpt (&optional arg ispec) 
  "Returns border of nonascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
     (thatpt-bounds 'nonascii arg ispec))))

;;;###autoload
(defsubst nonascii-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of nonascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (thatpt-beginning 'nonascii arg ispec))))

;;;###autoload
(defsubst nonascii-afpt-end-position (&optional arg ispec) 
  "Returns end position of nonascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (thatpt-end 'nonascii arg ispec))))

;;;###autoload
(defsubst copy-nonascii-afpt (&optional arg ispec) 
  "Returns a copy of nonascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (thatpt-copy 'nonascii arg ispec))))

;;;###autoload
(defsubst separate-nonascii-afpt (&optional arg ispec) 
  "Returns a copy of nonascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (thatpt-separate 'nonascii arg ispec))))

;;;###autoload
(defsubst comment-nonascii-afpt (&optional arg ispec) 
  "Returns a copy of nonascii after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (thatpt-comment 'nonascii arg ispec))))

;;;###autoload
(defsubst doublequote-nonascii-afpt (&optional arg ispec) 
  "Doublequotes nonascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (unless (eobp)
    (thatpt-delim 'nonascii 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-nonascii-afpt (&optional arg ispec) 
  "Singlequotes nonascii after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (unless (eobp)
    (thatpt-delim 'nonascii 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-nonascii-afpt (&optional arg ispec) 
  "Parentizes nonascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (unless (eobp)
    (thatpt-delim 'nonascii 'parentize arg ispec))))

;;;###autoload
(defsubst brace-nonascii-afpt (&optional arg ispec) 
  "Braces nonascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (unless (eobp)
    (thatpt-delim 'nonascii 'brace arg ispec))))

;;;###autoload
(defsubst bracket-nonascii-afpt (&optional arg ispec) 
  "Brackets nonascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (unless (eobp)
    (thatpt-delim 'nonascii 'bracket arg ispec))))

;;;###autoload
(defsubst kill-nonascii-afpt ()
  "Kills nonascii after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:nonascii:]")
      (thatpt-kill 'nonascii))))

;;;###autoload
(defsubst forward-nonascii-afpt (&optional arg ispec) 
  "Moves forward over nonascii after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:nonascii:]")
     ;; (forward-char 1)
  (thatpt-forward 'nonascii arg ispec)))
;;;###autoload
(defsubst print-afpt (&optional arg ispec) 
  "Returns print after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:print:]")
    (thatpt 'print arg ispec))))

;;;###autoload
(defsubst bounds-of-print-afpt (&optional arg ispec) 
  "Returns border of print after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:print:]")
     (thatpt-bounds 'print arg ispec))))

;;;###autoload
(defsubst print-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of print after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (thatpt-beginning 'print arg ispec))))

;;;###autoload
(defsubst print-afpt-end-position (&optional arg ispec) 
  "Returns end position of print after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (thatpt-end 'print arg ispec))))

;;;###autoload
(defsubst copy-print-afpt (&optional arg ispec) 
  "Returns a copy of print after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (thatpt-copy 'print arg ispec))))

;;;###autoload
(defsubst separate-print-afpt (&optional arg ispec) 
  "Returns a copy of print after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (thatpt-separate 'print arg ispec))))

;;;###autoload
(defsubst comment-print-afpt (&optional arg ispec) 
  "Returns a copy of print after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (thatpt-comment 'print arg ispec))))

;;;###autoload
(defsubst doublequote-print-afpt (&optional arg ispec) 
  "Doublequotes print after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (unless (eobp)
    (thatpt-delim 'print 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-print-afpt (&optional arg ispec) 
  "Singlequotes print after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (unless (eobp)
    (thatpt-delim 'print 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-print-afpt (&optional arg ispec) 
  "Parentizes print after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (unless (eobp)
    (thatpt-delim 'print 'parentize arg ispec))))

;;;###autoload
(defsubst brace-print-afpt (&optional arg ispec) 
  "Braces print after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (unless (eobp)
    (thatpt-delim 'print 'brace arg ispec))))

;;;###autoload
(defsubst bracket-print-afpt (&optional arg ispec) 
  "Brackets print after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (unless (eobp)
    (thatpt-delim 'print 'bracket arg ispec))))

;;;###autoload
(defsubst kill-print-afpt ()
  "Kills print after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:print:]")
      (thatpt-kill 'print))))

;;;###autoload
(defsubst forward-print-afpt (&optional arg ispec) 
  "Moves forward over print after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:print:]")
     ;; (forward-char 1)
  (thatpt-forward 'print arg ispec)))
;;;###autoload
(defsubst punct-afpt (&optional arg ispec) 
  "Returns punct after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
    (thatpt 'punct arg ispec))))

;;;###autoload
(defsubst bounds-of-punct-afpt (&optional arg ispec) 
  "Returns border of punct after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
     (thatpt-bounds 'punct arg ispec))))

;;;###autoload
(defsubst punct-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of punct after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (thatpt-beginning 'punct arg ispec))))

;;;###autoload
(defsubst punct-afpt-end-position (&optional arg ispec) 
  "Returns end position of punct after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (thatpt-end 'punct arg ispec))))

;;;###autoload
(defsubst copy-punct-afpt (&optional arg ispec) 
  "Returns a copy of punct after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (thatpt-copy 'punct arg ispec))))

;;;###autoload
(defsubst separate-punct-afpt (&optional arg ispec) 
  "Returns a copy of punct after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (thatpt-separate 'punct arg ispec))))

;;;###autoload
(defsubst comment-punct-afpt (&optional arg ispec) 
  "Returns a copy of punct after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (thatpt-comment 'punct arg ispec))))

;;;###autoload
(defsubst doublequote-punct-afpt (&optional arg ispec) 
  "Doublequotes punct after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (unless (eobp)
    (thatpt-delim 'punct 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-punct-afpt (&optional arg ispec) 
  "Singlequotes punct after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (unless (eobp)
    (thatpt-delim 'punct 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-punct-afpt (&optional arg ispec) 
  "Parentizes punct after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (unless (eobp)
    (thatpt-delim 'punct 'parentize arg ispec))))

;;;###autoload
(defsubst brace-punct-afpt (&optional arg ispec) 
  "Braces punct after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (unless (eobp)
    (thatpt-delim 'punct 'brace arg ispec))))

;;;###autoload
(defsubst bracket-punct-afpt (&optional arg ispec) 
  "Brackets punct after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (unless (eobp)
    (thatpt-delim 'punct 'bracket arg ispec))))

;;;###autoload
(defsubst kill-punct-afpt ()
  "Kills punct after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:punct:]")
      (thatpt-kill 'punct))))

;;;###autoload
(defsubst forward-punct-afpt (&optional arg ispec) 
  "Moves forward over punct after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:punct:]")
     ;; (forward-char 1)
  (thatpt-forward 'punct arg ispec)))
;;;###autoload
(defsubst space-afpt (&optional arg ispec) 
  "Returns space after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:space:]")
    (thatpt 'space arg ispec))))

;;;###autoload
(defsubst bounds-of-space-afpt (&optional arg ispec) 
  "Returns border of space after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:space:]")
     (thatpt-bounds 'space arg ispec))))

;;;###autoload
(defsubst space-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of space after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (thatpt-beginning 'space arg ispec))))

;;;###autoload
(defsubst space-afpt-end-position (&optional arg ispec) 
  "Returns end position of space after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (thatpt-end 'space arg ispec))))

;;;###autoload
(defsubst copy-space-afpt (&optional arg ispec) 
  "Returns a copy of space after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (thatpt-copy 'space arg ispec))))

;;;###autoload
(defsubst separate-space-afpt (&optional arg ispec) 
  "Returns a copy of space after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (thatpt-separate 'space arg ispec))))

;;;###autoload
(defsubst comment-space-afpt (&optional arg ispec) 
  "Returns a copy of space after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (thatpt-comment 'space arg ispec))))

;;;###autoload
(defsubst doublequote-space-afpt (&optional arg ispec) 
  "Doublequotes space after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (unless (eobp)
    (thatpt-delim 'space 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-space-afpt (&optional arg ispec) 
  "Singlequotes space after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (unless (eobp)
    (thatpt-delim 'space 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-space-afpt (&optional arg ispec) 
  "Parentizes space after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (unless (eobp)
    (thatpt-delim 'space 'parentize arg ispec))))

;;;###autoload
(defsubst brace-space-afpt (&optional arg ispec) 
  "Braces space after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (unless (eobp)
    (thatpt-delim 'space 'brace arg ispec))))

;;;###autoload
(defsubst bracket-space-afpt (&optional arg ispec) 
  "Brackets space after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (unless (eobp)
    (thatpt-delim 'space 'bracket arg ispec))))

;;;###autoload
(defsubst kill-space-afpt ()
  "Kills space after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:space:]")
      (thatpt-kill 'space))))

;;;###autoload
(defsubst forward-space-afpt (&optional arg ispec) 
  "Moves forward over space after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:space:]")
     ;; (forward-char 1)
  (thatpt-forward 'space arg ispec)))
;;;###autoload
(defsubst unibyte-afpt (&optional arg ispec) 
  "Returns unibyte after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
    (thatpt 'unibyte arg ispec))))

;;;###autoload
(defsubst bounds-of-unibyte-afpt (&optional arg ispec) 
  "Returns border of unibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
     (thatpt-bounds 'unibyte arg ispec))))

;;;###autoload
(defsubst unibyte-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of unibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (thatpt-beginning 'unibyte arg ispec))))

;;;###autoload
(defsubst unibyte-afpt-end-position (&optional arg ispec) 
  "Returns end position of unibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (thatpt-end 'unibyte arg ispec))))

;;;###autoload
(defsubst copy-unibyte-afpt (&optional arg ispec) 
  "Returns a copy of unibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (thatpt-copy 'unibyte arg ispec))))

;;;###autoload
(defsubst separate-unibyte-afpt (&optional arg ispec) 
  "Returns a copy of unibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (thatpt-separate 'unibyte arg ispec))))

;;;###autoload
(defsubst comment-unibyte-afpt (&optional arg ispec) 
  "Returns a copy of unibyte after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (thatpt-comment 'unibyte arg ispec))))

;;;###autoload
(defsubst doublequote-unibyte-afpt (&optional arg ispec) 
  "Doublequotes unibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (unless (eobp)
    (thatpt-delim 'unibyte 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-unibyte-afpt (&optional arg ispec) 
  "Singlequotes unibyte after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (unless (eobp)
    (thatpt-delim 'unibyte 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-unibyte-afpt (&optional arg ispec) 
  "Parentizes unibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (unless (eobp)
    (thatpt-delim 'unibyte 'parentize arg ispec))))

;;;###autoload
(defsubst brace-unibyte-afpt (&optional arg ispec) 
  "Braces unibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (unless (eobp)
    (thatpt-delim 'unibyte 'brace arg ispec))))

;;;###autoload
(defsubst bracket-unibyte-afpt (&optional arg ispec) 
  "Brackets unibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (unless (eobp)
    (thatpt-delim 'unibyte 'bracket arg ispec))))

;;;###autoload
(defsubst kill-unibyte-afpt ()
  "Kills unibyte after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:unibyte:]")
      (thatpt-kill 'unibyte))))

;;;###autoload
(defsubst forward-unibyte-afpt (&optional arg ispec) 
  "Moves forward over unibyte after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:unibyte:]")
     ;; (forward-char 1)
  (thatpt-forward 'unibyte arg ispec)))
;;;###autoload
(defsubst upper-afpt (&optional arg ispec) 
  "Returns upper after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
    (thatpt 'upper arg ispec))))

;;;###autoload
(defsubst bounds-of-upper-afpt (&optional arg ispec) 
  "Returns border of upper after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
     (thatpt-bounds 'upper arg ispec))))

;;;###autoload
(defsubst upper-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of upper after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (thatpt-beginning 'upper arg ispec))))

;;;###autoload
(defsubst upper-afpt-end-position (&optional arg ispec) 
  "Returns end position of upper after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (thatpt-end 'upper arg ispec))))

;;;###autoload
(defsubst copy-upper-afpt (&optional arg ispec) 
  "Returns a copy of upper after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (thatpt-copy 'upper arg ispec))))

;;;###autoload
(defsubst separate-upper-afpt (&optional arg ispec) 
  "Returns a copy of upper after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (thatpt-separate 'upper arg ispec))))

;;;###autoload
(defsubst comment-upper-afpt (&optional arg ispec) 
  "Returns a copy of upper after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (thatpt-comment 'upper arg ispec))))

;;;###autoload
(defsubst doublequote-upper-afpt (&optional arg ispec) 
  "Doublequotes upper after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (unless (eobp)
    (thatpt-delim 'upper 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-upper-afpt (&optional arg ispec) 
  "Singlequotes upper after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (unless (eobp)
    (thatpt-delim 'upper 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-upper-afpt (&optional arg ispec) 
  "Parentizes upper after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (unless (eobp)
    (thatpt-delim 'upper 'parentize arg ispec))))

;;;###autoload
(defsubst brace-upper-afpt (&optional arg ispec) 
  "Braces upper after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (unless (eobp)
    (thatpt-delim 'upper 'brace arg ispec))))

;;;###autoload
(defsubst bracket-upper-afpt (&optional arg ispec) 
  "Brackets upper after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (unless (eobp)
    (thatpt-delim 'upper 'bracket arg ispec))))

;;;###autoload
(defsubst kill-upper-afpt ()
  "Kills upper after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:upper:]")
      (thatpt-kill 'upper))))

;;;###autoload
(defsubst forward-upper-afpt (&optional arg ispec) 
  "Moves forward over upper after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:upper:]")
     ;; (forward-char 1)
  (thatpt-forward 'upper arg ispec)))
;;;###autoload
(defsubst xdigit-afpt (&optional arg ispec) 
  "Returns xdigit after point if any, nil otherwise"
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
    (thatpt 'xdigit arg ispec))))

;;;###autoload
(defsubst bounds-of-xdigit-afpt (&optional arg ispec) 
  "Returns border of xdigit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
     (thatpt-bounds 'xdigit arg ispec))))

;;;###autoload
(defsubst xdigit-afpt-beginning-position (&optional arg ispec) 
  "Returns beginning of xdigit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (thatpt-beginning 'xdigit arg ispec))))

;;;###autoload
(defsubst xdigit-afpt-end-position (&optional arg ispec) 
  "Returns end position of xdigit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (thatpt-end 'xdigit arg ispec))))

;;;###autoload
(defsubst copy-xdigit-afpt (&optional arg ispec) 
  "Returns a copy of xdigit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (thatpt-copy 'xdigit arg ispec))))

;;;###autoload
(defsubst separate-xdigit-afpt (&optional arg ispec) 
  "Returns a copy of xdigit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (thatpt-separate 'xdigit arg ispec))))

;;;###autoload
(defsubst comment-xdigit-afpt (&optional arg ispec) 
  "Returns a copy of xdigit after point if any, nil otherwise "
  (interactive "p\np")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (thatpt-comment 'xdigit arg ispec))))

;;;###autoload
(defsubst doublequote-xdigit-afpt (&optional arg ispec) 
  "Doublequotes xdigit after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (unless (eobp)
    (thatpt-delim 'xdigit 'doublequote arg ispec))))

;;;###autoload
(defsubst singlequote-xdigit-afpt (&optional arg ispec) 
  "Singlequotes xdigit after point if any, does nothing otherwise " 
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (unless (eobp)
    (thatpt-delim 'xdigit 'singlequote arg ispec))))

;;;###autoload
(defsubst parentize-xdigit-afpt (&optional arg ispec) 
  "Parentizes xdigit after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (unless (eobp)
    (thatpt-delim 'xdigit 'parentize arg ispec))))

;;;###autoload
(defsubst brace-xdigit-afpt (&optional arg ispec) 
  "Braces xdigit after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (unless (eobp)
    (thatpt-delim 'xdigit 'brace arg ispec))))

;;;###autoload
(defsubst bracket-xdigit-afpt (&optional arg ispec) 
  "Brackets xdigit after point if any, does nothing otherwise "
  (interactive "p\np")
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (unless (eobp)
    (thatpt-delim 'xdigit 'bracket arg ispec))))

;;;###autoload
(defsubst kill-xdigit-afpt ()
  "Kills xdigit after point if any, does nothing otherwise "
  (interactive "*")
  (unless (eobp)
  (save-excursion  
     (skip-chars-forward "^[:xdigit:]")
      (thatpt-kill 'xdigit))))

;;;###autoload
(defsubst forward-xdigit-afpt (&optional arg ispec) 
  "Moves forward over xdigit after point if any, does nothing otherwise "
  (interactive "p\np")
  (unless (eobp)
       (skip-chars-forward "^[:xdigit:]")
     ;; (forward-char 1)
  (thatpt-forward 'xdigit arg ispec)))

;;; thing-after-point-utils.el ends here
(provide 'thing-after-point-utils)