mirror of https://github.com/Chizi123/.emacs.d.git

Chizi123
2018-11-17 5cb5f70b1872a757e93ea333b0e2dca50c6c8957
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; 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\300\302!\210\303\304\305\306#\210\303\304\307\310#\207" [require s dash put f-guard-error error-conditions (error f-guard-error) error-message "Destructive operation outside sandbox"] 4)
#@77 List of allowed paths to modify when guarded.
 
Do not modify this variable.
(defvar f--guard-paths nil (#$ . 621))
#@123 If PATH is allowed to be modified, yield BODY.
 
If PATH is not allowed to be modified, throw error.
 
(fn PATH &rest BODY)
(defalias 'f--destructive '(macro . #[385 "\300\301\300\302\303\304\305E\306\305    EE\307BB\310B\311\312\313    \314BBEFBBB\207" [if f--guard-paths --any\? or f-same\? it f-ancestor-of\? (f--guard-paths) progn signal 'f-guard-error list (f--guard-paths)] 12 (#$ . 743)]))
(byte-code "\300\301\302\303#\300\207" [function-put f--destructive lisp-indent-function 1] 4)
#@46 Join ARGS to a single path.
 
(fn &rest ARGS)
(defalias 'f-join #[128 "\300C\301@!\302\303\304\305\306\307!\310\"\311\312%\"\210\211\203\"\313\242!\202$\242\207" [nil f-relative\? -map make-byte-code 257 "\300\301\300\242\"\240\207" vconcat vector [f-expand] 5 "\n\n(fn ARG)" f-relative] 10 (#$ . 1239)])
#@57 Split PATH and return list containing parts.
 
(fn PATH)
(defalias 'f-split #[257 "\300\301 \302#\303!\203\301 B\211\262\202\211\207" [s-split f-path-separator omit-nulls f-absolute\?] 5 (#$ . 1558)])
#@274 Expand PATH relative to DIR (or `default-directory').
PATH and DIR can be either a directory names or directory file
names.  Return a directory name if PATH is a directory name, and
a directory file name otherwise.  File name handlers are
ignored.
 
(fn PATH &optional DIR)
(defalias 'f-expand #[513 "\301\302\")\207" [file-name-handler-alist nil expand-file-name] 5 (#$ . 1773)])
#@37 Return the name of PATH.
 
(fn PATH)
(defalias 'f-filename #[257 "\300\301!!\207" [file-name-nondirectory directory-file-name] 4 (#$ . 2162)])
(defalias 'f-parent 'f-dirname)
#@49 Return the parent directory to PATH.
 
(fn PATH)
(defalias 'f-dirname #[257 "\301\302\303\"!!\304\"?\205\305!\203\306!\202\302!\207" [default-directory file-name-directory directory-file-name f-expand f-same\? f-relative\? f-relative] 6 (#$ . 2343)])
#@66 Return the deepest common parent directory of PATHS.
 
(fn PATHS)
(defalias 'f-common-parent #[257 "\211\204\300\207\211A\204\301@!\207\302\303\"\211@@\300@\203e\304\304\305\203H\203H@\2045\300\262\202<\211@\232\262\210\211T\262A\262\202!\266\306!\262\203e\302\307\"\262B\262@@\262\202\211\204m\310\202\207\211G\311U\203\200\312@!\203\200\313 \202\207\314\315\237\"\316P\207" [nil f-parent -map f-split t 0 ---truthy\? cdr "" 1 f-root\? f-root apply f-join "/"] 11 (#$ . 2612)])
#@165 Return the file extension of PATH.
 
The extension, in a file name, is the part that follows the last
'.', excluding version numbers and backup suffixes.
 
(fn PATH)
(defalias 'f-ext #[257 "\300!\207" [file-name-extension] 3 (#$ . 3142)])
#@62 Return everything but the file extension of PATH.
 
(fn PATH)
(defalias 'f-no-ext #[257 "\300!\207" [file-name-sans-extension] 3 (#$ . 3386)])
#@93 Return PATH but with EXT as the new extension.
EXT must not be nil or empty.
 
(fn PATH EXT)
(defalias 'f-swap-ext #[514 "\300!\203\n\301\302!\207\303!\304Q\207" [s-blank\? error "Extension cannot be empty or nil" f-no-ext "."] 5 (#$ . 3535)])
#@70 Return the name of PATH, excluding the extension of file.
 
(fn PATH)
(defalias 'f-base #[257 "\300\301!!\207" [f-no-ext f-filename] 4 (#$ . 3788)])
#@55 Return PATH relative to DIR.
 
(fn PATH &optional DIR)
(defalias 'f-relative #[513 "\300\"\207" [file-relative-name] 5 (#$ . 3943)])
(defalias 'f-abbrev 'f-short)
#@64 Return abbrev of PATH.  See `abbreviate-file-name'.
 
(fn PATH)
(defalias 'f-short #[257 "\300!\207" [abbreviate-file-name] 3 (#$ . 4113)])
#@41 Return long version of PATH.
 
(fn PATH)
(defalias 'f-long #[257 "\300!\207" [f-expand] 3 (#$ . 4259)])
#@47 Return the canonical name of PATH.
 
(fn PATH)
(defalias 'f-canonical #[257 "\300!\207" [file-truename] 3 (#$ . 4369)])
#@131 Append slash to PATH unless one already.
 
Some functions, such as `call-process' requires there to be an
ending slash.
 
(fn PATH)
(defalias 'f-slash #[257 "\300!\203\n\301!\207\207" [f-dir\? file-name-as-directory] 3 (#$ . 4496)])
#@61 Return absolute path to PATH, with ending slash.
 
(fn PATH)
(defalias 'f-full #[257 "\300\301!!\207" [f-slash f-long] 4 (#$ . 4736)])
#@61 Helper for `f-uniquify' and `f-uniquify-alist'.
 
(fn PATHS)
(defalias 'f--uniquify #[257 "\211G\300\301\"\302\303\"GU\204!\302\303\304\305\300\306\"\"\"\262\202\n\207" [mapcar #[257 "\211\300!B\207" [f-filename] 4 "\n\n(fn IT)"] -group-by cdr apply append #[257 "\211A\211G\300V\203\301\302\"\202\211\207" [1 mapcar #[257 "\211@\300\301A@\"!\302 AQB\207" [f-filename s-chop-suffix f-path-separator] 6 "\n\n(fn IT)"]] 5 "\n\n(fn IT)"]] 11 (#$ . 4877)])
#@89 Return unique suffixes of FILES.
 
This function expects no duplicate paths.
 
(fn FILES)
(defalias 'f-uniquify #[257 "\300\301\302!\"\207" [-map car f--uniquify] 5 (#$ . 5353)])
#@112 Return alist mapping FILES to unique suffixes of FILES.
 
This function expects no duplicate paths.
 
(fn FILES)
(defalias 'f-uniquify-alist #[257 "\300\301\302!\"\207" [-map cadr f--uniquify] 5 (#$ . 5538)])
#@83 Read binary data from PATH.
 
Return the binary data as unibyte string.
 
(fn PATH)
(defalias 'f-read-bytes #[257 "\301\302!r\211q\210\303\304\305\306\307!\310\"\311$\216\312\313!\210\314\315!\210\316ed\"*\207" [buffer-file-coding-system generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205    \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 set-buffer-multibyte nil binary insert-file-contents-literally buffer-substring-no-properties] 8 (#$ . 5752)])
(defalias 'f-read 'f-read-text)
#@139 Read text with PATH, using CODING.
 
CODING defaults to `utf-8'.
 
Return the decoded text as multibyte string.
 
(fn PATH &optional CODING)
(defalias 'f-read-text #[513 "\300\301!\206    \302\"\207" [decode-coding-string f-read-bytes utf-8] 5 (#$ . 6262)])
(defalias 'f-write 'f-write-text)
#@167 Write TEXT with CODING to PATH.
 
TEXT is a multibyte string.  CODING is a coding system to encode
TEXT with.  PATH is a file name to write to.
 
(fn TEXT CODING PATH)
(defalias 'f-write-text #[771 "\300\301\"\"\207" [f-write-bytes encode-coding-string] 7 (#$ . 6558)])
#@50 Determine whether S is a unibyte string.
 
(fn S)
(defalias 'f-unibyte-string-p #[257 "\300!?\207" [multibyte-string-p] 3 (#$ . 6835)])
#@105 Write binary DATA to PATH.
 
DATA is a unibyte string.  PATH is a file name to write to.
 
(fn DATA PATH)
(defalias 'f-write-bytes #[514 "\203\211\304\305\306\307\2038\2038@\203\305\262\202,\310\"\206*\311\"\262\210\211T\262A\262\202    \266\211\262!\203\202\312!\204N\313\314\312D\"\210\305\315\211\316\317\320!!\321\307\322\323\324!\325\"\326$\216r\211q\210\315\327\305!\210c)rq\210\330\305\211\305\307%\210*\266\202*\207\313\331D\"\207\312!\204\226\313\314\312D\"\210\305\315\211\316\317\320!!\321\307\322\323\324!\332\"\326$\216r\211q\210\315\327\305!\210c)rq\210\330\305\211\305\307%\210*\266\202*\207" [f--guard-paths coding-system-for-write file-coding-system-alist buffer-file-coding-system ---truthy\? nil t 0 f-same\? f-ancestor-of\? f-unibyte-string-p signal wrong-type-argument binary get-buffer-create generate-new-buffer-name " *temp file*" make-byte-code "\301\300!\205    \302\300!\207" vconcat vector [buffer-name kill-buffer] 2 set-buffer-multibyte write-region f-guard-error [buffer-name kill-buffer]] 11 (#$ . 6978)])
(defalias 'f-append 'f-append-text)
#@97 Append TEXT with CODING to PATH.
 
If PATH does not exist, it is created.
 
(fn TEXT CODING PATH)
(defalias 'f-append-text #[771 "\300\301\"\"\207" [f-append-bytes encode-coding-string] 7 (#$ . 8101)])
#@85 Append binary DATA to PATH.
 
If PATH does not exist, it is created.
 
(fn DATA PATH)
(defalias 'f-append-bytes #[514 "\300!\203\f\301!\202 \302\303P\"\207" [f-file\? f-read-bytes "" f-write-bytes] 6 (#$ . 8310)])
#@43 Create directories DIRS.
 
(fn &rest DIRS)
(defalias 'f-mkdir #[128 "\300C\301\302\303\304\305\306!\307\"\310\311%\"\207" [nil -each make-byte-code 257 "\300\302\300\242\"\240\210\303\300\242!?\205b    \203^\304\305    \306\307\203H\203H@\203-\305\262\202<\310\300\242\"\206:\311\300\242\"\262\210\211T\262A\262\202\266\211\262!\203V\312\300\242!\207\313\314\300\242    D\"\207\312\300\242!\207" vconcat vector [f--guard-paths f-expand f-directory\? ---truthy\? nil t 0 f-same\? f-ancestor-of\? make-directory signal f-guard-error] 10 "\n\n(fn DIR)"] 10 (#$ . 8535)])
#@130 Delete PATH, which can be file or directory.
 
If FORCE is t, a directory will be deleted recursively.
 
(fn PATH &optional FORCE)
(defalias 'f-delete #[513 "\203]\301\302\303\304\2038\2038@\203\302\262\202,\305    \"\206*\306    \"\262\210\211T\262A\262\202    \266\211\262!\203V\307!\204M\310!\203Q\311!\207\312\"\207\313\314D\"\207\307!\204i\310!\203m\311!\207\312\"\207" [f--guard-paths ---truthy\? nil t 0 f-same\? f-ancestor-of\? f-file\? f-symlink\? delete-file delete-directory signal f-guard-error] 11 (#$ . 9127)])
#@57 Create a symlink to SOURCE from PATH.
 
(fn SOURCE PATH)
(defalias 'f-symlink #[514 "\203M\301\302\303\304\2038\2038@\203\302\262\202,\305\"\206*\306\"\262\210\211T\262A\262\202    \266\211\262!\203F\307\"\207\310\311D\"\207\307\"\207" [f--guard-paths ---truthy\? nil t 0 f-same\? f-ancestor-of\? make-symbolic-link signal f-guard-error] 11 (#$ . 9689)])
#@88 Move or rename FROM to TO.
If TO is a directory name, move FROM into TO.
 
(fn FROM TO)
(defalias 'f-move #[514 "\203N\301\302\303\304\2038\2038@\203\302\262\202,\305\"\206*\306\"\262\210\211T\262A\262\202    \266\211\262!\203G\307\303#\207\310\311D\"\207\307\303#\207" [f--guard-paths ---truthy\? nil t 0 f-same\? f-ancestor-of\? rename-file signal f-guard-error] 11 (#$ . 10080)])
#@141 Copy file or directory FROM to TO.
If FROM names a directory and TO is a directory name, copy FROM
into TO as a subdirectory.
 
(fn FROM TO)
(defalias 'f-copy #[514 "\203{\302\303\304\305\2038\2038@\203\303\262\202,\306\"\206*\307\"\262\210\211T\262A\262\202    \266\211\262!\203t\310!\203L\311\"\207    \312V\203W\313\"\207\314!\203o\315\316\317!\"\210\320\321!\"\313\"\207\313\"\207\322\323D\"\207\310!\203\206\311\"\207    \312V\203\221\313\"\207\314!\203\251\315\316\317!\"\210\320\321!\"\313\"\207\313\"\207" [f--guard-paths emacs-major-version ---truthy\? nil t 0 f-same\? f-ancestor-of\? f-file\? copy-file 23 copy-directory f-dir\? apply f-mkdir f-split f-expand f-filename signal f-guard-error] 11 (#$ . 10500)])
#@65 Copy contents in directory FROM, to directory TO.
 
(fn FROM TO)
(defalias 'f-copy-contents #[514 "\300!\204 \301\302\"\210\303!\204\301\304\"\210\305!\306\2054@\307\310!\"\266\211T\262A\262\202\207" [f-exists\? error "Cannot copy contents to non existing directory %s" f-dir\? "Cannot copy contents as %s is a file" f-entries 0 f-copy file-name-as-directory] 9 (#$ . 11280)])
#@79 Update PATH last modification date or create if it does not exist.
 
(fn PATH)
(defalias 'f-touch #[257 "\203W\301\302\303\304\2038\2038@\203\302\262\202,\305\"\206*\306\"\262\210\211T\262A\262\202    \266\211\262!\203P\307!\203K\310!\207\311\312\"\207\313\314D\"\207\307!\203a\310!\207\311\312\"\207" [f--guard-paths ---truthy\? nil t 0 f-same\? f-ancestor-of\? f-file\? set-file-times f-write-bytes "" signal f-guard-error] 10 (#$ . 11682)])
#@54 Return t if PATH exists, false otherwise.
 
(fn PATH)
(defalias 'f-exists\? #[257 "\300!\207" [file-exists-p] 3 (#$ . 12166)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\303\"\207" [defalias f-exists-p f-exists\? f-dir\? f-directory\? f-dir-p] 3)
#@60 Return t if PATH is directory, false otherwise.
 
(fn PATH)
(defalias 'f-directory\? #[257 "\300!\207" [file-directory-p] 3 (#$ . 12433)])
(defalias 'f-directory-p 'f-directory\?)
#@55 Return t if PATH is file, false otherwise.
 
(fn PATH)
(defalias 'f-file\? #[257 "\300!\207" [file-regular-p] 3 (#$ . 12619)])
(defalias 'f-file-p 'f-file\?)
#@58 Return t if PATH is symlink, false otherwise.
 
(fn PATH)
(defalias 'f-symlink\? #[257 "\300!??\207" [file-symlink-p] 3 (#$ . 12783)])
(defalias 'f-symlink-p 'f-symlink\?)
#@59 Return t if PATH is readable, false otherwise.
 
(fn PATH)
(defalias 'f-readable\? #[257 "\300!\207" [file-readable-p] 3 (#$ . 12961)])
(defalias 'f-readable-p 'f-readable\?)
#@59 Return t if PATH is writable, false otherwise.
 
(fn PATH)
(defalias 'f-writable\? #[257 "\300!\207" [file-writable-p] 3 (#$ . 13142)])
(defalias 'f-writable-p 'f-writable\?)
#@61 Return t if PATH is executable, false otherwise.
 
(fn PATH)
(defalias 'f-executable\? #[257 "\300!\207" [file-executable-p] 3 (#$ . 13323)])
(defalias 'f-executable-p 'f-executable\?)
#@59 Return t if PATH is absolute, false otherwise.
 
(fn PATH)
(defalias 'f-absolute\? #[257 "\300!\207" [file-name-absolute-p] 3 (#$ . 13514)])
(defalias 'f-absolute-p 'f-absolute\?)
#@59 Return t if PATH is relative, false otherwise.
 
(fn PATH)
(defalias 'f-relative\? #[257 "\300!?\207" [f-absolute\?] 3 (#$ . 13700)])
(defalias 'f-relative-p 'f-relative\?)
#@65 Return t if PATH is root directory, false otherwise.
 
(fn PATH)
(defalias 'f-root\? #[257 "\300!?\207" [f-parent] 3 (#$ . 13879)])
(defalias 'f-root-p 'f-root\?)
#@279 Return t if extension of PATH is EXT, false otherwise.
 
If EXT is nil or omitted, return t if PATH has any extension,
false otherwise.
 
The extension, in a file name, is the part that follows the last
'.', excluding version numbers and backup suffixes.
 
(fn PATH &optional EXT)
(defalias 'f-ext\? #[513 "\211\203\n\300!\230\207\300!\301=?\207" [f-ext nil] 4 (#$ . 14049)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\303\"\207" [defalias f-ext-p f-ext\? f-equal\? f-same\? f-equal-p] 3)
#@80 Return t if PATH-A and PATH-B are references to same file.
 
(fn PATH-A PATH-B)
(defalias 'f-same\? #[514 "\300!\205\300!\205\301\302\303!!!\301\302\303!!!\232\207" [f-exists\? f-canonical directory-file-name f-expand] 7 (#$ . 14559)])
(defalias 'f-same-p 'f-same\?)
#@61 Return t if PATH-A is parent of PATH-B.
 
(fn PATH-A PATH-B)
(defalias 'f-parent-of\? #[514 "\300!\211\205 \301\"\207" [f-parent f-same\?] 6 (#$ . 14839)])
(defalias 'f-parent-of-p 'f-parent-of\?)
#@60 Return t if PATH-A is child of PATH-B.
 
(fn PATH-A PATH-B)
(defalias 'f-child-of\? #[514 "\300!\211\205 \301\"\207" [f-parent f-same\?] 6 (#$ . 15045)])
(defalias 'f-child-of-p 'f-child-of\?)
#@63 Return t if PATH-A is ancestor of PATH-B.
 
(fn PATH-A PATH-B)
(defalias 'f-ancestor-of\? #[514 "\300\"?\205\301\302!\302!\"\207" [f-same\? s-starts-with\? f-full] 6 (#$ . 15247)])
(defalias 'f-ancestor-of-p 'f-ancestor-of\?)
#@64 Return t if PATH-A is desendant of PATH-B.
 
(fn PATH-A PATH-B)
(defalias 'f-descendant-of\? #[514 "\300\"?\205\301\302!\302!\"\207" [f-same\? s-starts-with\? f-full] 6 (#$ . 15484)])
(defalias 'f-descendant-of-p 'f-descendant-of\?)
#@55 Return t if PATH is hidden, nil otherwise.
 
(fn PATH)
(defalias 'f-hidden\? #[257 "\300!\204 \301\302\"\210\211\303\304O\305\230\207" [f-exists\? error "Path does not exist: %s" 0 1 "."] 4 (#$ . 15728)])
(defalias 'f-hidden-p 'f-hidden\?)
#@158 If PATH is a file, return t if the file in PATH is empty, nil otherwise.
If PATH is directory, return t if directory has no files, nil otherwise.
 
(fn PATH)
(defalias 'f-empty\? #[257 "\300!\203\301\302\303#\302\232\207\304!\305U\207" [f-directory\? f-files nil t f-size 0] 5 (#$ . 15977)])
(defalias 'f-empty-p 'f-empty\?)
#@135 Return size of PATH.
 
If PATH is a file, return size of that file.  If PATH is
directory, return sum of all files in PATH.
 
(fn PATH)
(defalias 'f-size #[257 "\300!\203\301\302\303\304\305\306#\"!\207\307\310!8\207" [f-directory\? -sum -map f-size f-files nil t 7 file-attributes] 8 (#$ . 16313)])
#@195 Return the depth of PATH.
 
At first, PATH is expanded with `f-expand'.  Then the full path is used to
detect the depth.
'/' will be zero depth,  '/usr' will be one depth.  And so on.
 
(fn PATH)
(defalias 'f-depth #[257 "\300\301!!GS\207" [f-split f-expand] 4 (#$ . 16623)])
#@27 Return path to this file.
(defalias 'f-this-file #[0 "\203    \207\303\302!\203\n\203\n\207\304 \207" [load-in-progress load-file-name byte-compile-current-file boundp buffer-file-name] 2 (#$ . 16904)])
#@51 A variable to cache result of `f-path-separator'.
(defvar f--path-separator nil (#$ . 17117))
#@24 Return path separator.
(defalias 'f-path-separator #[0 "\206 \301\302\303\"\304\305O\211\207" [f--path-separator f-join "x" "y" 1 2] 3 (#$ . 17217)])
#@52 Find PATTERN in PATH.
 
(fn PATTERN &optional PATH)
(defalias 'f-glob #[513 "\301\302\206\"!\207" [default-directory file-expand-wildcards f-join] 6 (#$ . 17376)])
#@23 
 
(fn PATH RECURSIVE)
(defalias 'f--collect-entries #[514 "\300C\301\302\303\304\"\"\203#\305\306\307\310\311\312\"\313\"\314\315%\"\210\202'\240\210\242\207" [nil -reject #[257 "\300!\301\232\206 \300!\302\232\207" [f-filename "." ".."] 3 "\n\n(fn FILE)"] directory-files t -map make-byte-code 257 "\302!\203 \301\301\242B\240\207\303!\205$\301\301\242B\240\210\301\304\301\242\305\300\"\"\240\207" vconcat vector [f-file\? f-directory\? append f--collect-entries] 7 "\n\n(fn ENTRY)"] 12 (#$ . 17550)])
#@71 Anaphoric version of `f-entries'.
 
(fn PATH BODY &optional RECURSIVE)
(defalias 'f--entries '(macro . #[770 "\300\301\302\303\304EEF\207" [f-entries lambda (path) let ((it path))] 10 (#$ . 18082)]))
#@247 Find all files and directories in PATH.
 
FN - called for each found file and directory.  If FN returns a thruthy
value, file or directory will be included.
RECURSIVE - Search for files and directories recursive.
 
(fn PATH &optional FN RECURSIVE)
(defalias 'f-entries #[769 "\300\"\203\301\"\202\211\207" [f--collect-entries -select] 7 (#$ . 18292)])
#@75 Anaphoric version of `f-directories'.
 
(fn PATH BODY &optional RECURSIVE)
(defalias 'f--directories '(macro . #[770 "\300\301\302\303\304EEF\207" [f-directories lambda (path) let ((it path))] 10 (#$ . 18657)]))
#@83 Find all directories in PATH.  See `f-entries'.
 
(fn PATH &optional FN RECURSIVE)
(defalias 'f-directories #[769 "\300\301\302\"\"\203\300\"\202\211\207" [-select f-directory\? f--collect-entries] 8 (#$ . 18878)])
#@69 Anaphoric version of `f-files'.
 
(fn PATH BODY &optional RECURSIVE)
(defalias 'f--files '(macro . #[770 "\300\301\302\303\304EEF\207" [f-files lambda (path) let ((it path))] 10 (#$ . 19107)]))
#@77 Find all files in PATH.  See `f-entries'.
 
(fn PATH &optional FN RECURSIVE)
(defalias 'f-files #[769 "\300\301\302\"\"\203\300\"\202\211\207" [-select f-file\? f--collect-entries] 8 (#$ . 19310)])
#@70 Anaphoric version of `f-traverse-upwards'.
 
(fn BODY &optional PATH)
(defalias 'f--traverse-upwards '(macro . #[513 "\300\301\302\303\304EEE\207" [f-traverse-upwards lambda (dir) let ((it dir))] 8 (#$ . 19522)]))
#@224 Traverse up as long as FN return nil, starting at PATH.
 
If FN returns a non-nil value, the path sent as argument to FN is
returned.  If no function callback return a non-nil value, nil is
returned.
 
(fn FN &optional PATH)
(defalias 'f-traverse-upwards #[513 "\211\204\262\301!\203\302!\262!\203\207\303!?\205&\304\305!\"\207" [default-directory f-relative\? f-expand f-root\? f-traverse-upwards f-parent] 6 (#$ . 19745)])
#@23 Return absolute root.
(defalias 'f-root #[0 "\300\301!\207" [f-traverse-upwards f-root\?] 2 (#$ . 20191)])
#@96 Only allow PATH-OR-PATHS and decendants to be modified in BODY.
 
(fn PATH-OR-PATHS &rest BODY)
(defalias 'f-with-sandbox '(macro . #[385 "\300\301\302\303D\304DFDC\305\300\306BB\307BBE\207" [let paths if listp list unwind-protect ((f--guard-paths paths)) ((setq f--guard-paths nil))] 9 (#$ . 20304)]))
(byte-code "\300\301\302\303#\304\305!\207" [function-put f-with-sandbox lisp-indent-function 1 provide f] 4)