;ELC   
;;; Compiled
;;; in Emacs version 30.2
;;; with all optimizations.


(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require dash s format] 2)
(defvar elisp-refs-verbose t)#@72 Format INTEGER as a string, with , separating thousands.

(fn INTEGER)
(defalias 'elisp-refs--format-int #[257 "\300!\301\302V\203 \303\304\305\306\"\"B\262\306\245\262\202 \303\307\"B\262\310W\203/ \311\2020 \312\313\314\"P\207" [abs nil 999 format "%03d" mod 1000 "%d" 0 "-" "" s-join ","] 8 (#$ . 193)])#@88 Find the start position of form ending at END-POS
in the current buffer.

(fn END-POS)
(defalias 'elisp-refs--start-pos #[257 "\301\302\303\")\207" [parse-sexp-ignore-comments t scan-sexps -1] 4 (#$ . 519)])#@311 Return a list of start and end positions of all the sexps
between START-POS and END-POS (inclusive) in BUFFER.

Positions exclude quote characters, so given 'foo or `foo, we
report the position of the symbol foo.

Not recursive, so we don't consider subelements of nested sexps.

(fn BUFFER START-POS END-POS)
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put elisp-refs--start-pos speed -1 put byte-optimizer byte-compile-inline-expand] 5)
(defalias 'elisp-refs--sexp-positions #[771 "\301rq\210\30219 \30328 \304\305\306\")\211\203 \211V\203# \307\303\301\"\210\211\304\305\310\")\262DB\262\262\202 0)\210\237\207" [parse-sexp-ignore-comments nil (scan-error) done t scan-sexps 1 throw -1] 9 (#$ . 735)])#@437 Read a form from the current buffer, starting at point.
Returns a list:
(form form-start-pos form-end-pos symbol-positions read-start-pos)

In Emacs 28 and earlier, SYMBOL-POSITIONS is a list of 0-indexed
symbol positions relative to READ-START-POS, according to
`read-symbol-positions-list'.

In Emacs 29+, SYMBOL-POSITIONS is nil. If SYMBOLS-WITH-POS is
non-nil, forms are read with `read-positioning-symbols'.

(fn SYMBOLS-WITH-POS)
(defalias 'elisp-refs--read-buffer-form #[257 "\302`\203 \303\304!\203 \304p!\202 \305p!\306\300!\205 `\211\307\310\311\")\262\257\207" [read-symbol-positions-list parse-sexp-ignore-comments nil fboundp read-positioning-symbols read boundp t scan-sexps -1] 12 (#$ . 1477)])#@96 A buffer-local variable used by `elisp-refs--contents-buffer'.
Internal implementation detail.
(defvar elisp-refs--path nil (#$ . 2208))#@89 Read all the forms in BUFFER, along with their positions.

(fn BUFFER SYMBOLS-WITH-POS)
(defalias 'elisp-refs--read-all-buffer-forms #[514 "rq\210eb\210\301\3021 \303!B\262\202\f \211@\304=\204$ \211@\305=\203) \210\237\2023 \306\307\310!`$\266\202)\207" [elisp-refs--path nil (error) elisp-refs--read-buffer-form end-of-file scan-error error "Unexpected error whilst reading %s position %s: %s" abbreviate-file-name] 9 (#$ . 2350)])#@33 Is VAL a proper list?

(fn VAL)
(defalias 'elisp-refs--proper-list-p #[257 "\300\301!\203\n \301!\207\302!\207" [fboundp proper-list-p format-proper-list-p] 3 (#$ . 2796)])#@599 Walk FORM, a nested list, and return a list of sublists (with
their positions) where MATCH-P returns t. FORM is traversed
depth-first (pre-order traversal, left-to-right).

MATCH-P is called with three arguments:
(SYMBOL CURRENT-FORM PATH).

PATH is the first element of all the enclosing forms of
CURRENT-FORM, innermost first, along with the index of the
current form.

For example if we are looking at h in (e f (g h)), PATH takes the
value ((g . 1) (e . 2)).

START-POS and END-POS should be the position of FORM within BUFFER.

(fn BUFFER FORM START-POS END-POS SYMBOL MATCH-P &optional PATH)
(defalias 'elisp-refs--walk #[1798 "#\203 EC\207:\205\230 \300\242\301=\203* \300\302	#B\2023 \302T#\303\"\304\203\217 \211A\262\242\211\211A\262\242\211A\262\242@:\203] \305!\204i 9\203\211 \f=\203\211 \306\242BB&\211\203\210 \211\nB\262\n\210\266T\2029 \266\307\310\237\"\266\202\207" [nil \` elisp-refs--sexp-positions -zip-pair 0 elisp-refs--proper-list-p elisp-refs--walk apply append] 25 (#$ . 2977)])#@79 Return t if FORM looks like a function call to SYMBOL.

(fn SYMBOL FORM PATH)
(defalias 'elisp-refs--function-p #[771 ":\204 \300\207\211@\301\232\204# \211@\302\232\204# \211@\303\232\204# \211@\304\232\203% \300\207\211@\305\232\203. \300\207\211@\306\232\204< \211@\307\232\203> \300\207\211A@\310\232\204N \211A@\311\232\203P \300\207\211@\312\232\203Y \300\207@=\203b \313\207\300\314\300\203\204 \210\242\211\315D\232\211\262\204\204 T\262A\262\202f \266\203\213 \313\207@\316=\203\236 \317DA@\232\203\236 \313\207@\320=\205\260 \317DA@\232\205\260 \313\207" [nil (defsubst . 2) (defun . 2) (defmacro . 2) (cl-defun . 2) (lambda . 1) (let . 1) (let* . 1) (let . 1) (let* . 1) (declare-function . 3) t 0 function funcall quote apply] 10 (#$ . 4047)])#@76 Return t if FORM looks like a macro call to SYMBOL.

(fn SYMBOL FORM PATH)
(defalias 'elisp-refs--macro-p #[771 ":\204 \300\207\211@\301\232\204 \211@\302\232\204 \211@\303\232\203 \300\207\211@\304\232\203' \300\207\211@\305\232\2045 \211@\306\232\2037 \300\207\211A@\307\232\204G \211A@\310\232\203I \300\207@=\205Q \311\207" [nil (defsubst . 2) (defun . 2) (defmacro . 2) (lambda . 1) (let . 1) (let* . 1) (let . 1) (let* . 1) t] 5 (#$ . 4829)])#@128 Return t if this looks like a variable reference to SYMBOL.
We consider parameters to be variables too.

(fn SYMBOL FORM PATH)
(defalias 'elisp-refs--special-p 'elisp-refs--macro-p)
(defalias 'elisp-refs--variable-p #[771 ":\203 \300\207\211@\301\232\204# \211@\302\232\204# \211@\303\232\204# \211@\304\232\203% \300\207\211A@\305\232\2045 \211A@\306\232\2037 \307\207\211A@\310\232\203A \307\207\211AA@\311\232\204S \211AA@\312\232\203U \307\207\211@\313B\232\203` \300\207=\205g \307\207" [nil (defsubst . 1) (defun . 1) (defmacro . 1) (cl-defun . 1) (let . 1) (let* . 1) t (lambda . 1) (let . 1) (let* . 1) 0] 6 (#$ . 5291)])#@232 Read all the forms in BUFFER, and return a list of all forms that
contain SYMBOL where MATCH-P returns t.

For every matching form found, we return the form itself along
with its start and end position.

(fn BUFFER SYMBOL MATCH-P)#@11 

(fn IT)
(defalias 'elisp-refs--read-and-find #[771 "\300\301\302\303\304\305\n$\306\307\"\"\"!\207" [-non-nil apply append mapcar make-closure #[257 "\211\211A\262\242\211A\262\242\211A\262\242\211A\262\242@\210\303\203' \301\236\2053 \304\302\301\300&\207" [V0 V1 V2 nil elisp-refs--walk] 14 (#$ . 6168)] elisp-refs--read-all-buffer-forms nil] 12 (#$ . 5932)])#@146 Given a nested list of FORMS, return a list of all positions of SYMBOL.
Assumes `symbol-with-pos-pos' is defined (Emacs 29+).

(fn FORMS SYMBOL)
(defalias 'elisp-refs--walk-positioned-symbols #[514 "\301!\203 \302=\205 \211\303!\303!\304!G\\EC)\207\305!\203/ \306\307\310\311\312\"\"\"\207:\203A \307\313@\"\313A\"\"\207\314!\205Q \306\307\310\311\315\"\"\"\207" [symbols-with-pos-enabled symbol-with-pos-p t symbol-with-pos-pos symbol-name elisp-refs--proper-list-p apply append mapcar make-closure #[257 "\301\300\"\207" [V0 elisp-refs--walk-positioned-symbols] 4 (#$ . 6168)] elisp-refs--walk-positioned-symbols vectorp #[257 "\301\300\"\207" [V0 elisp-refs--walk-positioned-symbols] 4 (#$ . 6168)]] 8 (#$ . 6563)])#@97 Read all the forms in BUFFER, and return a list of all
positions of SYMBOL.

(fn BUFFER SYMBOL)
(defalias 'elisp-refs--read-and-find-symbol #[514 "\300\301!\302\"\203 \303\"\207\304\305\306\307\310\311\"\"\"!\207" [fboundp symbol-with-pos-pos elisp-refs--read-all-buffer-forms elisp-refs--walk-positioned-symbols -non-nil apply append mapcar make-closure #[257 "\211AAA\211A\262\242@\301\302\303\300#\"\207" [V0 mapcar make-closure #[257 "\211\211A\262\242\211\301=\205 \300\\\211\302!G\\E\266\202\207" [V0 V1 symbol-name] 8 (#$ . 6168)]] 9 (#$ . 6168)]] 11 (#$ . 7309)])#@78 Return a list of all the items in `obarray' where PRED returns t.

(fn PRED)#@15 

(fn SYMBOL)
(defalias 'elisp-refs--filter-obarray #[257 "\300C\301\302\303#!\210\242\207" [nil mapatoms make-closure #[257 "\301!\205 \302!\303\232?\205 \300\300\242B\240\207" [V0 V1 symbol-name ""] 4 (#$ . 7990)]] 7 (#$ . 7908)])#@128 Return a list of all files that have been loaded in Emacs.
Where the file was a .elc, return the path to the .el file instead.
(defalias 'elisp-refs--loaded-paths #[0 "\301\302\303\"!\301\302\304\"!\207" [load-history -non-nil mapcar -first-item #[257 "\300\301\302!\"\300\303\302!\"\304!\203 \207\304!\203 \207\305\207" [format "%s.el" file-name-sans-extension "%s.el.gz" file-exists-p nil] 6 (#$ . 6168)]] 5 (#$ . 8236)])#@149 Read PATH into a disposable buffer, and return it.
Works around the fact that Emacs won't allow multiple buffers
visiting the same file.

(fn PATH)
(defalias 'elisp-refs--contents-buffer #[257 "\304\305\306\"!\307\310r\211q\210\311\302!\210\312!\210\313!+\210\207" [file-name-handler-alist coding-system-for-read elisp-refs--path emacs-lisp-mode-syntax-table generate-new-buffer format " *refs-%s*" nil (("\\(?:\\.dz\\|\\.txz\\|\\.xz\\|\\.lzma\\|\\.lz\\|\\.g?z\\|\\.\\(?:tgz\\|svgz\\|sifz\\)\\|\\.tbz2?\\|\\.bz2\\|\\.Z\\)\\(?:~\\|\\.~[-[:alnum:]:#@^._]+\\(?:~[[:digit:]]+\\)?~\\)?\\'" . jka-compr-handler) ("\\(?:^/\\)\\(\\(?:\\(?:\\(-\\|[[:alnum:]]\\{2,\\}\\)\\(?::\\)\\(?:\\([^/:|[:blank:]]+\\)\\(?:@\\)\\)?\\(\\(?:[%._[:alnum:]-]+\\|\\(?:\\[\\)\\(?:\\(?:[[:alnum:]]*:\\)+[.[:alnum:]]*\\)?\\(?:]\\)\\)\\(?:\\(?:#\\)\\(?:[[:digit:]]+\\)\\)?\\)?\\)\\(?:|\\)\\)+\\)?\\(?:\\(-\\|[[:alnum:]]\\{2,\\}\\)\\(?::\\)\\(?:\\([^/:|[:blank:]]+\\)\\(?:@\\)\\)?\\(\\(?:[%._[:alnum:]-]+\\|\\(?:\\[\\)\\(?:\\(?:[[:alnum:]]*:\\)+[.[:alnum:]]*\\)?\\(?:]\\)\\)\\(?:\\(?:#\\)\\(?:[[:digit:]]+\\)\\)?\\)?\\)\\(?::\\)\\([^\n]*\\'\\)" . tramp-file-name-handler) ("\\`/:" . file-name-non-special)) make-local-variable insert-file-contents set-syntax-table] 5 (#$ . 8675)])#@150 A temporary buffer used for highlighting.
Since `elisp-refs--syntax-highlight' is a hot function, we
don't want to create lots of temporary buffers.
(defvar elisp-refs--highlighting-buffer nil (#$ . 9939))#@74 Apply font-lock properties to a string STR of Emacs lisp code.

(fn STR)
(defalias 'elisp-refs--syntax-highlight #[257 "\203\n \302!\204 \303\304!rq\210\305\301!\210\306\307 *\210rq\210\310 \210\211c\210\311\312!\2032 \312 \210\2025 \313 \210\314 )\207" [elisp-refs--highlighting-buffer delay-mode-hooks buffer-live-p generate-new-buffer " *refs-highlighting*" make-local-variable t emacs-lisp-mode erase-buffer fboundp font-lock-ensure font-lock-fontify-buffer buffer-string] 3 (#$ . 10150)])#@50 Replace tabs in STRING with spaces.

(fn STRING)
(defalias 'elisp-refs--replace-tabs #[257 "\301\302\303\304\"#\207" [tab-width s-replace "	" s-repeat " "] 6 (#$ . 10656)])#@76 Return a list of all the lines in STRING.
'a
b' -> ('a
' 'b')

(fn STRING)
(defalias 'elisp-refs--lines #[257 "\300G\301V\2030 \302\303\"\211\203$ \301TOB\262T\300O\262\210\202 B\262\304\262\210\202 \237\207" [nil 0 s-index-of "\n" ""] 6 (#$ . 10836)])#@83 Execute FN for each line in string, and join the result together.

(fn STRING FN)
(defalias 'elisp-refs--map-lines #[514 "\300\301!\211\203 \211@!B\262\210A\202 \210\302\303\237\"\207" [nil elisp-refs--lines apply concat] 7 (#$ . 11109)])#@227 Given an indented STRING, unindent rigidly until
at least one line has no indent.

STRING should have a 'elisp-refs-start-pos property. The returned
string will have this property updated to reflect the unindent.

(fn STRING)#@13 

(fn LINE)
(defalias 'elisp-refs--unindent-rigidly #[257 "\300!\301\302\"\303\301\304\"!\305\306\307\310\"\"\311#\207" [s-lines mapcar #[257 "\300\301\"@\207" [s-match "\\`[[:space:]]+"] 4 (#$ . 6168)] -min #[257 "G\207" [] 2 (#$ . 6168)] propertize elisp-refs--map-lines make-closure #[257 "\211\300\301O\207" [V0 nil] 4 (#$ . 11593)] elisp-refs-unindented] 10 (#$ . 11362)])#@202 Return a string, all the lines in BUFFER that are between
START-POS and END-POS (inclusive).

For the characters that are between START-POS and END-POS,
propertize them.

(fn BUFFER START-POS END-POS)
(defalias 'elisp-refs--containing-lines #[771 "\301\211rq\210b\210\302 \210`\262b\210\301\266`{{\303\304\305#\306{!\303\304\305#Q\303\307\310!!\311\312%)\207" [elisp-refs--path nil beginning-of-line propertize face font-lock-comment-face elisp-refs--syntax-highlight elisp-refs--unindent-rigidly elisp-refs--replace-tabs elisp-refs-start-pos elisp-refs-path] 14 (#$ . 11984)])#@50 Open the file referenced by BUTTON.

(fn BUTTON)
(defalias 'elisp-refs--find-file #[257 "\300\301\302\"!\210eb\207" [find-file button-get path] 5 (#$ . 12587)])#@52 Return a button that navigates to PATH.

(fn PATH)
(define-button-type 'elisp-refs-path-button 'action 'elisp-refs--find-file 'follow-link t 'help-echo "Open file")
(defalias 'elisp-refs--path-button #[257 "\300\301\302\"r\211q\210\303\304\"\216\305\306!\307\310\311%\210\312 *\207" [generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] insert-text-button abbreviate-file-name :type elisp-refs-path-button path buffer-string] 8 (#$ . 12754)])#@63 Show *Help* for the symbol referenced by BUTTON.

(fn BUTTON)
(defalias 'elisp-refs--describe #[257 "\300\301\"\300\302\"\211\303\267\202 \304!\207\305!\207\306!\207" [button-get symbol kind #s(hash-table test eq purecopy t data (symbol 14 variable 18)) describe-symbol describe-variable describe-function] 5 (#$ . 13265)])#@131 Return a button that shows *Help* for SYMBOL.
KIND should be 'function, 'macro, 'variable, 'special or 'symbol.

(fn SYMBOL KIND)
(define-button-type 'elisp-refs-describe-button 'action 'elisp-refs--describe 'follow-link t 'help-echo "Describe")
(defalias 'elisp-refs--describe-button #[514 "\300\301\302\"r\211q\210\303\304\"\216\305!\306\261\210\307\305!\310\311\312\313&\210\314 *\207" [generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] symbol-name " " insert-text-button :type elisp-refs-describe-button symbol kind buffer-string] 11 (#$ . 13601)])#@79 Human-friendly description of NUMBER occurrences of THING.

(fn NUMBER THING)
(defalias 'elisp-refs--pluralize #[514 "\300\301\302!\303=\203 \304\202 \305$\207" [format "%s %s%s" elisp-refs--format-int 1 "" "s"] 8 (#$ . 14230)])#@63 

(fn SYMBOL REF-COUNT FILE-COUNT SEARCHED-FILE-COUNT PREFIX)
(defalias 'elisp-refs--format-count #[1285 "\300U\203\n \301\202 \302\303\304\305\"\"\302\306\304\307\"$\2031 \302\310\304\311\"\312\313!!#\2029 \302\314\304\305\"\"\315\316\302\317#\"\207" [0 "" format " in %s" elisp-refs--pluralize "file" "Found %s to %s%s." "reference" "Searched %s in %s." "loaded file" elisp-refs--path-button file-name-as-directory "Searched all %s loaded in Emacs." s-word-wrap 70 "%s %s"] 14 (#$ . 14469)])#@168 Given a RESULTS list where each element takes the form (forms . buffer),
render a friendly results buffer.

(fn SYMBOL DESCRIPTION RESULTS SEARCHED-FILE-COUNT PREFIX)
(defalias 'elisp-refs--show-results #[1285 "\303\304\305\"!\306!\210\307\310 \210\212\311\312\313\314\"!G%\315\261\210\316\203z \211A\262\242\211\211A\262\242rq\210	)\317\320\321\322#\323!\324\261\210\316\203p \211A\262\242\211A\211A\262\242@\325	#\324\261\266T\202M \266\324c\266T\202( \266\326 *\210\n\205\207 \327\n!\207" [inhibit-read-only elisp-refs--path elisp-refs--highlighting-buffer get-buffer-create format "*refs: %s*" switch-to-buffer t erase-buffer elisp-refs--format-count -sum mapcar #[257 "\211@G\207" [] 2 (#$ . 6168)] "\n\n" 0 propertize "File: " face bold elisp-refs--path-button "\n" elisp-refs--containing-lines elisp-refs-mode kill-buffer] 22 (#$ . 14986)])#@66 Return a list of open buffers, one for each path in `load-path'.
(defalias 'elisp-refs--loaded-bufs #[0 "\300\301\302 \"\207" [mapcar elisp-refs--contents-buffer elisp-refs--loaded-paths] 3 (#$ . 15877)])#@284 Call MATCH-FN on each buffer in BUFS, reporting progress
and accumulating results.

BUFS should be disposable: we make no effort to preserve their
state during searching.

MATCH-FN should return a list where each element takes the form:
(form start-pos end-pos).

(fn BUFS MATCH-FN)
(defalias 'elisp-refs--search-1 #[514 "\302G\303\304\211\203: \211@!\211\203 \211BB\262\305\306\"\303U\2030 	\2030 \307\310#\210T\262\266A\202 \210	\203E \307\310\211#\210)\207" [gc-cons-percentage elisp-refs-verbose 0.8 0 nil mod 10 message "Searched %s/%s files"] 12 (#$ . 16088)])#@348 Find references to SYMBOL in all loaded files; call MATCH-FN on each buffer.
When PATH-PREFIX, limit to loaded files whose path starts with that prefix.

Display the results in a hyperlinked buffer.

MATCH-FN should return a list where each element takes the form:
(form start-pos end-pos).

(fn SYMBOL DESCRIPTION MATCH-FN &optional PATH-PREFIX)
(defalias 'elisp-refs--search #[1027 "\300 \203+ \301\302\203% \211A\262\242\303\"\203  \211B\262\210T\202	 \266\237\202, \211\304\305\"\306\307\"\216\310\"\311G	%)\207" [elisp-refs--loaded-paths nil 0 s-starts-with? mapcar elisp-refs--contents-buffer make-closure #[0 "\300\301\205 \211A\262\242\302!\266T\202 \207" [V0 0 kill-buffer] 5] elisp-refs--search-1 elisp-refs--show-results] 14 (#$ . 16680)])#@218 Read an interned symbol from the minibuffer,
defaulting to the symbol at point. PROMPT is the string to prompt
with.

If FILTER is given, only offer symbols where (FILTER sym) returns
t.

(fn PROMPT &optional FILTER)#@10 

(fn _)
(defalias 'elisp-refs--completing-read-symbol #[513 "\211\206 \300\301\302\303!\304\211\211\211\305\306!\211\205  	\301!!\205  \211\262&!\207" [#[257 "\300\207" [t] 2 (#$ . 17689)] read completing-read elisp-refs--filter-obarray nil thing-at-point symbol] 15 (#$ . 17467)])#@256 Display all the references to function SYMBOL, in all loaded
elisp files.

If called with a prefix, prompt for a directory to limit the search.

This searches for functions, not macros. For that, see
`elisp-refs-macro'.

(fn SYMBOL &optional PATH-PREFIX)#@12 

(fn BUF)
(defalias 'elisp-refs-function #[513 "\300!\204 \301!\203 \302\303\"\210\202 \302\304\"\210\305\306\307\"\310\311\"$\207" [functionp macrop user-error "%s is a macro. Did you mean elisp-refs-macro?" "%s is not a function. Did you mean elisp-refs-symbol?" elisp-refs--search elisp-refs--describe-button function make-closure #[257 "\301\300\302#\207" [V0 elisp-refs--read-and-find elisp-refs--function-p] 5 (#$ . 18245)]] 8 (#$ . 17985) (byte-code "\301\302\303\"\205 \304\305!D\207" [current-prefix-arg elisp-refs--completing-read-symbol "Function: " functionp read-directory-name "Limit search to loaded files in: "] 3)])#@256 Display all the references to macro SYMBOL, in all loaded
elisp files.

If called with a prefix, prompt for a directory to limit the search.

This searches for macros, not functions. For that, see
`elisp-refs-function'.

(fn SYMBOL &optional PATH-PREFIX)
(defalias 'elisp-refs-macro #[513 "\300!\204 \301!\203 \302\303\"\210\202 \302\304\"\210\305\306\307\"\310\311\"$\207" [macrop functionp user-error "%s is a function. Did you mean elisp-refs-function?" "%s is not a function. Did you mean elisp-refs-symbol?" elisp-refs--search elisp-refs--describe-button macro make-closure #[257 "\301\300\302#\207" [V0 elisp-refs--read-and-find elisp-refs--macro-p] 5 (#$ . 18245)]] 8 (#$ . 18900) (byte-code "\301\302\303\"\205 \304\305!D\207" [current-prefix-arg elisp-refs--completing-read-symbol "Macro: " macrop read-directory-name "Limit search to loaded files in: "] 3)])#@184 Display all the references to special form SYMBOL, in all loaded
elisp files.

If called with a prefix, prompt for a directory to limit the search.

(fn SYMBOL &optional PATH-PREFIX)
(defalias 'elisp-refs-special #[513 "\300\301\302\"\303\304\"$\207" [elisp-refs--search elisp-refs--describe-button special-form make-closure #[257 "\301\300\302#\207" [V0 elisp-refs--read-and-find elisp-refs--special-p] 5 (#$ . 18245)]] 8 (#$ . 19790) (byte-code "\301\302\303\"\205 \304\305!D\207" [current-prefix-arg elisp-refs--completing-read-symbol "Special form: " special-form-p read-directory-name "Limit search to loaded files in: "] 3)])#@180 Display all the references to variable SYMBOL, in all loaded
elisp files.

If called with a prefix, prompt for a directory to limit the search.

(fn SYMBOL &optional PATH-PREFIX)
(defalias 'elisp-refs-variable #[513 "\300\301\302\"\303\304\"$\207" [elisp-refs--search elisp-refs--describe-button variable make-closure #[257 "\301\300\302#\207" [V0 elisp-refs--read-and-find elisp-refs--variable-p] 5 (#$ . 18245)]] 8 (#$ . 20436) (byte-code "\301\302!\205\n \303\304!D\207" [current-prefix-arg elisp-refs--completing-read-symbol "Variable: " read-directory-name "Limit search to loaded files in: "] 3)])#@170 Display all the references to SYMBOL in all loaded elisp files.

If called with a prefix, prompt for a directory to limit the
search.

(fn SYMBOL &optional PATH-PREFIX)
(defalias 'elisp-refs-symbol #[513 "\300\301\302\"\303\304\"$\207" [elisp-refs--search elisp-refs--describe-button symbol make-closure #[257 "\301\300\"\207" [V0 elisp-refs--read-and-find-symbol] 4 (#$ . 18245)]] 8 (#$ . 21053) (byte-code "\301\302!\205\n \303\304!D\207" [current-prefix-arg elisp-refs--completing-read-symbol "Symbol: " read-directory-name "Limit search to loaded files in: "] 3)])#@31 Keymap for `elisp-refs-mode'.
(defvar elisp-refs-mode-map (byte-code "\301 \302\"\210\303\304\305#\210\303\306\307#\210\303\310\305#\210\303\311\307#\210\303\312\313#\210\207" [special-mode-map make-sparse-keymap set-keymap-parent define-key [tab] elisp-refs-next-match [backtab] elisp-refs-prev-match "n" "p" "" elisp-refs-visit-match] 5) (#$ . 21634))
(defvar elisp-refs-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [elisp-refs-mode-hook variable-documentation put "Hook run after entering `elisp-refs-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp elisp-refs-mode-map definition-name elisp-refs-mode] 4)
(defvar elisp-refs-mode-map (make-sparse-keymap))#@239 Major mode for refs results buffers.

In addition to any hooks its parent mode `special-mode' might have run, this
mode runs the hook `elisp-refs-mode-hook', as the final or penultimate step
during initialization.

\{elisp-refs-mode-map}
(byte-code "\301\302N\204 \303\301\302\304\305!#\210\306\307!\204* \303\307\310\311#\210\312\307\306\307!\203& \313\202( \314 \"\210\307\302N\2048 \303\307\302\304\315!#\210\306\300!\204X \303\300\310\311#\210\312\300\306\300!\203P \313\202V \316\300\313\"\210\"\210\300\302N\204f \303\300\302\304\317!#\210\320\321!\203t \321\311\322\"\210\202z \303\311\323\322#\210\313\207" [elisp-refs-mode-abbrev-table elisp-refs-mode-map variable-documentation put purecopy "Keymap for `elisp-refs-mode'." boundp elisp-refs-mode-syntax-table definition-name elisp-refs-mode defvar-1 nil make-syntax-table "Syntax table for `elisp-refs-mode'." define-abbrev-table "Abbrev table for `elisp-refs-mode'." fboundp derived-mode-set-parent special-mode derived-mode-parent] 5)
(defalias 'elisp-refs-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203 \314\311\313\310\313N#\210\315!\204' \316\317 \"\210\320\f!\211\2035 \211\321 =\203; \322\f\323 \"\210\210\324\325\"\204R =\204R \326\325C#\210\327!\210\330\f!\210)\331\332!\207" [delay-mode-hooks major-mode mode-name elisp-refs-mode-map elisp-refs-mode-syntax-table elisp-refs-mode-abbrev-table make-local-variable t special-mode elisp-refs-mode "Refs" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table run-mode-hooks elisp-refs-mode-hook local-abbrev-table] 5 (#$ . 22465) nil])#@122 Go to the search result at point.
Open file with function OPEN_FN. `find-file` or `find-file-other-window`

(fn OPEN-FN)
(defalias 'elisp--refs-visit-match #[257 "\301`\302\"\301`\303\"\301`\304\"i\305\204 \306\307!\210\212\301`\303\"\232\203' \305y\210T\202 )!\210b\210\211y\210\310 \210\\\311\211W\205T \312\313!\203M \211\\\262\202N T\314u\210\2029 \207" [tab-width get-text-property elisp-refs-path elisp-refs-start-pos elisp-refs-unindented -1 user-error "No match here" beginning-of-line 0 looking-at "	" 1] 10 (#$ . 24212) nil])#@34 Goto the search result at point.
(defalias 'elisp-refs-visit-match #[0 "\300\301!\207" [elisp--refs-visit-match find-file] 2 (#$ . 24765) nil])#@61 Goto the search result at point, opening in another window.
(defalias 'elisp-refs-visit-match-other-window #[0 "\300\301!\207" [elisp--refs-visit-match find-file-other-window] 2 (#$ . 24914) nil])#@93 Move point one match forwards.
If DIRECTION is -1, moves backwards instead.

(fn DIRECTION)
(defalias 'elisp-refs--move-to-match #[257 "`\300\301\"\302\3031T \3042) \300`\301\"\262\211\203# \232\204# \305\304\302\"\210u\210\202 \210\300`\301\"\300`S\301\"\232\203= \306u\210\202* \307\310!\204L \300`\311\"\312=\205R \313u\210\202= 0\207b\210\314\315\302\"\207" [get-text-property elisp-refs-start-pos nil (end-of-buffer) done throw -1 looking-at " " face font-lock-comment-face 1 signal end-of-buffer] 8 (#$ . 25116)])#@56 Move to the previous search result in the Refs buffer.
(defalias 'elisp-refs-prev-match #[0 "\300\301!\207" [elisp-refs--move-to-match -1] 2 (#$ . 25648) nil])#@52 Move to the next search result in the Refs buffer.
(defalias 'elisp-refs-next-match #[0 "\300\301!\207" [elisp-refs--move-to-match 1] 2 (#$ . 25813) nil])
(provide 'elisp-refs)