;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301!\210\300\302!\210\300\303!\210\304\305\306\307\310\311\312\313\314\315&	\210\316\317\320\321\322DD\323\310\324\325\326&\210\316\327\320\321\330DD\331\325\321%\210\316\332\320\321\333DD\334\325\321%\210\316\335\320\321\336DD\337\325\321%\207" [require thingatpt pp browse-url custom-declare-group quickurl nil "Insert a URL based on text at point in buffer." :version "21.1" :group abbrev :prefix "quickurl-" custom-declare-variable quickurl-url-file funcall function #[0 "\300\301\302\"\207" [locate-user-emacs-file "quickurls" ".quickurls"] 3 #1=""] "File that contains the URL list." "24.4" :type file quickurl-format-function #[0 "\300\207" [quickurl-format-url] 1 #1#] "Function to format the URL before insertion into the current buffer." quickurl-sort-function #[0 "\300\207" [quickurl-sort-urls] 1 #1#] "Function to sort the URL list." quickurl-grab-lookup-function #[0 "\300\207" [current-word] 1 #1#] "Function to grab the thing to lookup."] 10)
#@65 Default function for `quickurl-assoc-function'.

(fn KEY ALIST)
(defalias 'quickurl--assoc-function #[514 "\300\301#\207" [assoc-string t] 6 (#$ . 1061)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\303&\210\300\311\302\303\312DD\313\310\314%\210\300\315\302\303\316DD\317\310\320%\210\300\321\302\303\322DD\323\310\320%\210\300\324\302\303\325DD\326\310\327%\207" [custom-declare-variable quickurl-assoc-function funcall function #[0 "\300\207" [quickurl--assoc-function] 1 #1=""] "Function to use for alist lookup into `quickurl-urls'." :version "26.1" :type quickurl-completion-ignore-case #[0 "\300\207" [t] 1 #1#] "Should `quickurl-ask' ignore case when doing the input lookup?" boolean quickurl-prefix #[0 "\300\207" [";; -*- lisp -*-\n\n"] 1 #1#] "Text to write to `quickurl-url-file' before writing the URL list." string quickurl-postfix #[0 "\300\207" [#1#] 1 #1#] "Text to write to `quickurl-url-file' after writing the URL list.\n\nSee the constant `quickurl-reread-hook-postfix' for some example text that\ncould be used here." quickurl-list-mode-hook #[0 "\300\207" [nil] 1 #1#] "Hooks for `quickurl-list-mode'." hook] 8)
#@339 Example `quickurl-postfix' text that adds a local variable to the
`quickurl-url-file' so that if you edit it by hand it will ensure that
`quickurl-urls' is updated with the new URL list.

To make use of this do something like:

  (setq quickurl-postfix quickurl-reread-hook-postfix)

in your init file (after loading/requiring quickurl).
(defconst quickurl-reread-hook-postfix "\n;; Local Variables:\n;; eval: (progn (require 'quickurl) (add-hook 'write-file-functions (lambda () (quickurl-read) nil) nil t))\n;; End:\n" (#$ . 2213))
#@55 URL alist for use with `quickurl' and `quickurl-ask'.
(defvar quickurl-urls nil (#$ . 2753))
#@49 Local keymap for a `quickurl-list-mode' buffer.
(defvar quickurl-list-mode-map (byte-code "\300 \301
\302\303#\210\301
\304\305#\210\301
\306\307#\210\301
\310\311#\210\301
\312\313#\210\301
\314\315#\210\301
\316\317#\210\301
\320\317#\210\301
\321\322#\210\207" [make-sparse-keymap define-key "a" quickurl-list-add-url [(control m)] quickurl-list-insert-url "u" quickurl-list-insert-naked-url " " quickurl-list-insert-with-lookup "l" quickurl-list-insert-lookup "d" quickurl-list-insert-with-desc [(control g)] quickurl-list-quit "q" [mouse-2] quickurl-list-mouse-select] 5) (#$ . 2852))
#@34 Name for the URL listing buffer.
(defvar quickurl-list-buffer-name "*quickurl-list*" (#$ . 3448))
#@51 `current-buffer' when `quickurl-list' was called.
(defvar quickurl-list-last-buffer nil (#$ . 3552))
#@40 Does the URL have a comment?

(fn URL)
(defalias 'quickurl-url-commented-p #[257 "\211A<\207" [] 2 (#$ . 3659)])
#@94 Create a URL from KEYWORD, URL and (optionally) COMMENT.

(fn KEYWORD URL &optional COMMENT)
(defalias 'quickurl-make-url #[770 "\211\203\211G\300U\204E\207B\207" [0] 6 (#$ . 3778)])
(defalias 'quickurl-url-keyword 'car "Return the keyword for the URL.\n\n(fn URL)")
#@91 Return the actual URL of the URL.

Note that this function is a setfable place.

(fn URL)
(defalias 'quickurl-url-url #[257 "\300
!\203\n\211A@\207\211A\207" [quickurl-url-commented-p] 3 (#$ . 4060)])
(byte-code "\300\301\302\303#\300\207" [function-put quickurl-url-url gv-expander #[385 "\300\301\302$\207" [gv--defsetter quickurl-url-url #[514 "\300\301\302D\303D\304DFE\207" [setf if quickurl-url-commented-p cadr cdr] 8 "\n\n(fn STORE URL)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@146 Get the comment from a URL.

If the URL has no comment an empty string is returned.  Also note
that this function is a setfable place.

(fn URL)
(defalias 'quickurl-url-comment #[257 "\300
!\203\n\301
8\207\302\207" [quickurl-url-commented-p 2 ""] 3 (#$ . 4554)])
(byte-code "\300\301\302\303#\300\207" [function-put quickurl-url-comment gv-expander #[385 "\300\301\302$\207" [gv--defsetter quickurl-url-comment #[514 "\300\301D\300\302\303DD\304\305D\306DE\304\307\310EEF\311\302\303DD\304\305D\312\305	D\nEEEF\207" [if quickurl-url-commented-p zerop length setf cdr cadr nth 2 unless list] 12 "\n\n(fn STORE URL)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@129 Return a description for the URL.

If the URL has a comment then this is returned, otherwise the keyword is
returned.

(fn URL)
(defalias 'quickurl-url-description #[257 "\300
!\211G\301U\203\302!\207\207" [quickurl-url-comment 0 quickurl-url-keyword] 4 (#$ . 5231)])
#@12 

(fn URL)
(defalias 'quickurl-format-url #[257 "\300\301\302!\"\207" [format "<URL:%s>" quickurl-url-url] 5 (#$ . 5508)])
#@77 Sort URLs in LIST according to their `quickurl-url-description'.

(fn LIST)
(defalias 'quickurl-sort-urls #[257 "\300
\301\"\207" [sort #[514 "\300!\227\300!\227\231\207" [quickurl-url-description] 5 "\n\n(fn X Y)"]] 4 (#$ . 5638)])
#@239 `read' the URL list from BUFFER into `quickurl-urls'.

BUFFER, if nil, defaults to current buffer.
Note that this function moves point to `point-min' before doing the `read'
It also restores point after the `read'.

(fn &optional BUFFER)
(defalias 'quickurl-read #[256 "\212eb\210\302\206p!!\211)\207" [quickurl-sort-function quickurl-urls read] 4 (#$ . 5880)])
#@64 Load the contents of `quickurl-url-file' into `quickurl-urls'.
(defalias 'quickurl-load-urls #[0 "\301!\205\302\303\304\"r\211q\210\305\306\"\216\307!\210\310 *\262
\207" [quickurl-url-file file-exists-p generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] insert-file-contents quickurl-read] 4 (#$ . 6253)])
#@62 Save the contents of `quickurl-urls' to `quickurl-url-file'.
(defalias 'quickurl-save-urls #[0 "\306\307\310\"r\211q\210\311\312\"\216p\313\314\n!\210\315!\210\314\f!\210\316ed
\313\317%,\207" [print-length standard-output quickurl-prefix quickurl-urls quickurl-postfix quickurl-url-file generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] nil princ pp write-region 0] 7 (#$ . 6632)])
#@266 Return URL associated with key LOOKUP.

The lookup is done by looking in the alist `quickurl-urls' and the `cons'
for the URL is returned.  The actual method used to look into the alist
depends on the setting of the variable `quickurl-assoc-function'.

(fn LOOKUP)
(defalias 'quickurl-find-url #[257 "
	\"\207" [quickurl-assoc-function quickurl-urls] 4 (#$ . 7088)])
#@160 Insert URL, formatted using `quickurl-format-function'.

Also display a `message' saying what the URL was unless SILENT is non-nil.

(fn URL &optional SILENT)
(defalias 'quickurl-insert #[513 "!c\210\211?\205\301\302\303!\"\207" [quickurl-format-function message "Found %s" quickurl-url-url] 6 (#$ . 7463)])
#@207 Insert a URL based on LOOKUP.

If not supplied LOOKUP is taken to be the word at point in the current
buffer, this default action can be modified via
`quickurl-grab-lookup-function'.

(fn &optional LOOKUP)
(defalias 'quickurl #[256 "\211\204\f \211\262\205/\301 \210\302
!\211\204\303\304\"\202-\305\306!\203'\307\306!\210\310c\210\311
!\262
\207" [quickurl-grab-lookup-function quickurl-load-urls quickurl-find-url error "No URL associated with \"%s\"" looking-at "\\w" skip-syntax-forward " " quickurl-insert] 5 (#$ . 7783) nil])
#@76 Insert a URL, with `completing-read' prompt, based on LOOKUP.

(fn LOOKUP)
(defalias 'quickurl-ask #[257 "\300
!\211\205\n\301
!\207" [quickurl-find-url quickurl-insert] 4 (#$ . 8330) (byte-code "\303 \210\304\305\n\306\307$)C\207" [quickurl-completion-ignore-case completion-ignore-case quickurl-urls quickurl-load-urls completing-read "Lookup: " nil t] 5)])
#@362 Attempt to grab a word/URL pair from point in the current buffer.

Point should be somewhere on the URL and the word is taken to be the thing
that is returned from calling `quickurl-grab-lookup-function' once a
`backward-word' has been issued at the start of the URL.

It is assumed that the URL is either "unguarded" or is wrapped inside an
<URL:...> wrapper.
(defalias 'quickurl-grab-url #[0 "\302\303!\211\205=\212\304\303!\210\305!\203\306\307!\210\310\311!\210	 \211\205:\312\313\314\315\"r\211q\210\316\317\"\216c\210\320ed\"*\262
\"\262
)\207" [thing-at-point-markedup-url-regexp quickurl-grab-lookup-function thing-at-point url beginning-of-thing thing-at-point-looking-at search-backward "<URL:" backward-word-strictly 1 quickurl-make-url generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] buffer-substring-no-properties] 7 (#$ . 8700)])
#@181 Allow the user to interactively add a new URL associated with WORD.

See `quickurl-grab-url' for details on how the default word/URL combination
is decided.

(fn WORD URL COMMENT)
(defalias 'quickurl-add-url #[771 "G\303U\203\304\305!\207\306 \210\307!\211\203)\310\311!\203%\312\313\314\"!\202*\315\202*\315\211\205\230
\203v\316!\203@
A\240\210\202D
\241\210\316!\203eG\303U\203Z
\211A@\241\210\202~
AA\211\240\266\202~G\303U\204~
\211AD\241\210\202~\317#B	!\320 \210\321\n!\203\216\322 \210\310\311!\205\230\323\324\"\207" [quickurl-urls quickurl-sort-function quickurl-list-buffer-name 0 error "You must specify a WORD for lookup" quickurl-load-urls quickurl-find-url called-interactively-p interactive y-or-n-p format "\"%s\" exists, replace URL? " t quickurl-url-commented-p quickurl-make-url quickurl-save-urls get-buffer quickurl-list-populate-buffer message "Added %s"] 9 (#$ . 9623) (byte-code "\300 \301\302\303!\"\301\304\305!\"\301\306\307!\"E\207" [quickurl-grab-url read-string "Word: " quickurl-url-keyword "URL: " quickurl-url-url "Comment: " quickurl-url-comment] 7)])
#@216 Browse the URL associated with LOOKUP.

If not supplied LOOKUP is taken to be the word at point in the
current buffer, this default action can be modified via
`quickurl-grab-lookup-function'.

(fn &optional LOOKUP)
(defalias 'quickurl-browse-url #[256 "\211\204\f \211\262\205$\301 \210\302
!\211\203\303\304!!\202\"\305\306\"\262
\207" [quickurl-grab-lookup-function quickurl-load-urls quickurl-find-url browse-url quickurl-url-url error "No URL associated with \"%s\""] 5 (#$ . 10759) nil])
#@85 Browse the URL, with `completing-read' prompt, associated with LOOKUP.

(fn LOOKUP)
(defalias 'quickurl-browse-url-ask #[257 "\300
!\211\205\f\301\302!!\207" [quickurl-find-url browse-url quickurl-url-url] 5 (#$ . 11267) (byte-code "\301 \210\302\303\304\305$C\207" [quickurl-urls quickurl-load-urls completing-read "Browse: " nil t] 5)])
#@58 Pull `quickurl-url-file' into a buffer for hand editing.
(defalias 'quickurl-edit-urls #[0 "\301!\207" [quickurl-url-file find-file] 2 (#$ . 11615) nil])
(defvar quickurl-list-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [quickurl-list-mode-hook variable-documentation put "Hook run after entering Quickurl mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp quickurl-list-mode-map definition-name quickurl-list-mode] 4)
(defvar quickurl-list-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [quickurl-list-mode-abbrev-table quickurl-list-mode-map variable-documentation put purecopy "Keymap for `quickurl-list-mode'." boundp quickurl-list-mode-syntax-table definition-name quickurl-list-mode (lambda (#1=#:def-tmp-var) (defvar quickurl-list-mode-syntax-table #1#)) make-syntax-table "Syntax table for `quickurl-list-mode'." (lambda (#1#) (defvar quickurl-list-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `quickurl-list-mode'." derived-mode-parent special-mode] 5)
#@299 A mode for browsing the quickurl URL list.

The key bindings for `quickurl-list-mode' are:

\{quickurl-list-mode-map}

In addition to any hooks its parent mode `special-mode' might have
run, this mode runs the hook `quickurl-list-mode-hook', as the final
or penultimate step during initialization.
(defalias 'quickurl-list-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
\325C#\210\327!\210\330\f!\210
\307)\331\332!\207" [delay-mode-hooks major-mode mode-name quickurl-list-mode-map quickurl-list-mode-syntax-table quickurl-list-mode-abbrev-table make-local-variable t special-mode quickurl-list-mode "Quickurl" 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 quickurl-list-mode-hook local-abbrev-table truncate-lines] 5 (#$ . 13018) nil])
#@73 Display `quickurl-list' as a formatted list using `quickurl-list-mode'.
(defalias 'quickurl-list #[0 "\302 \210\303 \230\204\fp\304!\210\305 \210\306 \207" [quickurl-list-buffer-name quickurl-list-last-buffer quickurl-load-urls buffer-name pop-to-buffer quickurl-list-populate-buffer quickurl-list-mode] 2 (#$ . 14107) nil])
#@38 Populate the `quickurl-list' buffer.
(defalias 'quickurl-list-populate-buffer #[0 "r\303!q\210	\304\211:\203!@\262\305!G
B\262
A\262\202	\211\237\266\203\206*\306C\307\310\311\312\"\"\313\314 \210	\211\203X\211@`\307\305!\315!#c\210\316
`S\317#\266
A\266\202\2027\210eb)\266\202)\207" [quickurl-list-buffer-name quickurl-urls inhibit-read-only get-buffer nil quickurl-url-description 20 format "%%-%ds %%s\n" apply max t erase-buffer quickurl-url-url add-text-properties (mouse-face highlight help-echo "mouse-2: insert this URL")] 10 (#$ . 14442)])
#@90 Wrapper for `quickurl-add-url' that doesn't guess the parameters.

(fn WORD URL COMMENT)
(defalias 'quickurl-list-add-url #[771 "\300#\207" [quickurl-add-url] 7 (#$ . 15016) "sWord: \nsURL: \nsComment: "])
#@52 Kill the buffer named `quickurl-list-buffer-name'.
(defalias 'quickurl-list-quit #[0 "\300\301!\207" [quit-window t] 2 (#$ . 15231) nil])
#@51 Select the URL under the mouse click.

(fn EVENT)
(defalias 'quickurl-list-mouse-select #[257 "\300\301!!b\210\302 \207" [posn-point event-end quickurl-list-insert-url] 4 (#$ . 15375) "e"])
#@364 Insert the URL under cursor into `quickurl-list-last-buffer'.
TYPE dictates what will be inserted, options are:
  `url'         - Insert the URL as <URL:url>
  `naked-url'   - Insert the URL with no formatting
  `with-lookup' - Insert "lookup <URL:url>"
  `with-desc'   - Insert "description <URL:url>"
  `lookup'      - Insert the lookup for that URL

(fn TYPE)
(defalias 'quickurl-list-insert #[257 "\303e\304 \"8\211\203Dr	q\210
\305\267\202?\n
!\202@\306
!\202@\307\310\311!\306!#\202@\307\312\313!\306!#\202@\311
!\202@\314c\210)\207\315\316!\210\207" [quickurl-urls quickurl-list-last-buffer quickurl-format-function count-lines line-beginning-position #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (url 21 naked-url 27 with-lookup 33 with-desc 45 lookup 57)) quickurl-url-url format "%s <URL:%s>" quickurl-url-keyword "%S <URL:%s>" quickurl-url-description nil error "No URL details on that line"] 7 (#$ . 15573)])
#@87 Macro to make a key-response function for use in `quickurl-list-mode-map'.

(fn TYPE)
(defalias 'quickurl-list-make-inserter '(macro . #[257 "\300\301\302\303\"!\304\302\305\"\306\307\310\311DD\312BB\257\207" [defun intern format "quickurl-list-insert-%S" nil "Insert the result of calling `quickurl-list-insert' with `%s'." (interactive) when quickurl-list-insert quote ((quickurl-list-quit))] 10 (#$ . 16552)]))
#@65 Insert the result of calling `quickurl-list-insert' with `url'.
(defalias 'quickurl-list-insert-url #[0 "\300\301!\205\302 \207" [quickurl-list-insert url quickurl-list-quit] 2 (#$ . 16977) nil])
#@71 Insert the result of calling `quickurl-list-insert' with `naked-url'.
(defalias 'quickurl-list-insert-naked-url #[0 "\300\301!\205\302 \207" [quickurl-list-insert naked-url quickurl-list-quit] 2 (#$ . 17181) nil])
#@73 Insert the result of calling `quickurl-list-insert' with `with-lookup'.
(defalias 'quickurl-list-insert-with-lookup #[0 "\300\301!\205\302 \207" [quickurl-list-insert with-lookup quickurl-list-quit] 2 (#$ . 17403) nil])
#@71 Insert the result of calling `quickurl-list-insert' with `with-desc'.
(defalias 'quickurl-list-insert-with-desc #[0 "\300\301!\205\302 \207" [quickurl-list-insert with-desc quickurl-list-quit] 2 (#$ . 17631) nil])
#@68 Insert the result of calling `quickurl-list-insert' with `lookup'.
(defalias 'quickurl-list-insert-lookup #[0 "\300\301!\205\302 \207" [quickurl-list-insert lookup quickurl-list-quit] 2 (#$ . 17853) nil])
(provide 'quickurl)