elpa/helm-core-20191201.1013/helm-lib.elc

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

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\302\303\304\305\306DD\307\310\311\312\313&\210\302\314\304\305\315DD\316\312\305\310\311&\210\302\317\304\305\320DD\321\310\311\312\322&\210\302\323\304\305\324DD\325\312\313\310\326&\207" [require cl-lib custom-declare-variable helm-file-globstar funcall function #[0 "\300\207" [t] 1] "Same as globstar bash shopt option.\nWhen non--nil a pattern beginning with two stars will expand recursively.\nDirectories expansion is not supported yet." :group helm :type boolean helm-yank-text-at-point-function #[0 "\300\207" [nil] 1] "The function used to forward point with `helm-yank-text-at-point'.\nWith a nil value, fallback to default `forward-word'.\nThe function should take one arg, an integer like `forward-word'.\nNOTE: Using `forward-symbol' here is not very useful as it is already\nprovided by \\<helm-map>\\[next-history-element]." helm-scroll-amount #[0 "\300\207" [nil] 1] "Scroll amount when scrolling other window in a helm session.\nIt is used by `helm-scroll-other-window'\nand `helm-scroll-other-window-down'.\n\nIf you prefer scrolling line by line, set this value to 1." integer helm-help-full-frame #[0 "\300\207" [t] 1] "Display help window in full frame when non nil.\n\nEven when `nil' probably the same result (full frame)\ncan be reach by tweaking `display-buffer-alist' but it is\nmuch more convenient to use a simple boolean value here." helm-help] 8)
(defvar helm-ff--boring-regexp nil)
#@16 

(fn VAR VAL)
(defalias 'helm-ff--setup-boring-regex #[514 "L\210\301!@\302!\303\304:\2035@\262\305\306\"\203'\211\307PP\262\202.\211\310PP\262A\262\202
\211\305\306\"\203C\304\202D\311Q\266\204\211\207" [helm-ff--boring-regexp last butlast nil "" string-match "\\$\\'" "\\|" "$\\|" "$"] 11 (#$ . 1852)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\306\317\310\303&\210\300\320\302\303\321DD\322\306\317\310\303&\207" [custom-declare-variable helm-boring-file-regexp-list funcall function #[0 "\301\302\"\207" [completion-ignored-extensions mapcar #[257 "\301!\302\303\304\305#)\266\203\203\211\306P\202\211\307\310O\311P\207" [inhibit-changing-match-data regexp-quote "[^/]$" nil t string-match "$" 0 -1 "\\(/\\|$\\)"] 9 "\n\n(fn F)"]] 3] "A list of regexps matching boring files.\n\nThis list is build by default on `completion-ignored-extensions'.\nThe directory names should end with \"/?\" e.g. \"\\.git/?\" and the\nfile names should end with \"$\" e.g. \"\\.o$\".\n\nThese regexps may be used to match the entire path, not just the file\nname, so for example to ignore files with a prefix \".bak.\", use\n\"\\.bak\\..*$\" as the regexp.\n\nNOTE: When modifying this, be sure to use customize interface or the\ncustomize functions e.g. `customize-set-variable' and NOT `setq'." :group helm-files :type (repeat (choice regexp)) :set helm-ff--setup-boring-regex helm-describe-function-function #[0 "\300\207" [describe-function] 1] "Function used to describe functions in Helm." helm-elisp helm-describe-variable-function #[0 "\300\207" [describe-variable] 1] "Function used to describe variables in Helm."] 10)
(defvar helm-yank-point nil)
#@51 The input pattern used to update the helm buffer.
(defvar helm-pattern "" (#$ . 3592))
#@29 Buffer showing completions.
(defvar helm-buffer "*helm*" (#$ . 3685))
#@40 Current buffer when `helm' is invoked.
(defvar helm-current-buffer nil (#$ . 3761))
(defvar helm-suspend-update-flag nil)
#@25 Buffer showing actions.
(defvar helm-action-buffer "*helm action*" (#$ . 3889))
#@294 Add the face property to the text from START to END.
It is a compatibility function which behave exactly like
`add-face-text-property' if available otherwise like `add-text-properties'.
When only `add-text-properties' is available APPEND is ignored.

(fn BEG END FACE &optional APPEND OBJECT)
(defalias 'helm-add-face-text-properties #[1283 "\300\301!\203\301%\207\302\303D$\207" [fboundp add-face-text-property add-text-properties face] 11 (#$ . 3976)])
(defalias 'helm--advice-wdired-finish-edit #[0 "\306 \210\307\310\307\211\211\211\211\211\212\203\"\311\312!\203\"\313 \262\211A\262\211@\262	\203@\314\315!\203@\316 \262A\\\262\206>\211@\262db\210o\204\247\317\307\320\"\262\203\241\317 \262\232\203a\320\262\202\241\320\262\204qB\262\202\241\n\203\230\n\250\203~\n\202\213\n\203\212\321\"A\202\213\307\211\203\227\322!BB\210\322!BB\262\323y\210\202C)\203\265\324!\\\262\2030\f;\203\327\325\f!\204\327\204\327G\326U\203\327@A\202\f:\203\fA\203\203\f\327\330\"\fA\307\211:\203@\262\235\203\n\331\"B\262\202B\262A\262\202\357\211\237\266\204\241\210\310V\204&\332 \210\320\333!\210)\202=\320\334ed\335#\210\336\337!\210)\203F\340!\210\310V\203V\341\342\343	\"\307\"\210\266\344\307!\210\307\211%\207" [wdired-allow-to-redirect-links wdired-allow-to-change-permissions wdired-keep-marker-rename wdired-old-marks dired-directory inhibit-read-only wdired-change-to-dired-mode nil 0 fboundp make-symbolic-link wdired-do-symlink-changes boundp wdired-col-perm wdired-do-perm-changes wdired-get-filename t assoc substitute-in-file-name -1 wdired-do-renames file-directory-p 1 mapcar car assoc-default revert-buffer dired-mark-remembered remove-text-properties (old-name nil end-name nil old-link nil end-link nil end-perm nil old-perm nil perm-changed nil) message "(No changes to be performed)" wdired-flag-for-deletion dired-log-summary format "%d rename actions failed" set-buffer-modified-p buffer-undo-list] 16 nil nil])
#@29 

(fn &optional NO-DIR OLD)
(defalias 'helm--advice-wdired-get-filename #[512 "\300\211\211\212\301 \262\302 \210\303`\304\300$\262=\204N\203&\305\304\"\262\2023\303\306\"\262\307T\"\262\211\203N\3101G\311\312?D\"0\202L\312!\262\262\204`\204`\211\203d\313!\203d\211\202t\211\205t\211G\314V\205t\315\316 \")\207" [nil line-end-position beginning-of-line next-single-property-change old-name get-text-property end-name buffer-substring-no-properties (wrong-number-of-arguments) apply wdired-normalize-filename file-name-absolute-p 0 expand-file-name dired-current-directory] 10 (#$ . 6036)])
#@42 

(fn &optional LOCATION NOMSG ACTIVATE)
(defalias 'helm--advice-push-mark #[768 "\306\307!\203(\310\311 !\211\312\"B\210G	V\203(	\233@\313\211\223\210	S\233\313\241\210\311 \206/`p\223\210\310\311 !p\n\313\211\211:\203[@\262\314!\262=\204TB\262A\262\202;\211\237\266\205B\211GV\203w\n\233@\313\211\223\210S\n\233\313\241\210\204\212\f\204\212\315 \316V\204\212\317\320!\210\211\204\222
\204\230\321\306\307!!\210\313\207" [mark-ring mark-ring-max global-mark-ring global-mark-ring-max executing-kbd-macro transient-mark-mode mark t copy-marker mark-marker delete nil marker-buffer minibuffer-depth 0 message "Mark set" set-mark] 12 (#$ . 6668)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\207" [custom-declare-variable helm-advice-push-mark funcall function #[0 "\300\207" [t] 1] "Override `push-mark' with a version avoiding duplicates when non nil." :group helm :type boolean :set #[514 "L\210\211\203\300\301\302\303#\207\304\301\303\"\207" [advice-add push-mark :override helm--advice-push-mark advice-remove] 6 "\n\n(fn VAR VAL)"]] 10)
#@21 

(fn PROMPT GUESS)
(defalias 'helm-advice--ffap-read-file-or-url #[514 "\211\204\262\301!\203\302\303\211\304%\207\305!\204\"\306\307!!\262\310\311!\303\211\312!%\207" [default-directory ffap-url-p read-string nil t ffap-file-remote-p abbreviate-file-name expand-file-name read-file-name file-name-directory file-name-nondirectory] 9 (#$ . 7778)])
#@86 Bind the SYMBOLS to fresh uninterned symbols and eval BODY.

(fn SYMBOLS &rest BODY)
(defalias 'helm-with-gensyms '(macro . #[385 "\300\301\302\"BB\207" [let mapcar #[257 "\211\300\301\302DDDD\207" [cl-gensym symbol-name quote] 6 "\n\n(fn S)"]] 6 (#$ . 8150)]))
(byte-code "\300\301\302\303#\300\207" [function-put helm-with-gensyms lisp-indent-function 1] 4)
#@143 Returns the actual command in action.
Like `this-command' but return the real command,
and not `exit-minibuffer' or other unwanted functions.
(defalias 'helm-this-command #[0 "\300\301\302\211\303\302\304X\203W\305!\262A@\2629\2032\306!\2032>\2042\262\302\211\262\202M\307=\203LG\310V\203LAA@\262\302\211\262\202M\303\203WT\262\202\207" [(helm-maybe-exit-minibuffer helm-confirm-and-exit-minibuffer helm-exit-minibuffer exit-minibuffer) 1 nil t 50 backtrace-frame commandp call-interactively 2] 8 (#$ . 8520)])
#@320 A simple and faster replacement of CL `position'.

Returns ITEM first occurence position found in SEQ.
When SEQ is a string, ITEM have to be specified as a char.
Argument TEST when unspecified default to `eq'.
When argument ALL is non--nil return a list of all ITEM positions
found in SEQ.

(fn ITEM SEQ &key TEST ALL)
(defalias 'helm-position '(macro . #[642 "\300\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262\202
\304>A@\203.\305\262\202
\306\307@\"\210\202
\210;\203A\310\202B\311\312\313\314\315\316\317\320\f\317\321\322\323\324\325\326\327BB\320F\330\331BBBBBBBBBBBBBBBBB\262\207" [plist-member :test :all (:test :all :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:test :all)" across in cl-loop with deftest = 'eq for c index from 0 when funcall or (deftest) if (collect index into ls else return index finally return ls)] 24 (#$ . 9069)]))
#@47 Return an iterator object from SEQ.

(fn SEQ)
(defalias 'helm-iter-list #[257 "\211C\300\301\302\303\304!\305\"\306$\207" [make-byte-code 0 "\300\242@\300\211\242A\240\210\211\207" vconcat vector [] 3] 8 (#$ . 9991)])
#@38 Infinite iteration on SEQ.

(fn SEQ)
(defalias 'helm-iter-circular #[257 "\211C\300\301\302\303\304\"\305\"\306$\207" [make-byte-code 0 "\301\242@\301\211\242:\205\301\242A\211\211\206\300\262\262\240\210\211\207" vconcat vector [] 5] 9 (#$ . 10216)])
#@76 Infinite iteration of SEQ starting at ELM.

(fn SEQ ELM &key (TEST \='eq))
(defalias 'helm-iter-sub-next-circular #[642 "\300\301\"\206\302A@\211\2035\211@\303>\203\211AA\262\202\304>A@\203,\305\262\202\306\307@\"\210\202\210\310\305\311\305\312\305:\203m@\262\206M\"\203^\262\305\211\262\202_\312\203mA\262T\262\202=\203u\202v\211\266\207T\313\233\314\311#\"\315!\316\311\317\320\321!\322\"\323$\266\203\207" [plist-member :test (nil eq) (:test :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:test)" eq 0 t append cl-subseq helm-iter-circular make-byte-code "\301\300!\207" vconcat vector [helm-iter-next] 2] 14 (#$ . 10484)])
#@45 Return next elm of ITERATOR.

(fn ITERATOR)
(defalias 'helm-iter-next #[257 "\211\205\211 \207" [] 2 (#$ . 11205)])
#@211 Anaphoric version of `if'.
Like `if' but set the result of TEST-FORM in a temporary variable called `it'.
THEN-FORM and ELSE-FORMS are then excuted just like in `if'.

(fn TEST-FORM THEN-FORM &rest ELSE-FORMS)
(defalias 'helm-aif '(macro . #[642 "\300\301DC\302\301BBBE\207" [let it if] 9 (#$ . 11330)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put helm-aif lisp-indent-function 2 put edebug-form-spec t] 5)
#@248 Anaphoric version of `while'.
Same usage as `while' except that SEXP is bound to
a temporary variable called `it' at each turn.
An implicit nil block is bound to the loop so usage
of `cl-return' is possible to exit the loop.

(fn SEXP &rest BODY)
(defalias 'helm-awhile '(macro . #[385 "\300\301!\302\303BC\304\305\306\307	\310\nB\311\n\312BBFEEE\207" [cl-gensym "flag" let (t) cl-block nil while helm-aif progn setq (nil)] 15 (#$ . 11770)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put helm-awhile lisp-indent-function 1 put edebug-form-spec t] 5)
#@281 Anaphoric version of `cond'.
In each clause of CLAUSES, the result of the car of clause
is stored in a temporary variable called `it' and usable in the cdr
of this same clause.  Each `it' variable is independent of its clause.
The usage is the same as `cond'.

(fn &rest CLAUSES)
(defalias 'helm-acond '(macro . #[128 "\211\205,\300\301!@\302@DC\303\304\305\306DD\307AB\310BBB\311ABFE\262\262\207" [cl-gensym "sym" let helm-aif if cdr quote progn (it) helm-acond] 11 (#$ . 12353)]))
(put 'helm-acond 'edebug-form-spec 'cond)
#@147 Anaphoric version of `and'.
Each condition is bound to a temporary variable called `it' which is
usable in next condition.

(fn &rest CONDITIONS)
(defalias 'helm-aand '(macro . #[128 "\211\204\300\207\211A\204\211@\207\301@\302ABE\207" [t helm-aif helm-aand] 5 (#$ . 12898)]))
(put 'helm-aand 'edebug-form-spec '(&rest form))
#@252 A simple anaphoric `cl-case' implementation handling strings.
EXPR is bound to a temporary variable called `it' which is usable in
CLAUSES to refer to EXPR.
NOTE: Duplicate keys in CLAUSES are deliberately not handled.

(fn EXPR (KEYLIST BODY...)...)
(defalias 'helm-acase '(macro . #[385 "\211\205\"\211@\300\301\302@DD\303DD\304\305\306AB\307\303ABBFE\262\207" [let key quote it if (or (equal it key) (and (listp key) (member it key)) (eq key t)) progn helm-acase] 11 (#$ . 13237)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put helm-acase lisp-indent-function 1 put edebug-form-spec (form &rest (sexp body))] 5)
#@181 Transform string PATTERN in regexp for further fuzzy matching.
e.g helm.el$
    => "[^h]*h[^e]*e[^l]*l[^m]*m[^.]*[.][^e]*e[^l]*l$"
    ^helm.el$
    => "helm[.]el$".

(fn PATTERN)
(defalias 'helm--mapconcat-pattern #[257 "\300\301\"\211@\302\230\203 \303\304\305\306\307\310!\311\"\312\313%A\301#\2021\303\304\305\314\307\310!\315\"\316\313%\301#\207" [split-string-and-unquote "" "^" mapconcat make-byte-code 257 "\211\301\230\203\302\303\300\"\203\207\304!\207" vconcat vector ["$" string-match "$\\'" regexp-quote] 4 "\n\n(fn C)" "\211\301\230\203\302\303\300\"\203\207\304\305\306!#\207" ["$" string-match "$\\'" format "[^%s]*%s" regexp-quote] 6] 9 (#$ . 13887)])
(put 'helm--mapconcat-pattern 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn STRING)
(defalias 'helm--collect-pairs-in-string #[257 "\300\301\302#\303:\203!A\203@A@DB\262A\262\202\211\237\207" [split-string "" t nil] 5 (#$ . 14657)])
(put 'helm--collect-pairs-in-string 'byte-optimizer 'byte-compile-inline-expand)
#@164 Show long message during `helm' session in BUFNAME.
INSERT-CONTENT-FN is the function that insert
text to be displayed in BUFNAME.

(fn BUFNAME INSERT-CONTENT-FN)
(defalias 'helm-help-internal #[514 "\303 \304 \304 p\305\306\307\310\311\"\312\"\313$\216\314\315\"\210\316!\210\305\306\317\310\311\"\320\"\321$\216\322\323!q\210\324!\210\n\203B\325 \210ed|\210\326 \210\327 \210\212 \210)\330 \210\331 *\266\202\207" [helm-initial-frame helm-suspend-update-flag helm-help-full-frame current-frame-configuration selected-frame make-byte-code 0 "\302\300!\203\303\300\304\"\210\305\301!\205\301q\207" vconcat vector [frame-live-p select-frame norecord buffer-live-p] 3 select-frame norecord select-frame-set-input-focus "\303\301!\210\304\305\300!\207" [helm-suspend-update-flag raise-frame nil set-frame-configuration] 2 t get-buffer-create switch-to-buffer delete-other-windows org-mode org-mark-ring-push buffer-disable-undo helm-help-event-loop] 13 (#$ . 14922)])
#@15 

(fn AMOUNT)
(defalias 'helm-help-scroll-up #[257 "\3001\3011\302!00\2070\303\207\303\207" [(end-of-buffer) (beginning-of-buffer) scroll-up-command nil] 3 (#$ . 15915)])
#@15 

(fn AMOUNT)
(defalias 'helm-help-scroll-down #[257 "\3001\3011\302!00\2070\303\207\303\207" [(end-of-buffer) (beginning-of-buffer) scroll-down-command nil] 3 (#$ . 16097)])
(defalias 'helm-help-next-line #[0 "\3001\3011\302\303!00\2070\304\207\304\207" [(end-of-buffer) (beginning-of-buffer) call-interactively next-line nil] 2])
(defalias 'helm-help-previous-line #[0 "\3001\3011\302\303!00\2070\304\207\304\207" [(end-of-buffer) (beginning-of-buffer) call-interactively previous-line nil] 2])
(defalias 'helm-help-toggle-mark #[0 "\300 \203\301 \207\302\303\211\304#\207" [region-active-p deactivate-mark push-mark nil t] 4])
(defalias 'helm-help-event-loop #[0 "\302\303\304\305#\306\307\310!\311\3122\247\211\205\246\313!\211\203\237\314\315\"\203)\316	!\210\202\242\314\317\"\2037\320	!\210\202\242\321\322\"\203D\323 \210\202\242\321\324\"\203Q\325 \210\202\242\321\326\"\203_\327\330!\210\202\242\321\331\"\203m\327\332!\210\202\242\314\333\"\203{\327\334!\210\202\242\314\335\"\203\211\327\336!\210\202\242\314\337\"\203\226\340 \210\202\242\314\341\"\203\243\342 \210\202\242\321\343\"\203\261\327\344!\210\202\242\321\345\"\203\277\327\346!\210\202\242\321\347\"\203\315\327\350!\210\202\242\321\351\"\203\333\327\352!\210\202\242\321\353\"\203\351\327\354!\210\202\242\321\355\"\203\367\327\356!\210\202\242\321\357\"\203\360 \210\202\242\321\361\"\203\362 \210\202\242\321\363\"\203+\3641#\327\365!0\202'\210\202\242\210\202\242\321\366\"\203E\3671=\327\370!0\202A\210\202\242\210\202\242\321\371\"\203S\327\372!\210\202\242\321\373\"\203r\374!\211\247\203h\375 \210\202n\211\362!\266\210\202\242\321\376\"\203\214\377\201@ \201A \"\210\201B \210\202\242\321\201C\"\203\242\201D\312\306\"\210\202\242\306\262\210\2020\262)\207" [scroll-error-top-bottom helm-scroll-amount propertize "[SPC,C-v,next:ScrollUp  b,M-v,prior:ScrollDown TAB:Cycle M-TAB:All C-s/r:Isearch q:Quit]" face helm-helper nil helm-iter-circular (1 (16) (64)) t --cl-block-nil-- read-key memql (22 32 next) helm-help-scroll-up (134217846 98 prior) helm-help-scroll-down eql 19 isearch-forward 18 isearch-backward 1 call-interactively move-beginning-of-line 5 move-end-of-line (6 right) forward-char (2 left) backward-char (14 down) helm-help-next-line (16 up) helm-help-previous-line 134217825 backward-sentence 134217829 forward-sentence 134217830 forward-word 134217826 backward-word 134217790 end-of-buffer 134217788 beginning-of-buffer 67108896 helm-help-toggle-mark 9 org-cycle 13 (error) org-open-at-point 67108902 (error) org-mark-ring-goto 67108901 org-mark-ring-push 134217737 helm-iter-next org-content 134217847 copy-region-as-kill region-beginning region-end deactivate-mark 113 throw] 9])
#@26 

(fn CANDIDATES SOURCE)
(defalias 'helm-multiline-transformer #[514 "\300\301\302\303 \"!\304\211:\2031@\262\247\203%\305\"BB\262\202*B\262A\262\202\n\211\237\207" [helm-interpret-value assoc-default multiline helm-get-current-source nil helm--multiline-get-truncated-candidate] 9 (#$ . 18902)])
#@77 Truncate CANDIDATE when its length is > than OFFSET.

(fn CANDIDATE OFFSET)
(defalias 'helm--multiline-get-truncated-candidate #[514 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216c\210eb\210\203C\311 V\203C\312`\212u\210\313\314!\2034\2027\314P\262`){P\262\202E\315 *\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 buffer-size "[...]" looking-at "\n" buffer-string] 9 (#$ . 19224)])
#@89 Return a list of all single elements of sublists in SEQ.

(fn SEQ &optional OMIT-NULLS)
(defalias 'helm-flatten-list #[513 "\300C\300C\211\301\302\303\304\305#\306\"\307\310%\240\210\211\242!\266\211\242\237\207" [nil make-byte-code 257 "\211\303:\203D@\262\211\204\300\2048\211:\203.\304!\204.\211:\2038\211A\2038\211A:\2048\301\301\242B\240\210\202=\302\242!\210A\262\202\303\207" vconcat vector [nil functionp] 6 "\n\n(fn SEQ)"] 13 (#$ . 19718)])
#@101 If OBJ is a list (but not lambda), return itself.
Otherwise make a list with one element.

(fn OBJ)
(defalias 'helm-mklist #[257 "\211<\203\f\300!\204\f\207\211C\207" [functionp] 3 (#$ . 20203)])
#@629 Remove duplicates elements in list SEQ.

This is same as `remove-duplicates' but with memoisation.
It is much faster, especially in large lists.
A test function can be provided with TEST argument key.
Default is `eq'.
NOTE: Comparison of special elisp objects (e.g. markers etc...) fails
because their printed representations which are stored in hash-table
can't be compared with with the real object in SEQ.
This is a bug in `puthash' which store the printable representation of
object instead of storing the object itself, this to provide at the
end a printable representation of hashtable itself.

(fn SEQ &key (TEST \='eq))
(defalias 'helm-fast-remove-dups #[385 "\300\301\"\206\302A@\211\2035\211@\303>\203\211AA\262\202\304>A@\203,\305\262\202\306\307@\"\210\202\210\310\301\"\305\211:\203^@\262\311\"\204W\312\211#B\262A\262\202=\211\237\266\204\207" [plist-member :test (nil eq) (:test :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:test)" make-hash-table gethash puthash] 11 (#$ . 20409)])
#@69 Join all STRINGS using SEPARATOR.

(fn STRINGS &optional SEPARATOR)
(defalias 'helm--string-join #[513 "\300\301#\207" [mapconcat identity] 6 (#$ . 21483)])
(put 'helm--string-join 'byte-optimizer 'byte-compile-inline-expand)
#@84 Return a regexp which matches any of the regexps in REGEXP-LIST.

(fn REGEXP-LIST)
(defalias 'helm--concat-regexps #[257 "\211\203\300\301\302\303#\266\202\304Q\207\305\207" ["\\(?:" "\\)\\|\\(?:" mapconcat identity "\\)" "\\<\\>"] 8 (#$ . 21717)])
#@115 Remove entries which matches one of REGEXP-LIST from SEQ.

(fn SEQ BLACK-REGEXP-LIST &optional WHITE-REGEXP-LIST)
(defalias 'helm-skip-entries #[770 "\301!\301!\302\211:\203C@\262;\2037\302\303\304#)\266\203\2037\302\303\304#)\266\203\203<B\262A\262\202	\211\237\266\203\207" [inhibit-changing-match-data helm--concat-regexps nil t string-match] 15 (#$ . 21978)])
#@79 Check if one regexp in BLACK-LIST match DIRECTORY.

(fn DIRECTORY BLACK-LIST)
(defalias 'helm-boring-directory-p #[514 "\301\3022e\211\205d\303\304\305!!!\211\203]\211\306\230\203\307\302\310\"\210\310\301\310:\203M@\262\304	!\310\301\311#)\266\203\211\262?\211\262\203MA\262\202#\266\203\203W\307\302\301\"\210\211\262\202`\310\262\210\2020\207" [inhibit-changing-match-data t --cl-block-nil-- helm-basedir directory-file-name expand-file-name "/" throw nil string-match] 15 (#$ . 22377)])
#@95 Put shadow property on entries in SEQ matching a regexp in REGEXP-LIST.

(fn SEQ REGEXP-LIST)
(defalias 'helm-shadow-entries #[514 "\300\301\211:\203S@\262\301\302\301:\2035@\262;\205$\303\"\211\262?\211\262\2035A\262\202\266\203\203G\304\305#B\262\202LB\262A\262\202\211\237\266\203\207" [italic nil t string-match propertize face] 13 (#$ . 22903)])
#@70 Remove all elements of SEQ that don't match REGEXP.

(fn REGEXP SEQ)
(defalias 'helm-remove-if-not-match #[514 "\211\301\211\211:\203A@\2629\203\302!\202#:\203\"@\202#\262\301\303\304#)\266\203\203:B\262A\262\202\211\237\207" [inhibit-changing-match-data nil symbol-name t string-match] 13 (#$ . 23296)])
#@64 Remove all elements of SEQ that match REGEXP.

(fn REGEXP SEQ)
(defalias 'helm-remove-if-match #[514 "\211\301\211\211:\203A@\2629\203\302!\202#:\203\"@\202#\262\301\303\304#)\266\203\204:B\262A\262\202\211\237\207" [inhibit-changing-match-data nil symbol-name t string-match] 13 (#$ . 23636)])
#@294 `mapcar' for candidate-transformer.

ARGS is (cand1 cand2 ...) or ((disp1 . real1) (disp2 . real2) ...)

(helm-transform-mapcar 'upcase '("foo" "bar"))
=> ("FOO" "BAR")
(helm-transform-mapcar 'upcase '(("1st" . "foo") ("2nd" . "bar")))
=> (("1st" . "FOO") ("2nd" . "BAR"))

(fn FUNCTION ARGS)
(defalias 'helm-transform-mapcar #[514 "\211\300\211:\203-@\262:\203@A!BB\262\202&!B\262A\262\202\211\237\207" [nil] 8 (#$ . 23967)])
#@49 Append ELM at INDEX in SEQ.

(fn SEQ ELM INDEX)
(defalias 'helm-append-at-nth #[771 "GV\203\211\262\202\300W\203\300\262\300U\203$\301\"\202c\302\303\302:\203_@\262B\262U\203T<\203N\304!\244\262\202TB\262A\262T\262\202(\211\237\266\204\207" [0 append nil 1 reverse] 10 (#$ . 24421)])
#@154 Get a Helm source in SOURCES by NAME.

Optional argument SOURCES is a list of Helm sources which default to
`helm-sources'.

(fn NAME &optional SOURCES)
(defalias 'helm-source-by-name #[513 "\211\203-\211\301\211:\203&@\262<\203\202JB\262A\262\202\211\237\266\203\202.\211\301\302\301:\203W@\262\303\304\"\230\205F\211\262?\211\262\203WA\262\2022\207" [helm-sources nil t assoc-default name] 11 (#$ . 24758)])
#@220 Build an alist with (NAME . ACTION) elements with each pairs in ARGS.
Where NAME is a string or a function returning a string or nil and ACTION
a function.
If NAME returns nil the pair is skipped.

(fn NAME ACTION ...)
(defalias 'helm-make-actions #[128 "\211\300\211\211\211:\2036\262\211A\262\242\262@\262\301!\203# \262\203.BB\262AA\262\202\211\237\207" [nil functionp] 8 (#$ . 25210)])
#@100 Return the representation of ELM as a string.
ELM can be a string, a number or a symbol.

(fn ELM)
(defalias 'helm-stringify #[257 "\211;\203\207\211\247\203\300!\207\2119\205\301!\207" [number-to-string symbol-name] 3 (#$ . 25630)])
#@119 Return the substring of string STR from 0 to WIDTH.
Handle multibyte characters by moving by columns.

(fn STR WIDTH)
(defalias 'helm-substring #[514 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216\212c\210)\311!\210\312 `{*\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 move-to-column point-at-bol] 9 (#$ . 25879)])
#@228 Truncate string STR to end at column WIDTH.
Similar to `truncate-string-to-width'.
Add ENDSTR at end of truncated STR.
Add spaces at end if needed to reach WIDTH when STR is shorter than WIDTH.

(fn STR WIDTH &optional ENDSTR)
(defalias 'helm-substring-by-width #[770 "\300\211\301\211\300\203\202\302GSO\262\303!\262X\2038\304	Z\305\"Q\262\300\211\262\2029\301\203B\300\262\202\207" [nil t 0 string-width make-string 32] 13 (#$ . 26296)])
#@62 Check if string STR contains multibyte characters.

(fn STR)
(defalias 'helm-string-multibyte-p #[257 "\211\300\301\302\301T\211\262GW\203$H\262\303!\304V\211\262?\211\262\204\207" [-1 nil t char-width 1] 8 (#$ . 26772)])
#@63 Get pid from running process PROCESS-NAME.

(fn PROCESS-NAME)
(defalias 'helm-get-pid-from-process-name #[257 "\300 \211\301\211\302\301:\203:@\262\303\304\305!\"\262\203/\306\"\203/\262\301\211\262\2020\302\203:A\262\202\207" [list-system-processes nil t assoc-default comm process-attributes string-match] 11 (#$ . 27012)])
#@54 Return a list of available printers on Unix systems.
(defalias 'helm-ff-find-printers #[0 "\300\301!\205R\302\303!r\211q\210\304\305\306\307\310!\311\"\312$\216\313\301\314\315\314\316%\210\317\320 \321\"*\262\211\314\211\211:\203L@\262\317!@\262\203EB\262A\262\202-\211\237\266\204\262\207" [executable-find "lpstat" generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 call-process nil t "-a" split-string buffer-string "\n"] 7 (#$ . 27366)])
(defalias 'helm-region-active-p #[0 "\205
	\205
\302 `U?\207" [transient-mark-mode mark-active mark] 2])
#@65 Quote whitespace, if some, in string CANDIDATE.

(fn CANDIDATE)
(defalias 'helm-quote-whitespace #[257 "\300\301\302#\207" [replace-regexp-in-string " " "\\\\ "] 5 (#$ . 28011)])
#@41 Current line string without properties.
(defalias 'helm-current-line-contents #[0 "\300\301 \302 \"\207" [buffer-substring-no-properties point-at-bol point-at-eol] 3 (#$ . 28197)])
#@1041 Replace REGEXP by REP in string STR.

Same as `replace-regexp-in-string' but handle properly REP as
function with SUBEXP specified.

e.g

    (helm--replace-regexp-in-buffer-string "e\\(m\\)acs" 'upcase "emacs" t nil 1)
    => "eMacs"

    (replace-regexp-in-string "e\\(m\\)acs" 'upcase "emacs" t nil 1)
    => "eEMACSacs"

Also START argument behave as expected unlike
`replace-regexp-in-string'.

e.g

    (helm--replace-regexp-in-buffer-string "f" "r" "foofoo" t nil nil 3)
    => "fooroo"

    (replace-regexp-in-string "f" "r" "foofoo" t nil nil 3)
    => "roo"

Unlike `replace-regexp-in-string' this function is buffer-based
implemented i.e replacement is computed inside a temp buffer, so
REGEXP should be used differently than with
`replace-regexp-in-string'.

NOTE: This function is used internally for
`helm-ff-query-replace-on-filenames' and builded for this.
You should use `replace-regexp-in-string' instead unless the behavior
of this function is really needed.

(fn REGEXP REP STR &optional FIXEDCASE LITERAL SUBEXP START)
(defalias 'helm--replace-regexp-in-buffer-string #[1795 "\300\301!r\211q\210\302\303\304\305\306!\307\"\310$\216c\210\206eb\210\311\312\313#\203X\314\315!\203;\203;\316!!\202L\315!\203J!\202L\312%\210\202\317 *\207" [generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 re-search-forward nil t replace-match functionp match-string buffer-string] 14 (#$ . 28386)])
#@76 Same as `url-unhex-string' but ensure STR is completely decoded.

(fn STR)
(defalias 'helm-url-unhex-string #[257 "\211\206\300\262\301\302!r\211q\210\303\304\305\306\307!\310\"\311$\216\212c\210)\312\313\314\315#\203=\316\317\320\321\304!\322\314O\323\"!\315\211#\210eb\210\202\324\325 \326\"*\207" ["" generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 re-search-forward "%[A-Za-z0-9]\\{2\\}" nil t replace-match byte-to-string string-to-number match-string 1 16 decode-coding-string buffer-string utf-8] 8 (#$ . 29899)])
#@591 Prompt user for an answer.
Arg PROMPT is the prompt to present user the different possible
answers, ANSWER-LIST is a list of strings.
If user enter an answer which is one of ANSWER-LIST return this
answer, otherwise keep prompting for a valid answer.
Note that answer should be a single char, only short answer are
accepted.

Example:

    (let ((answer (helm-read-answer
                    "answer [y,n,!,q]: "
                    '("y" "n" "!" "q"))))
      (pcase answer
          ("y" "yes")
          ("n" "no")
          ("!" "all")
          ("q" "quit")))

(fn PROMPT ANSWER-LIST)
(defalias 'helm-read-answer #[514 "\300\3012=\211\205<\302\303\304\305\306#!!\211\2035\211\235\203$\307\301\"\210\2028\310\311\312\313\314#\"\210\315\316!\210\2028\317\262\210\2020\207" [t --cl-block-nil-- string read-key propertize face minibuffer-prompt throw message "Please answer by %s" mapconcat identity ", " sit-for 1 nil] 10 (#$ . 30508)])
#@44 Get symbol of STR-OR-SYM.

(fn STR-OR-SYM)
(defalias 'helm-symbolify #[257 "\2119\203\207\300!\207" [intern] 3 (#$ . 31467)])
#@12 

(fn OBJ)
(defalias 'helm-symbol-name #[257 "\211:\203\300!\204\301!\203\302\207\303!\207" [functionp byte-code-function-p "Anonymous" symbol-name] 3 (#$ . 31602)])
#@73 Display documentation of Eieio CLASS, a symbol or a string.

(fn CLASS)
(defalias 'helm-describe-class #[257 "\301\302\303\304#\210\305\216\306\307!*\207" [helm-describe-function-function advice-add cl--print-table :override helm-source--cl--print-table #[0 "\300\301\302\"\207" [advice-remove cl--print-table helm-source--cl--print-table] 3] describe-function helm-describe-function] 5 (#$ . 31783)])
#@63 Display documentation of FUNC, a symbol or string.

(fn FUNC)
(defalias 'helm-describe-function #[257 "\301K\302\303\304\305\306!\307\"\310$\216\301\311M\210\312!!)\207" [helm-describe-function-function message make-byte-code 0 "\301\300M\207" vconcat vector [message] 2 ignore helm-symbolify] 8 (#$ . 32193)])
#@63 Display documentation of VAR, a symbol or a string.

(fn VAR)
(defalias 'helm-describe-variable #[257 "\301K\302\303\304\305\306!\307\"\310$\216\301\311M\210\312!!)\207" [helm-describe-variable-function message make-byte-code 0 "\301\300M\207" vconcat vector [message] 2 ignore helm-symbolify] 8 (#$ . 32513)])
#@65 Display documentation of FACE, a symbol or a string.

(fn FACE)
(defalias 'helm-describe-face #[257 "\300 \301K\302\303\304\305\306!\307\"\310$\216\301\311M\210\312A\203!\313\314\"\202$\314!!)\262\207" [helm-marked-candidates message make-byte-code 0 "\301\300M\207" vconcat vector [message] 2 ignore describe-face mapcar helm-symbolify] 9 (#$ . 32833)])
#@264 Used to build persistent actions describing CANDIDATE with FUN.
Argument NAME is used internally to know which command to use when
symbol CANDIDATE refers at the same time to variable and a function.
See `helm-elisp-show-help'.

(fn CANDIDATE FUN &optional NAME)
(defalias 'helm-elisp--persistent-help #[770 "\303\304 !\305 \203\203\"\210\202k!\210\202k\306\307!\203V\306\310!\230\203V\211\232\204C\311!\210\312\313!	\203@\202A\n\"\210\314\307\315\"\210	\204k\316\317\320 !!\210\202k\203b\"\210\202f!\210\314\307\321\"\210\314\310\"\207" [helm-current-buffer helm--buffer-in-new-frame-p helm-persistent-action-window-buffer get-buffer help-buffer helm-follow-mode-p helm-attr help-running-p help-current-symbol kill-buffer set-window-buffer get-buffer-window helm-attrset nil helm-update regexp-quote helm-get-selection t] 7 (#$ . 33202)])
#@38 FUNC is symbol or string.

(fn FUNC)
(defalias 'helm-find-function #[257 "\300\301!!\207" [find-function helm-symbolify] 4 (#$ . 34081)])
#@36 VAR is symbol or string.

(fn VAR)
(defalias 'helm-find-variable #[257 "\300\301!!\207" [find-variable helm-symbolify] 4 (#$ . 34226)])
#@38 FACE is symbol or string.

(fn FACE)
(defalias 'helm-find-face-definition #[257 "\300\301!!\207" [find-face-definition helm-symbolify] 4 (#$ . 34369)])
#@103 CANDIDATE is symbol or string.
See `kill-new' for argument REPLACE.

(fn CANDIDATE &optional REPLACE)
(defalias 'helm-kill-new #[513 "\300\301!\"\207" [kill-new helm-stringify] 5 (#$ . 34529)])
#@133 Decide if current-buffer is related to START-BUFFER.
Argument ALIST is an alist of associated major modes.

(fn START-BUFFER ALIST)
(defalias 'helm-same-major-mode-p #[514 "rq\210)\236\301\"\236\301\"AA=\206z\302!\206zr	q\210\302!)\206z=\206z@=\206z	\236A=\206z\301\n\"@=\206z\211=\206z@=\206z\211	\236A=\206z\301\n\"@=\207" [major-mode rassq derived-mode-p] 13 (#$ . 34732)])
#@78 Same as `file-name-sans-extension' but remove all extensions.

(fn FILENAME)
(defalias 'helm-file-name-sans-extension #[257 "\300!\211\205\301\302\303!\304#\203\305!\202\211\207" [file-name-sans-extension string-match "\\." helm-basename 1 helm-file-name-sans-extension] 6 (#$ . 35169)])
#@378 Print FNAME  with any  leading directory  components removed.
If specified, also remove filename extension EXT.
Arg EXT can be specified as a string with or without dot,
in this case it should match file-name-extension.
It can also be non-nil (`t') in this case no checking
of file-name-extension is done and the extension is removed
unconditionally.

(fn FNAME &optional EXT)
(defalias 'helm-basename #[513 "\301\211\203+\302!\230\204\302\301\"\230\204\211\301=\203+\303!\204+\304\305!!\2020\305\306!!)\207" [non-essential t file-name-extension file-directory-p file-name-sans-extension file-name-nondirectory directory-file-name] 5 (#$ . 35473)])
#@70 Return the base directory of filename ending by a slash.

(fn FNAME)
(defalias 'helm-basedir #[257 "\211\205\211\300\230\203\300\202\301!\211\205\302!\207" ["~" file-name-directory file-name-as-directory] 4 (#$ . 36144)])
#@97 Return current-directory name at point.
Useful in dired buffers when there is inserted subdirs.
(defalias 'helm-current-directory #[0 "\302\303=\203\f\304 \202
	!\207" [major-mode default-directory expand-file-name dired-mode dired-current-directory] 3 (#$ . 36382)])
#@119 Files matching `helm-boring-file-regexp' will be
displayed with the `file-name-shadow' face if available.

(fn FILES)
(defalias 'helm-shadow-boring-files #[257 "\301\"\207" [helm-boring-file-regexp-list helm-shadow-entries] 4 (#$ . 36660)])
#@71 Files matching `helm-boring-file-regexp' will be skipped.

(fn FILES)
(defalias 'helm-skip-boring-files #[257 "\301\"\207" [helm-boring-file-regexp-list helm-skip-entries] 4 (#$ . 36909)])
#@43 Current file will be skipped.

(fn FILES)
(defalias 'helm-skip-current-file #[257 "\301\302!\"\207" [helm-current-buffer remove buffer-file-name] 4 (#$ . 37106)])
#@118 Change undesirable features of windows pathnames to ones more acceptable to
other candidate transformers.

(fn ARGS)
(defalias 'helm-w32-pathname-transformer #[257 "\301=\203\302\303\"\207\207" [system-type windows-nt helm-transform-mapcar #[257 "\300\301\302\300\303\304##\207" [replace-regexp-in-string "/cygdrive/\\(.\\)" "\\1:" "\\\\" "/"] 8 "\n\n(fn X)"]] 4 (#$ . 37278)])
#@83 Convert filename FILE to something usable by external w32 executables.

(fn FILE)
(defalias 'helm-w32-prepare-filename #[257 "\300\301\302\300\303\304\305\211%\305\306%\207" [replace-regexp-in-string "/" "\\" "/cygdrive/\\(.\\)" "\\1:" nil t] 10 (#$ . 37668)])
#@13 

(fn FILE)
(defalias 'helm-w32-shell-execute-open-file #[257 "\300\301\302!\"\207" [w32-shell-execute "open" helm-w32-prepare-filename] 5 (#$ . 37937)])
(defvar helm-walk-ignore-directories '("SCCS/" "RCS/" "CVS/" "MCVS/" ".svn/" ".git/" ".hg/" ".bzr/" "_MTN/" "_darcs/" "{arch}/" ".gvfs/"))
#@17 

(fn FILE DIR)
(defalias 'helm--dir-file-name #[514 "\300\301GSO\"\207" [expand-file-name 0] 6 (#$ . 38237)])
(put 'helm--dir-file-name 'byte-optimizer 'byte-compile-inline-expand)
#@12 

(fn STR)
(defalias 'helm--dir-name-p #[257 "\300\211GSH\301\"\207" [char-equal 47] 4 (#$ . 38428)])
(put 'helm--dir-name-p 'byte-optimizer 'byte-compile-inline-expand)
#@715 Walk through DIRECTORY tree.

Argument PATH can be one of basename, relative, full, or a function
called on file name, default to basename.

Argument DIRECTORIES when `t' return also directories names,
otherwise skip directories names, with a value of `only' returns
only subdirectories, i.e files are skipped.

Argument MATCH is a regexp matching files or directories.

Argument SKIP-SUBDIRS when `t' will skip `helm-walk-ignore-directories'
otherwise if it is given as a list of directories, this list will be used
instead of `helm-walk-ignore-directories'.

Argument NOERROR when `t' will skip directories which are not accessible.

(fn DIRECTORY &key (PATH \='basename) DIRECTORIES MATCH SKIP-SUBDIRS NOERROR)
(defalias 'helm-walk-directory #[385 "\301\302\"\206\303A@\301\304\"A@\301\305\"A@\301\306\"A@C\301\307\"A@\211\203O\211@\310>\2037\211AA\262\202$\311>A@\203F\312\262\202$\313\314@\"\210\202$\210\315\316\"\203[\317\202r\315\320\"\203f\321\202r\315\322\"\203q\323\202r\211\242<\203~\242\202\240\210\312C\211\324\325\326\327\330&\331\"\332\333%\240\210\211\242	!\262\262\207" [helm-walk-ignore-directories plist-member :path (nil basename) :directories :match :skip-subdirs :noerror (:path :directories :match :skip-subdirs :noerror :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:path :directories :match :skip-subdirs :noerror)" eql basename file-name-nondirectory relative file-relative-name full identity make-byte-code 257 "\306!?\205\247\307\310\311\"\312\"\313\211:\203\243@\262\314\235\211\204\233\315\211GSH\316\"\262\205;\317\320GSO\"\266\202\211\203{\302\242\235\206N\303\205N\321!??\205s\300\203o\301\203a\322\301\"\203o\304!\323PC\305\242!\244\202s\305\242!\237\244\262\202\232\300\324=?\205\225\301\203\215\322\301\"\205\225\304\317\"!C\237\244\262\210\210A\262\202\211\237\266\203\207" vconcat vector [file-symlink-p sort file-name-all-completions "" string-lessp nil ("./" "../") char-equal 47 expand-file-name 0 file-accessible-directory-p string-match "/" only] 11 "\n\n(fn DIR)"] 21 (#$ . 38606)])
#@176 Same as `file-expand-wildcards' but allow recursion.
Recursion happen when PATTERN starts with two stars.
Directories expansion is not supported.

(fn PATTERN &optional FULL)
(defalias 'helm-file-expand-wildcards #[513 "\302!\303	\203E\304\305\"\203E\306\307!\310\311\312\"\203 \312\2027\311\313\"\203+\313\2027\314\315\"\2036\316\2027\312\317\303\320\321!\322\323&	\202I\324\")\207" [case-fold-search helm-file-globstar helm-basename nil string-match "\\`\\*\\{2\\}\\(.*\\)" helm-walk-directory helm-basedir :path eql full relative memql (basename nil) basename :directories :match wildcard-to-regexp :skip-subdirs t file-expand-wildcards] 13 (#$ . 40774)])
#@131 Set minibuffer contents to PATTERN.
if optional NOUPDATE is non-nil, helm buffer is not changed.

(fn PATTERN &optional NOUPDATE)
(defalias 'helm-set-pattern #[513 "\301\302 \206\303 !r\304\305\306\307\310!\311\"\312$\216\313@\314\"\210\315 \210c\210*\210\211\205+\211\207" [helm-pattern internal--before-with-selected-window active-minibuffer-window minibuffer-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-with-selected-window] 2 select-window norecord delete-minibuffer-contents] 9 (#$ . 41460)])
#@110 Return the user input in a minibuffer before point as a string.
That is what completion commands operate on.
(defalias 'helm-minibuffer-completion-contents #[0 "\300 `{\207" [field-beginning] 2 (#$ . 42001)])
#@50 Eval BODY inside `helm-buffer'.

(fn &rest BODY)
(defalias 'with-helm-buffer '(macro . #[128 "\300\301BB\207" [with-current-buffer (helm-buffer-get)] 4 (#$ . 42216)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-helm-buffer lisp-indent-function 0 put edebug-form-spec t] 5)
#@58 Eval BODY inside `helm-current-buffer'.

(fn &rest BODY)
(defalias 'with-helm-current-buffer '(macro . #[128 "\300\301BB\207" [with-current-buffer (or (and (buffer-live-p helm-current-buffer) helm-current-buffer) (setq helm-current-buffer (current-buffer)))] 4 (#$ . 42524)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-helm-current-buffer lisp-indent-function 0 put edebug-form-spec t] 5)
#@63 Return `helm-action-buffer' if shown otherwise `helm-buffer'.
(defalias 'helm-buffer-get #[0 "\302 \203\207	\207" [helm-action-buffer helm-buffer helm-action-window] 1 (#$ . 42949)])
#@26 Window of `helm-buffer'.
(defalias 'helm-window #[0 "\300\301 \302\"\207" [get-buffer-window helm-buffer-get 0] 3 (#$ . 43141)])
#@33 Window of `helm-action-buffer'.
(defalias 'helm-action-window #[0 "\301\302\"\207" [helm-action-buffer get-buffer-window visible] 3 (#$ . 43276)])
#@62 Be sure BODY is excuted in the helm window.

(fn &rest BODY)
(defalias 'with-helm-window '(macro . #[128 "\300\301BB\207" [with-selected-window (helm-window)] 4 (#$ . 43430)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-helm-window lisp-indent-function 0 put edebug-form-spec t] 5)
#@108 Ensure BODY runs without following.
I.e. when using `helm-next-line' and friends in BODY.

(fn &rest BODY)
(defalias 'helm-without-follow '(macro . #[128 "\300\301\302\303\304BEE\207" [cl-letf (((symbol-function 'helm-follow-mode-p) (lambda (&optional _) nil))) let (helm-follow-mode-persistent) progn] 7 (#$ . 43748)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put helm-without-follow lisp-indent-function 0 put edebug-form-spec t] 5)
(defalias 'helm--setup-completion-styles-alist #[0 "\301\235\203\n\202
\301B\302\236?\205$\303\235\203\202\"\303B\211\207" [completion-styles-alist (helm helm-completion-try-completion helm-completion-all-completions "helm multi completion style.") flex (helm-flex helm-flex-completion-try-completion helm-flex-completion-all-completions "helm flex completion style.\nProvide flex matching for emacs-26.")] 2])
(defvar helm-blacklist-completion-styles '(emacs21 emacs22))
#@82 Return a suitable list of styles for `completion-styles'.

(fn &optional NOMODE)
(defalias 'helm--prepare-completion-styles #[256 "\306\307!\210\310>\203\f\311\207\211?\205&r\312	!\203	\206p\211q\210\n\236A)\211:\2056\211@A\211\266\202\266\202\262\206\211\313\f\236\206D\314\f\236@\315
>\205NC
\316\211:\203s@\262>\204l
>\204lB\262A\262\202Q\211\237\266\203\"\317\320
>\203\205\321\202\206\322#\266\202\207" [helm-completion-style helm-current-buffer major-mode helm-completion-styles-alist completion-styles-alist completion-styles require helm-mode (helm helm-fuzzy) (basic partial-completion emacs22) buffer-live-p flex helm-flex append nil helm-append-at-nth (helm) 1 0 helm-blacklist-completion-styles] 9 (#$ . 44699)])
#@1081 Build a function listing the possible completions of `helm-pattern' in COLLECTION.

Only the elements of COLLECTION that satisfy PREDICATE are considered.
Argument POINT is same as in `completion-all-completions' and is
meaningful only when using some kind of `completion-at-point'.
The return value is a list of completions that may be sorted by the
sort function provided by the completion-style in use (emacs-27 only),
otherwise (emacs-26) the sort function have to be provided if needed
either with a FCT function in source or by passing the sort function
with METADATA e.g. (metadata (display-sort-function . foo)).

Example:

    (helm :sources (helm-build-sync-source "test"
                     :candidates (helm-dynamic-completion
                                  '(foo bar baz foab)
                                  'symbolp)
                     :match-dynamic t)
          :buffer "*helm test*")

When argument NOMODE is non nil don't use `completion-styles' as
specified in `helm-completion-styles-alist'.

(fn COLLECTION PREDICATE &optional POINT METADATA NOMODE)
(defalias 'helm-dynamic-completion #[1282 "\300\301\302\303\304					%\305\"\306$\207" [make-byte-code 0 "\306\304!\307\310\311\312\313\314\300\301\302\303$\315\"\316\317%\320\307\301$*\207" vconcat vector [completion-styles helm--prepare-completion-styles t make-byte-code 771 "\304\305\300!\203\300\301\306#\202\300\302\206\307\303\206\310%\311!\312\303\313\"\314A\203.\314\241\210\315!\262\203=!\202>\211\207" vconcat vector [completion-all-completions functionp t 0 (metadata) last completion-metadata-get display-sort-function nil copy-sequence] 9 "\n\n(fn STR PRED ACTION)" complete-with-action completion-flex-nospace helm-pattern] 9] 15 (#$ . 45471)])
#@72 Yank text at point in `helm-current-buffer' into minibuffer.

(fn ARG)
(defalias 'helm-yank-text-at-point #[257 "r\305!\203\206p\211q\210	\206\306\307\n\204@\212\nb\210\310\311W\203Y\312\313!r\211q\210\314\311\315\316\317!\320\"\321$\216\fc\210d\211b\210\322!\210\211`Z\262`|\210\323 \262*\262\202g!\210\f\324\325\326\327\n`\"#P!\210\211\203s`Z\202t`\211)\266\202)\207" [helm-current-buffer helm-yank-text-at-point-function helm-yank-point helm-current-position helm-pattern buffer-live-p forward-word nil helm-set-pattern 0 generate-new-buffer " *temp*" make-byte-code "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 -1 buffer-string replace-regexp-in-string "\\`\n" "" buffer-substring-no-properties] 11 (#$ . 47249) "p"])
(put 'helm-yank-text-at-point 'helm-only t)
#@53 Undo last entry added by `helm-yank-text-at-point'.
(defalias 'helm-undo-yank-text-at-point #[0 "\300\301!\207" [helm-yank-text-at-point -1] 2 (#$ . 48078) nil])
(put 'helm-undo-yank-text-at-point 'helm-only t)
(defalias 'helm-reset-yank-point #[0 "\301\211\207" [helm-yank-point nil] 2])
(byte-code "\300\301\302\"\210\300\303\302\"\207" [add-hook helm-cleanup-hook helm-reset-yank-point helm-after-initialize-hook] 3)
(defvar helm--ansi-color-regexp "\\[\\(K\\|[0-9;]*m\\)")
(defvar helm--ansi-color-drop-regexp "\\[\\([ABCDsuK]\\|[12][JK]\\|=[0-9]+[hI]\\|[0-9;]*[Hf]\\)")
#@417 A version of `ansi-color-apply' immune to upstream changes.

Similar to the emacs-24.5 version without support to `ansi-color-context'
which is buggy in emacs.

Modify also `ansi-color-regexp' by using own variable `helm--ansi-color-regexp'
that match whole STRING.

This is needed to provide compatibility for both emacs-25 and emacs-24.5
as emacs-25 version of `ansi-color-apply' is partially broken.

(fn STRING)
(defalias 'helm--ansi-color-apply #[257 "\302\303\211\211\211\211\304#\211\262\203X\305\306\"\262\203+\307\310\311	!%\210O\262\302\225\262\304	\"\203I\312\313\303\211$\262\2027\211B\262\314\"\262\202\203k\307G\310\311	!%\210\304\315#\203\203\302\224OB\262\202\215\303OB\262\316\317\237\"\207" [helm--ansi-color-regexp helm--ansi-color-drop-regexp 0 nil string-match match-string 1 put-text-property font-lock-face ansi-color--find-face replace-match "" ansi-color-apply-sequence "" apply concat] 13 (#$ . 48663)])
(provide 'helm-lib)