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

Chizi123
2018-11-18 9d27fc972e84736015ab3b1c331888a8fe3d1276
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
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
;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 "\301\302!\210\301\303!\210\301\304!\210\301\305!\210\301\306\307\310#\203/\311\312\313\300!\205!\"\203/\314\315!\203/\315\316!\210\317\320\307\321\322\323\324\325&\210\317\326\307\327\324\320%\210\330\331\332\333\334DD\335\336\337\324\320\340\341&    \210\330\342\332\333\343DD\344\324\320\340\345&\210\330\346\332\333\347DD\350\324\320\340\351&\210\330\352\332\333\353DD\354\336\355\324\320\340\351&    \210\330\356\332\333\357DD\360\324\320\340\361&\210\362\363\364\365\324\326%\210\362\366\367\370\324\326%\210\362\371\372\373\324\326%\210\362\374\375\376\324\326%\210\362\377\201@\201A\324\326%\207" [async-bytecomp-allowed-packages require button cl-lib dash format-spec async-bytecomp nil t cl-intersection (all magit) boundp fboundp async-bytecomp-package-mode 1 custom-declare-group magit-popup "Infix arguments with a popup as feedback." :link (info-link "(magit-popup)") :group bindings magit-popup-faces "Faces used by Magit-Popup." custom-declare-variable magit-popup-display-buffer-action funcall function #[0 "\300\207" [((display-buffer-below-selected))] 1] "The action used to display a popup buffer.\n\nPopup buffers are displayed using `display-buffer' with the value\nof this option as ACTION argument.  You can also set this to nil\nand instead add an entry to `display-buffer-alist'." :package-version (magit-popup . "2.4.0") :type sexp magit-popup-manpage-package #[0 "\301>\203\302\207\303\207" [system-type (windows-nt ms-dos) woman man] 2] "The package used to display manpages.\nOne of `man' or `woman'." (choice (const man) (const woman)) magit-popup-show-help-echo #[0 "\300\207" [t] 1] "Show usage information in the echo area." boolean magit-popup-show-common-commands #[0 "\300\207" [nil] 1] "Whether to initially show section with commands common to all popups.\nThis section can also be toggled temporarily using \\<magit-popup-mode-map>\\[magit-popup-toggle-show-common-commands]." (magit-popup . "2.9.0") magit-popup-use-prefix-argument #[0 "\300\207" [default] 1] "Control how prefix arguments affect infix argument popups.\n\nThis option controls the effect that the use of a prefix argument\nbefore entering a popup has.\n\n`default'  With a prefix argument directly invoke the popup's\n           default action (an Emacs command), instead of bringing\n           up the popup.\n\n`popup'    With a prefix argument bring up the popup, otherwise\n           directly invoke the popup's default action.\n\n`nil'      Ignore prefix arguments." (choice (const :tag "Call default action instead of showing popup" default) (const :tag "Show popup instead of calling default action" popup) (const :tag "Ignore prefix argument" nil)) custom-declare-face magit-popup-heading ((t :inherit font-lock-keyword-face)) "Face for key mode header lines." magit-popup-key ((t :inherit font-lock-builtin-face)) "Face for key mode buttons." magit-popup-argument ((t :inherit font-lock-warning-face)) "Face used to display enabled arguments in popups." magit-popup-disabled-argument ((t :inherit shadow)) "Face used to display disabled arguments in popups." magit-popup-option-value ((t :inherit font-lock-string-face)) "Face used to display option values in popups."] 10)
#@901 Keymap for `magit-popup-mode'.
 
\<magit-popup-mode-map>This keymap contains bindings common to all popups.  A section
listing these commands can be shown or hidden using \[magit-popup-toggle-show-common-commands].
 
The prefix used to toggle any switch can be changed by binding
another key to `magit-invoke-popup-switch'.  Likewise binding
another key to `magit-invoke-popup-option' changes the prefixed
used to set any option.  The two prefixes have to be different.
If you change these bindings, you should also change the `prefix'
property of the button types `magit-popup-switch-button' and
`magit-popup-option-button'.
 
If you change any other binding, then you might have to also edit
`magit-popup-common-commands' for things to align correctly in
the section listing these commands.
 
Never bind an alphabetic character in this keymap or you might
make it impossible to invoke certain actions.
(defvar magit-popup-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\313#\210\301\315\316#\210\301\317\320#\210\301\321\322#\210\301\323\324#\210\325\326!\203_\301\327\330#\210\301\331\332#\210\301\333\334#\210\301\335\336#\210\202}\301\337\332#\210\301\340\334#\210\301\327\334#\210\301\333\336#\210\301\341\336#\210\211\207" [make-sparse-keymap define-key [remap self-insert-command] magit-invoke-popup-action [45 t] magit-invoke-popup-switch [61 t] magit-invoke-popup-option "" magit-popup-quit "?" magit-popup-help "k" "i" magit-popup-info "" magit-popup-toggle-show-common-commands "" magit-popup-set-default-arguments "" magit-popup-save-default-arguments featurep jkl "" universal-argument [return] push-button "    " backward-button " " forward-button " " "" ""] 5) (#$ . 3620))
(defvar magit-popup-common-commands '(("Set defaults" magit-popup-set-default-arguments) ("View popup manual" magit-popup-info) ("Toggle this section" magit-popup-toggle-show-common-commands) ("Save defaults" magit-popup-save-default-arguments) ("    Popup help prefix" magit-popup-help) ("Abort" magit-popup-quit)))
(byte-code "\300\301\302\303\304\305%\210\300\306\307\301\310\311\312\313\314\315\316\317\320\321\322\323\324\325&\210\300\326\307\301\310\327\312\330\314\331\316\317\320\332\322\333\324\325&\210\300\334\307\301\310\335\312\336\314\337\316\340\320\341\322\303\324\325&\210\300\342\307\301\310\335\312\343\314\344\316\345\320\341\322\303\324\346&\210\300\347\307\342\316\350\304\351&\210\300\352\307\347\314\353\324\354&\207" [define-button-type magit-popup-button face nil action #[257 "\300\301\"\300\302\"!\207" [button-get function event] 5 "\n\n(fn BUTTON)"] magit-popup-switch-button supertype function magit-invoke-popup-switch property :switches heading "Switches\n" formatter magit-popup-format-argument-button format " %k %d (%a)" prefix 45 maxcols 1 magit-popup-option-button magit-invoke-popup-option :options "Options\n" " %k %d (%a%v)" 61 magit-popup-variable-button magit-invoke-popup-action :variables "Variables\n" magit-popup-format-variable-button " %k %d" magit-popup-action-button :actions "Actions\n" magit-popup-format-action-button :max-action-columns magit-popup-command-button magit-popup-format-command-button #[257 "\300\301\"\211\302=?\205\303!\207" [button-get function push-button call-interactively] 4 "\n\n(fn BUTTON)"] magit-popup-internal-command-button "Common Commands\n" 3] 18)
#@125 The popup which is currently active.
This is intended for internal use only.
Don't confuse this with `magit-current-popup'.
(defvar magit-this-popup nil (#$ . 7058))
(make-variable-buffer-local 'magit-this-popup)
#@131 The events known to the active popup.
This is intended for internal use only.
Don't confuse this with `magit-current-popup-args'.
(defvar magit-this-popup-events nil (#$ . 7278))
(make-variable-buffer-local 'magit-this-popup-events)
(defvar magit-previous-popup nil nil)
(make-variable-buffer-local 'magit-previous-popup)
#@63 The buffer that was current before invoking the active popup.
(defvar magit-pre-popup-buffer nil (#$ . 7606))
(make-variable-buffer-local 'magit-pre-popup-buffer)
#@60 While a popup is active, get the value of PROP.
 
(fn PROP)
(defalias 'magit-popup-get #[257 "\211\302>\203 \303\"\207\303    J\"\207" [magit-this-popup-events magit-this-popup (:switches :options :variables :actions) plist-get] 4 (#$ . 7775)])
#@71 While a popup is active, set the value of PROP to VAL.
 
(fn PROP VAL)
(defalias 'magit-popup-put #[514 "\301>\203\302#\211\207\303\304\"\207" [magit-this-popup-events (:switches :options :variables :actions) plist-put error "Property %s isn't supported"] 6 (#$ . 8026)])
#@280 The popup from which this editing command was invoked.
 
Use this inside the `interactive' form of a popup aware command
to determine whether it was invoked from a popup and if so from
which popup.  If the current command was invoked without the use
of a popup, then this is nil.
(defvar magit-current-popup nil (#$ . 8312))
#@38 The popup action now being executed.
(defvar magit-current-popup-action nil (#$ . 8642))
#@830 The value of the popup arguments for this editing command.
 
If the current command was invoked from a popup, then this is
a list of strings of all the set switches and options.  This
includes arguments which are set by default not only those
explicitly set during this invocation.
 
When the value is nil, then that can be because no argument is
set, or because the current command wasn't invoked from a popup;
consult `magit-current-popup' to tell the difference.
 
Generally it is better to use `NAME-arguments', which is created
by `magit-define-popup', instead of this variable or the function
by the same name, because `NAME-argument' uses the default value
for the arguments when the editing command is invoked directly
instead of from a popup.  When the command is bound in several
popups that might not be feasible though.
(defvar magit-current-popup-args nil (#$ . 8738))
#@449 Return the value of the popup arguments for this editing command.
 
The value is the same as that of the variable by the same name
(which see), except that FILTER is applied.  FILTER is a list
of regexps; only arguments that match one of them are returned.
The first element of FILTER may also be `:not' in which case
only arguments that don't match any of the regexps are returned,
or `:only' which doesn't change the behaviour.
 
(fn &rest FILTER)
(defalias 'magit-current-popup-args #[128 "\211C\302\303\242@\304=\203\305\306\307\310\311!\312\"\313\314%\2028\242@\315=\203+\211\242A\240\210\305\306\316\310\311!\317\"\313\314%    \")\207" [-compare-fn magit-current-popup-args #[514 "\300\"\207" [magit-popup-arg-match] 5 "\n\n(fn A B)"] -filter :not make-byte-code 257 "\301\300\242A\"?\207" vconcat vector [-contains-p] 4 "\n\n(fn ARG)" :only "\301\300\242\"\207" [-contains-p]] 9 (#$ . 9624)])
#@114 The buffer that was current before invoking the active popup.
This is bound when invoking an action or variable.
(defvar magit-current-pre-popup-buffer nil (#$ . 10542))
#@279 Execute the forms in BODY in the buffer that current before the popup.
If `magit-current-pre-popup-buffer' is non-nil use that, else if
`magit-pre-popup-buffer' is non-nil use that, otherwise (when no
popup is involved) execute the forms in the current buffer.
 
(fn &rest BODY)
(defalias 'magit-with-pre-popup-buffer '(macro . #[128 "\300\301\302\303BBBBB\207" [--if-let (or magit-current-pre-popup-buffer magit-pre-popup-buffer) with-current-buffer it] 6 (#$ . 10719)]))
(byte-code "\300\301\302\303#\300\207" [function-put magit-with-pre-popup-buffer lisp-indent-function 0] 4)
#@23 
 
(fn PATTERN STRING)
(defalias 'magit-popup-arg-match #[514 "\301\302\303\304#)\266\203\204 \305\302\303\304#)\266\203\203(\304\306\307\"\"\207\211\230\207" [inhibit-changing-match-data "=$" nil t string-match "^-[A-Z]$" format "^%s\\(.*\\)$"] 9 (#$ . 11307)])
#@76 compiler-macro for inlining `magit-popup-event-p'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'magit-popup-event-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block magit-popup-event-p (and (memq (type-of cl-x) cl-struct-magit-popup-event-tags) t)) nil] 9 (#$ . 11590)])
(put 'magit-popup-event-p 'compiler-macro 'magit-popup-event-p--cmacro)
#@13 
 
(fn CL-X)
(defalias 'magit-popup-event-p #[257 "\301!>\205    \302\207" [cl-struct-magit-popup-event-tags type-of t] 3 (#$ . 11967)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put magit-popup-event-p side-effect-free error-free put magit-popup-event cl-deftype-satisfies] 5)
#@78 compiler-macro for inlining `magit-popup-event-key'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'magit-popup-event-key--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block magit-popup-event-key (or (magit-popup-event-p cl-x) (signal 'wrong-type-argument (list 'magit-popup-event cl-x))) (aref cl-x 1)) nil] 9 (#$ . 12270)])
(put 'magit-popup-event-key 'compiler-macro 'magit-popup-event-key--cmacro)
#@66 Access slot "key" of `magit-popup-event' struct CL-X.
 
(fn CL-X)
(defalias 'magit-popup-event-key #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-magit-popup-event-tags type-of signal wrong-type-argument magit-popup-event 1] 5 (#$ . 12701)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-popup-event-key side-effect-free t] 4)
#@78 compiler-macro for inlining `magit-popup-event-dsc'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'magit-popup-event-dsc--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block magit-popup-event-dsc (or (magit-popup-event-p cl-x) (signal 'wrong-type-argument (list 'magit-popup-event cl-x))) (aref cl-x 2)) nil] 9 (#$ . 13066)])
(put 'magit-popup-event-dsc 'compiler-macro 'magit-popup-event-dsc--cmacro)
#@66 Access slot "dsc" of `magit-popup-event' struct CL-X.
 
(fn CL-X)
(defalias 'magit-popup-event-dsc #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-magit-popup-event-tags type-of signal wrong-type-argument magit-popup-event 2] 5 (#$ . 13497)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-popup-event-dsc side-effect-free t] 4)
#@78 compiler-macro for inlining `magit-popup-event-arg'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'magit-popup-event-arg--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block magit-popup-event-arg (or (magit-popup-event-p cl-x) (signal 'wrong-type-argument (list 'magit-popup-event cl-x))) (aref cl-x 3)) nil] 9 (#$ . 13862)])
(put 'magit-popup-event-arg 'compiler-macro 'magit-popup-event-arg--cmacro)
#@66 Access slot "arg" of `magit-popup-event' struct CL-X.
 
(fn CL-X)
(defalias 'magit-popup-event-arg #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-magit-popup-event-tags type-of signal wrong-type-argument magit-popup-event 3] 5 (#$ . 14293)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-popup-event-arg side-effect-free t] 4)
#@78 compiler-macro for inlining `magit-popup-event-fun'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'magit-popup-event-fun--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block magit-popup-event-fun (or (magit-popup-event-p cl-x) (signal 'wrong-type-argument (list 'magit-popup-event cl-x))) (aref cl-x 4)) nil] 9 (#$ . 14658)])
(put 'magit-popup-event-fun 'compiler-macro 'magit-popup-event-fun--cmacro)
#@66 Access slot "fun" of `magit-popup-event' struct CL-X.
 
(fn CL-X)
(defalias 'magit-popup-event-fun #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-magit-popup-event-tags type-of signal wrong-type-argument magit-popup-event 4] 5 (#$ . 15089)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-popup-event-fun side-effect-free t] 4)
#@78 compiler-macro for inlining `magit-popup-event-use'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'magit-popup-event-use--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block magit-popup-event-use (or (magit-popup-event-p cl-x) (signal 'wrong-type-argument (list 'magit-popup-event cl-x))) (aref cl-x 5)) nil] 9 (#$ . 15454)])
(put 'magit-popup-event-use 'compiler-macro 'magit-popup-event-use--cmacro)
#@66 Access slot "use" of `magit-popup-event' struct CL-X.
 
(fn CL-X)
(defalias 'magit-popup-event-use #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-magit-popup-event-tags type-of signal wrong-type-argument magit-popup-event 5] 5 (#$ . 15885)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-popup-event-use side-effect-free t] 4)
#@78 compiler-macro for inlining `magit-popup-event-val'.
 
(fn CL-WHOLE-ARG CL-X)
(defalias 'magit-popup-event-val--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block magit-popup-event-val (or (magit-popup-event-p cl-x) (signal 'wrong-type-argument (list 'magit-popup-event cl-x))) (aref cl-x 6)) nil] 9 (#$ . 16250)])
(put 'magit-popup-event-val 'compiler-macro 'magit-popup-event-val--cmacro)
#@66 Access slot "val" of `magit-popup-event' struct CL-X.
 
(fn CL-X)
(defalias 'magit-popup-event-val #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-magit-popup-event-tags type-of signal wrong-type-argument magit-popup-event 6] 5 (#$ . 16681)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put magit-popup-event-val side-effect-free t defalias copy-magit-popup-event copy-sequence] 4)
#@109 compiler-macro for inlining `make-magit-popup-event'.
 
(fn CL-WHOLE &cl-quote &key KEY DSC ARG FUN USE VAL)
(defalias 'make-magit-popup-event--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262\202'\310>A@\203I\311\262\202'\312\313@\"\210\202'\210\314\315\316\311 \311      & \207" [plist-member :key :dsc :arg :fun :use :val (:key :dsc :arg :fun :use :val :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:key :dsc :arg :fun :use :val)" cl--defsubst-expand (key dsc arg fun use val) (cl-block make-magit-popup-event (record 'magit-popup-event key dsc arg fun use val))] 20 (#$ . 17103)])
(put 'make-magit-popup-event 'compiler-macro 'make-magit-popup-event--cmacro)
#@89 Constructor for objects of type `magit-popup-event'.
 
(fn &key KEY DSC ARG FUN USE VAL)
(defalias 'make-magit-popup-event #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262\202'\310>A@\203I\311\262\202'\312\313@\"\210\202'\210\314\315&\207" [plist-member :key :dsc :arg :fun :use :val (:key :dsc :arg :fun :use :val :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:key :dsc :arg :fun :use :val)" record magit-popup-event] 15 (#$ . 17904)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&    \207" [function-put make-magit-popup-event side-effect-free t cl-struct-define magit-popup-event nil cl-structure-object record ((cl-tag-slot) (key) (dsc) (arg) (fun) (use) (val)) cl-struct-magit-popup-event-tags] 11)
#@11 
 
(fn EV)
(defalias 'magit-popup-event-keydsc #[257 "\301!>\204\302\303\304D\"\210\211\305H\306\307!\203\202 \310!!\207" [cl-struct-magit-popup-event-tags type-of signal wrong-type-argument magit-popup-event 1 key-description vectorp vector] 5 (#$ . 18767)])
#@19 
 
(fn EVENT TYPE)
(defalias 'magit-popup-lookup #[514 "\301\302\303\304!\"\305\306\203D\203D@\203\301\262\2028\307!>\204,\310\311\312D\"\210\211\313H\232\2038\211\262\210\211T\262A\262\202    \266\211\207" [cl-struct-magit-popup-event-tags nil -filter magit-popup-event-p magit-popup-get t 0 type-of signal wrong-type-argument magit-popup-event 1] 11 (#$ . 19043)])
(defalias 'magit-popup-get-args #[0 "\300\301\302\303\301\304\305!\304\306!\"\"\"\207" [apply append mapcar #[257 "\301!>\205J\301!>\204\302\303\304D\"\210\211\305H\205J\306\307\301!>\204.\302\303\304D\"\210\310H\301!>\204A\302\303\304D\"\210\311H\206H\312#C\207" [cl-struct-magit-popup-event-tags type-of signal wrong-type-argument magit-popup-event 5 format "%s%s" 3 6 ""] 8 "\n\n(fn IT)"] magit-popup-get :switches :options] 8])
#@17 
 
(fn DEF FORM)
(defalias 'magit-popup-convert-events '(macro . #[514 "\300\301\302\303FE\207" [--map if (or (null it) (stringp it) (functionp it)) it] 7 (#$ . 19889)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put magit-popup-convert-events lisp-indent-function 1 put edebug-form-spec (form form)] 5)
#@16 
 
(fn VAL DEF)
(defalias 'magit-popup-convert-switches #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [mapcar make-byte-code 257 "\211\203\211;\204\301!\203\207\3028\303\304@\305A@\306\307\300\235\205'\310\311\312\313\f\"\2054\314\f8&\n\207" vconcat vector [functionp 2 make-magit-popup-event :key :dsc :arg :use t :fun string-prefix-p "++" 3] 15 "\n\n(fn IT)"] 9 (#$ . 20220)])
#@16 
 
(fn VAL DEF)
(defalias 'magit-popup-convert-options #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [mapcar make-byte-code 257 "\211\203\211;\204\301!\203\207\3028\303\304\"\305\300\306\307\203F\203F@\203/\305\262\202:\310\"\203:\211\262\210\211T\262A\262\202\266\211\262\311\312@\313A@\314\315\205^\306\316\n\205i\317\320\f\"\321\3228\206r\323&\f\207" vconcat vector [functionp 2 format "^%s\\(.*\\)" nil t 0 string-match make-magit-popup-event :key :dsc :arg :use :val match-string 1 :fun 3 read-from-minibuffer] 18 "\n\n(fn IT)"] 9 (#$ . 20634)])
#@16 
 
(fn VAL DEF)
(defalias 'magit-popup-convert-variables #[514 "\300\301\"\207" [mapcar #[257 "\211\203\211;\204\300!\203\207\301\302@A@\3038\3048\305\211&\207" [functionp record magit-popup-event 3 2 nil] 9 "\n\n(fn IT)"]] 5 (#$ . 21246)])
#@16 
 
(fn VAL DEF)
(defalias 'magit-popup-convert-actions #[514 "\300\301\"\207" [mapcar #[257 "\211\203\211;\204\300!\203\207\301\302@A@\303\3048\303\211&\207" [functionp record magit-popup-event nil 2] 9 "\n\n(fn IT)"]] 5 (#$ . 21506)])
#@7027 Define a popup command named NAME.
 
NAME should begin with the package prefix and by convention end
with `-popup'.  That name is used for the actual command as well
as for a variable used internally.  DOC is used as the doc-string
of that command.
 
Also define an option and a function named `SHORTNAME-arguments',
where SHORTNAME is NAME with the trailing `-popup' removed.  The
name of this option and this function can be overwritten using
the optional argument OPTION, but that is rarely advisable. As a
special case if OPTION is specified but nil, do not define this
option and this function at all.
 
The option `SHORTNAME-arguments' holds the default value for the
popup arguments.  It can be customized from within the popup or
using the Custom interface.
 
The function `SHORTNAME-arguments' is a wrapper around the
variable `magit-current-popup-args', both of which are intended
to be used inside the `interactive' form of commands commonly
invoked from the popup `NAME'.  When such a command is invoked
from that popup, then the function `SHORTNAME-arguments' returns
the value of the variable `magit-current-popup-args'; however
when the command is invoked directly, then it returns the default
value of the variable `SHORTNAME-arguments'.
 
Optional argument GROUP specifies the Custom group into which the
option is placed.  If omitted, then the option is placed into some
group the same way it is done when directly using `defcustom' and
omitting the group, except when NAME begins with "magit-", in
which case the group `magit-git-arguments' is used.
 
Optional argument MODE is deprecated, instead use the keyword
arguments `:setup-function' and/or `:refresh-function'.  If MODE
is non-nil, then it specifies the mode used by the popup buffer,
instead of the default, which is `magit-popup-mode'.
 
The remaining arguments should have the form
 
    [KEYWORD VALUE]...
 
The following keywords are meaningful (and by convention are
usually specified in that order):
 
`:actions'
  The actions which can be invoked from the popup.  VALUE is a
  list whose members have the form (KEY DESC COMMAND), see
  `magit-define-popup-action' for details.
 
  Actions are regular Emacs commands, which usually have an
  `interactive' form setup to consume the values of the popup
  `:switches' and `:options' when invoked from the corresponding
  popup, else when invoked as the default action or directly
  without using the popup, the default value of the variable
  `SHORTNAME-arguments'.  This is usually done by calling the
  function `SHORTNAME-arguments'.
 
  Members of VALUE may also be strings and functions, assuming
  the first member is a string or function.  In that case the
  members are split into sections and these special elements are
  used as headings.  If such an element is a function then it is
  called with no arguments and must return either a string, which
  is used as the heading, or nil, in which case the section is
  not inserted.
 
  Members of VALUE may also be nil.  This should only be used
  together with `:max-action-columns' and allows having gaps in
  the action grid, which can help arranging actions sensibly.
 
`:default-action'
  The default action of the popup which is used directly instead
  of displaying the popup buffer, when the popup is invoked with
  a prefix argument.  Also see `magit-popup-use-prefix-argument'
  and `:use-prefix', which can be used to inverse the meaning of
  the prefix argument.
 
`:use-prefix'
  Controls when to display the popup buffer and when to invoke
  the default action (if any) directly.  This overrides the
  global default set using `magit-popup-use-prefix-argument'.
  The value, if specified, should be one of `default' or `popup',
  or a function that is called with no arguments and returns one
  of these symbols.
 
`:max-action-columns'
  The maximum number of actions to display on a single line, a
  number or a function that returns a number and takes the name
  of the section currently being inserted as argument.  If there
  isn't enough room to display as many columns as specified here,
  then fewer are used.
 
`:switches'
  The popup arguments which can be toggled on and off.  VALUE
  is a list whose members have the form (KEY DESC SWITCH), see
  `magit-define-popup-switch' for details.
 
  Members of VALUE may also be strings and functions, assuming
  the first member is a string or function.  In that case the
  members are split into sections and these special elements are
  used as headings.  If such an element is a function then it is
  called with no arguments and must return either a string, which
  is used as the heading, or nil, in which case the section is
  not inserted.
 
`:options'
  The popup arguments which take a value, as in "--opt=OPTVAL".
  VALUE is a list whose members have the form (KEY DESC OPTION
  READER), see `magit-define-popup-option' for details.
 
  Members of VALUE may also be strings and functions, assuming
  the first member is a string or function.  In that case the
  members are split into sections and these special elements are
  used as headings.  If such an element is a function then it is
  called with no arguments and must return either a string, which
  is used as the heading, or nil, in which case the section is
  not inserted.
 
`:default-arguments'
  The default arguments, a list of switches (which are then
  enabled by default) and options with there default values, as
  in "--OPT=OPTVAL".
 
`:variables'
 
  Variables which can be set from the popup.  VALUE is a list
  whose members have the form (KEY DESC COMMAND FORMATTER), see
  `magit-define-popup-variable' for details.
 
  Members of VALUE may also be strings and functions, assuming
  the first member is a string or function.  In that case the
  members are split into sections and these special elements are
  used as headings.  If such an element is a function then it is
  called with no arguments and must return either a string, which
  is used as the heading, or nil, in which case the section is
  not inserted.
 
  Members of VALUE may also be actions as described above for
  `:actions'.
 
  VALUE may also be a function that returns a list as describe
  above.
 
`:sequence-predicate'
  When this function returns non-nil, then the popup uses
  `:sequence-actions' instead of `:actions', and does not show
  the `:switches' and `:options'.
 
`:sequence-actions'
  The actions which can be invoked from the popup, when
  `:sequence-predicate' returns non-nil.
 
`:setup-function'
  When this function is specified, then it is used instead of
  `magit-popup-default-setup'.
 
`:refresh-function'
  When this function is specified, then it is used instead of
  calling `magit-popup-insert-section' three times with symbols
  `magit-popup-switch-button', `magit-popup-option-button', and
  finally `magit-popup-action-button' as argument.
 
`:man-page'
  The name of the manpage to be displayed when the user requests
  help for a switch or argument.
 
(fn NAME DOC [GROUP [MODE [OPTION]]] :KEYWORD VALUE...)
(defalias 'magit-define-popup '(macro . #[642 "\300!\301@!\203\302\303\"\205\304\202\211A\262\242\301@!?\205)\211A\262\242\301@!\203F\305\306\307\"\203?\310\311O\202@\312P!\202N\313\211A\262\242!\314\315\316    \317\320\321D    \322BBB\257\323    \324\325\321D BBBE\326\321 DD\205\262\327\330 \331BB\332\333 \205\217\334\fD\335\"BBBB\315\336\337\340\341\321DE\342 FF\343\321D\344\321DFEBBBB\207" [symbol-name keywordp string-prefix-p "magit-" 'magit-git-arguments intern string-suffix-p "-popup" 0 -6 "-arguments" eval progn defun (&optional arg) (interactive "P") magit-invoke-popup quote (arg) defvar list :variable magit-define-popup-keys-deferred defcustom plist-get (:default-arguments) "" append :group (:type '(repeat (string :tag "Argument"))) nil if eq magit-current-popup magit-current-popup-args put 'definition-name] 20 (#$ . 21762)]))
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put magit-define-popup lisp-indent-function defun doc-string-elt 2] 5)
#@915 In POPUP, define KEY as SWITCH.
 
POPUP is a popup command defined using `magit-define-popup'.
SWITCH is a string representing an argument that takes no value.
KEY is a character representing the second event in the sequence
of keystrokes used to toggle the argument.  (The first event, the
prefix, is shared among all switches, defaults to -, and can be
changed in `magit-popup-mode-keymap').
 
DESC is a string describing the purpose of the argument, it is
displayed in the popup.
 
If optional ENABLE is non-nil, then the switch is on by default.
 
SWITCH is inserted after all other switches already defined for
POPUP, unless optional PREPEND is non-nil, in which case it is
placed first.  If optional AT is non-nil, then it should be the
KEY of another switch already defined for POPUP, the argument
is then placed before or after AT, depending on PREPEND.
 
(fn POPUP KEY DESC SWITCH &optional ENABLE AT PREPEND)
(defalias 'magit-define-popup-switch #[1796 "\300\301E&\207" [magit-define-popup-key :switches] 14 (#$ . 29824)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-define-popup-switch lisp-indent-function defun] 4)
#@1540 In POPUP, define KEY as OPTION.
 
POPUP is a popup command defined using `magit-define-popup'.
OPTION is a string representing an argument that takes a value.
KEY is a character representing the second event in the sequence
of keystrokes used to set the argument's value.  (The first
event, the prefix, is shared among all options, defaults to =,
and can be changed in `magit-popup-mode-keymap').
 
DESC is a string describing the purpose of the argument, it is
displayed in the popup.
 
If optional VALUE is non-nil then the option is on by default,
and VALUE is its default value.
 
READER is used to read a value from the user when the option is
invoked and does not currently have a value.  (When the option
has a value, then invoking the option causes it to be unset.)
This function must take two arguments but may choose to ignore
them.  The first argument is the name of the option (with ": "
appended, unless it ends with "=") and can be used as the
prompt.  The second argument is nil or the value that was in
effect before the option was unset, which may be suitable as
initial completion input.  If no reader is specified, then
`read-from-minibuffer' is used.
 
OPTION is inserted after all other options already defined for
POPUP, unless optional PREPEND is non-nil, in which case it is
placed first.  If optional AT is non-nil, then it should be the
KEY of another option already defined for POPUP, the argument
is then placed before or after AT, depending on PREPEND.
 
(fn POPUP KEY DESC OPTION &optional READER VALUE AT PREPEND)
(defalias 'magit-define-popup-option #[2052 "\300\301                    F&\207" [magit-define-popup-key :options] 16 (#$ . 30985)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-define-popup-option lisp-indent-function defun] 4)
#@828 In POPUP, define KEY as COMMAND.
 
POPUP is a popup command defined using `magit-define-popup'.
COMMAND is a command which calls `magit-popup-set-variable'.
FORMATTER is a function which calls `magit-popup-format-variable'.
These two functions have to be called with the same arguments.
 
KEY is a character representing the event used interactively call
the COMMAND.
 
DESC is the variable or a representation thereof.  It's not
actually used for anything.
 
COMMAND is inserted after all other commands already defined for
POPUP, unless optional PREPEND is non-nil, in which case it is
placed first.  If optional AT is non-nil, then it should be the
KEY of another command already defined for POPUP, the command
is then placed before or after AT, depending on PREPEND.
 
(fn POPUP KEY DESC COMMAND FORMATTER &optional AT PREPEND)
(defalias 'magit-define-popup-variable #[1797 "\300\301E&\207" [magit-define-popup-key :variables] 14 (#$ . 32771)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-define-popup-variable lisp-indent-function defun] 4)
#@751 In POPUP, define KEY as COMMAND.
 
POPUP is a popup command defined using `magit-define-popup'.
COMMAND can be any command but should usually consume the popup
arguments in its `interactive' form.
KEY is a character representing the event used invoke the action,
i.e. to interactively call the COMMAND.
 
DESC is a string describing the purpose of the action, it is
displayed in the popup.
 
COMMAND is inserted after all other commands already defined for
POPUP, unless optional PREPEND is non-nil, in which case it is
placed first.  If optional AT is non-nil, then it should be the
KEY of another command already defined for POPUP, the command
is then placed before or after AT, depending on PREPEND.
 
(fn POPUP KEY DESC COMMAND &optional AT PREPEND)
(defalias 'magit-define-popup-action #[1540 "\300\301D&\207" [magit-define-popup-key :actions] 13 (#$ . 33849)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-define-popup-action lisp-indent-function defun] 4)
#@112 Like `magit-define-popup-action' but for `:sequence-action'.
 
(fn POPUP KEY DESC COMMAND &optional AT PREPEND)
(defalias 'magit-define-popup-sequence-action #[1540 "\300\301D&\207" [magit-define-popup-key :sequence-actions] 13 (#$ . 34842)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-define-popup-sequence-action lisp-indent-function defun] 4)
(defconst magit-popup-type-plural-alist '((:switch . :switches) (:option . :options) (:variable . :variables) (:action . :actions) (:sequence-action . :sequence-actions)))
#@13 
 
(fn TYPE)
(defalias 'magit-popup-pluralize-type #[257 "\211\236A\206\211\207" [magit-popup-type-plural-alist] 3 (#$ . 35394)])
#@322 In POPUP, define KEY as an action, switch, or option.
It's better to use one of the specialized functions
  `magit-define-popup-action',
  `magit-define-popup-sequence-action',
  `magit-define-popup-switch',
  `magit-define-popup-option', or
  `magit-define-popup-variable'.
 
(fn POPUP TYPE KEY DEF &optional AT PREPEND)
(defalias 'magit-define-popup-key #[1540 "\300!\262\301>\203\264\302!\203\241J\303\"\304\"\211\203*\211\241\210\2021B\262\203r\305\306\307\310\311&\211\262\203~\312\306\307\310\311&\262\203f@\211AB\241\266\240\210\202~\211AB\241\266\202~\312\306\307\310\311&\262\304\"\204\227\203\220\211B\202\225\313C\"\262\314\n#L\207\257\315\316\316NB#\207\317\320\"\207" [magit-popup-pluralize-type (:switches :options :variables :actions :sequence-actions) boundp plist-get assoc cl-member :key car-safe :test equal cl-delete append plist-put put magit-popup-deferred error "Unknown popup event type: %s"] 16 (#$ . 35533)])
(byte-code "\300\301\302\303#\300\207" [function-put magit-define-popup-key lisp-indent-function defun] 4)
#@14 
 
(fn POPUP)
(defalias 'magit-define-popup-keys-deferred #[257 "\211\300N\211\203'\211@\3011\302\303#0\202\304\305\306!\307#\262\210A\266\202\202\210\310\300\311#\207" [magit-popup-deferred (debug error) apply magit-define-popup-key display-warning magit error-message-string :error put nil] 8 (#$ . 36664)])
#@189 In POPUP, bind TO to what FROM was bound to.
TYPE is one of `:action', `:sequence-action', `:switch', or
`:option'.  Bind TO and unbind FROM, both are characters.
 
(fn POPUP TYPE FROM TO)
(defalias 'magit-change-popup-key #[1028 "\300\301J\302!\"\"\211\203\211\240\202\303\304\"\207" [assoc plist-get magit-popup-pluralize-type message "magit-change-popup-key: FROM key %c is unbound"] 10 (#$ . 36993)])
#@240 In POPUP, remove KEY's binding of TYPE.
POPUP is a popup command defined using `magit-define-popup'.
TYPE is one of `:action', `:sequence-action', `:switch', or
`:option'.  KEY is the character which is to be unbound.
 
(fn POPUP TYPE KEY)
(defalias 'magit-remove-popup-key #[771 "\300!\262J\301\"\302\"\303\304\"#L\207" [magit-popup-pluralize-type plist-get assoc plist-put delete] 13 (#$ . 37415)])
(defvar magit-popup-previous-winconf nil nil)
(make-variable-buffer-local 'magit-popup-previous-winconf)
#@23 
 
(fn POPUP MODE ARG)
(defalias 'magit-invoke-popup #[771 "J\306\307\"J\306\310\"\306\311\"\312!\203\211 \202\211\211\206 \211\313=\203+\2046\211\314=\203\200\204\200\203q\313D    \315\316\"\210\317 *\203j<\203j@\320U?\205i@\320\245C\321!*\202\270\322\323\n\"\210\324        \"\202\270\211\325>\203\251\324        \"\210!\205\270\322\326\327\330\331\332\333#\330\334\332\333#\330\335\332\333#$!\202\270\203\264\336\337\"\202\270\336\340\"\207" [magit-popup-use-prefix-argument magit-this-popup-events magit-this-popup magit-current-popup-args magit-current-popup current-prefix-arg plist-get :variable :default-action :use-prefix functionp default popup nil magit-popup-default-setup magit-popup-get-args 4 call-interactively message "%s has no default action; showing popup instead." magit-popup-mode-setup (default popup nil) format "[%s] show common commands, [%s] describe events, [%s] show manual" propertize "C-t" face magit-popup-key "?" "C-h i" error "Invalid :use-prefix popup property value: %s" "Invalid magit-popup-use-prefix-argument value: %s" magit-popup-show-help-echo] 18 (#$ . 37940)])
#@14 
 
(fn EVENT)
(defalias 'magit-invoke-popup-switch #[257 "\301\302\"\211\2036\303!>\204\304\305\306D\"\210\211\211\307\303!>\204*\304\305\306D\"\210\307H?I\266\310 \202:\311\312\"\207" [cl-struct-magit-popup-event-tags magit-popup-lookup :switches type-of signal wrong-type-argument magit-popup-event 5 magit-refresh-popup-buffer user-error "%c isn't bound to any switch"] 9 (#$ . 39096) (list last-command-event)])
#@14 
 
(fn EVENT)
(defalias 'magit-invoke-popup-option #[257 "\302\303\"\211\203\263\304!>\204\305\306\307D\"\210\211\310H\2036\304!>\204,\305\306\307D\"\210\211\211\310\311I\266\202\256\304!>\204E\305\306\307D\"\210\211\312H\304!>\204W\305\306\307D\"\210\313H\314\311\315\316#)\266\203?\205m\317P\304!>\204~\305\306\307D\"\210\320H\"\304!>\204\221\305\306\307D\"\210\211\310\315I\266\304!>\204\247\305\306\307D\"\210\211\320I\266\321 \202\267\322\323\"\207" [cl-struct-magit-popup-event-tags inhibit-changing-match-data magit-popup-lookup :options type-of signal wrong-type-argument magit-popup-event 5 nil 3 4 "=$" t string-match ": " 6 magit-refresh-popup-buffer user-error "%c isn't bound to any option"] 12 (#$ . 39533) (list last-command-event)])
#@14 
 
(fn EVENT)
(defalias 'magit-invoke-popup-action #[257 "\306\307\"\306\310\"\211\203'\311!>\204\312\313\314D\"\210\211\315H\204'\211\262\316\262\204/\211\203r    \317 \f\311\206<!>\204M\312\313\314\206JD\"\210\206R\211\320H\211\203^\321 \210\211\322!\210?\205l\323 ,\262\202\214\324=\203\210\321 \210\205\214\325\316\"\202\214\326\327\"\207" [cl-struct-magit-popup-event-tags magit-this-popup magit-current-popup magit-current-popup-args magit-pre-popup-buffer magit-current-pre-popup-buffer magit-popup-lookup :actions :variables type-of signal wrong-type-argument magit-popup-event 3 nil magit-popup-get-args 4 magit-popup-quit call-interactively magit-refresh-popup-buffer 113 magit-popup-mode-setup user-error "%c isn't bound to any action" magit-current-popup-action this-command magit-previous-popup] 7 (#$ . 40338) (list last-command-event)])
#@60 Quit the current popup command without invoking an action.
(defalias 'magit-popup-quit #[0 "\301\302!\203 \303 \210\202\304\305!\210\306\300!\210\211\205\307!\207" [magit-popup-previous-winconf derived-mode-p magit-popup-mode kill-buffer magit-popup-help-mode -1 kill-local-variable set-window-configuration] 3 (#$ . 41239) nil])
#@88 Like `read-number' but DEFAULT may be a numeric string.
 
(fn PROMPT &optional DEFAULT)
(defalias 'magit-popup-read-number #[513 "\300;\203 \301!\202\"\207" [read-number string-to-number] 6 (#$ . 41582)])
#@298 Set default value for the arguments for the current popup.
Then close the popup without invoking an action; unless a prefix
argument is used in which case the popup remains open.
 
For a popup named `NAME-popup' that usually means setting the
value of the custom option `NAME-arguments'.
 
(fn ARG)
(defalias 'magit-popup-set-default-arguments #[257 "\300\301!\211\203\302\303 \"\210?\205\304 \202\305\306!\207" [magit-popup-get :variable customize-set-variable magit-popup-get-args magit-popup-quit user-error "Nothing to set"] 5 (#$ . 41800) "P"])
#@298 Save default value for the arguments for the current popup.
Then close the popup without invoking an action; unless a prefix
argument is used in which case the popup remains open.
 
For a popup named `NAME-popup' that usually means saving the
value of the custom option `NAME-arguments'.
 
(fn ARG)
(defalias 'magit-popup-save-default-arguments #[257 "\300\301!\211\203\302\303 \"\210?\205\304 \202\305\306!\207" [magit-popup-get :variable customize-save-variable magit-popup-get-args magit-popup-quit user-error "Nothing to save"] 5 (#$ . 42363) "P"])
#@174 Show or hide an additional section with common commands.
The commands listed in this section are common to all popups
and are defined in `magit-popup-mode-map' (which see).
(defalias 'magit-popup-toggle-show-common-commands #[0 "?\301 \210\302 \207" [magit-popup-show-common-commands magit-refresh-popup-buffer fit-window-to-buffer] 1 (#$ . 42929) nil])
#@48 Show help for the argument or action at point.
(defalias 'magit-popup-help #[0 "\301\302!\303\304\205\n\305\306Q!\211GSH\307\310 \311#\206 \307\312 \"\211\313=\203\202\314\315\"\211\203y\316\317\320!>\204?\321\322\323D\"\210\324H\"\203r\320!>\204U\321\322\323D\"\210\211\325H\203r\326\320!>\204k\321\322\323D\"\210\325H!\202}\327\"\202}\330\331\"\262\2028\211\332=\203\344\314\333\"\211\203\333\316\317\320!>\204\241\321\322\323D\"\210\324H\"\203\324\320!>\204\267\321\322\323D\"\210\211\325H\203\324\326\320!>\204\315\321\322\323D\"\210\325H!\202\337\327\"\202\337\330\334\"\262\2028\211\335=\203\361\327\336\"\2028\211\337>\203(\314\340\"\206\314\341\"\262\211\203\326\320!>\204\321\322\323D\"\210\325H!\2028\342 \210\343\336!\2028\211\2045\342 \210\343\336!\2028\326!\207" [cl-struct-magit-popup-event-tags magit-popup-get :man-page read-key-sequence "Describe key" " (? for manpage)" ": " lookup-key current-local-map t current-global-map magit-invoke-popup-switch magit-popup-lookup :switches string-prefix-p "++" type-of signal wrong-type-argument magit-popup-event 3 4 magit-popup-describe-function magit-popup-manpage user-error "%c isn't bound to any switch" magit-invoke-popup-option :options "%c isn't bound to any option" magit-popup-help nil (magit-invoke-popup-action self-insert-command) :actions :variables ding message] 11 (#$ . 43291) nil])
#@18 
 
(fn TOPIC ARG)
(defalias 'magit-popup-manpage #[514 "\204 \306\307\310\311!\"\210\211\203N\312!>\204\313\314\315D\"\210\211\316H\262\317\320\"\203N\211\321\230\2034\322\202L\317\323\"\203E\320\324\325\326OQ\202L\320\327\330\326OQ\262\331 \326    \332\267\202\226\333 \210\334 \210\326\211\211\335!+\210p\262\202\226\336\337K\340\341\342\343\344!\345\"\330$\216\337M\210\346!\262)\266\333 \210\334 \210\347\350 \"\210r\211q\210\351 \210\352\353 !\210\203\357\354\355!\203\357\326\3568\357\360\361\362    \363\"\203\316\211\341GGZO\266\202\202\320\262\363\362 \"\203\334\364\202\335\365%\326\366#)\266\202\203\357\367\224b\202\361eb)\207" [cl-struct-magit-popup-event-tags magit-popup-manpage-package display-buffer-overriding-action display-buffer-function display-buffer-alist magit-popup-previous-winconf user-error "No man page associated with %s" magit-popup-get :man-page type-of signal wrong-type-argument magit-popup-event 3 string-prefix-p "--" "-- " "\\(?:\\[--\\] \\)?<[^[:space:]]+>\\.\\.\\." "--no-" "\\[?no-\\]?" 5 nil "\\(?:\\[no-\\]\\)?" 2 current-window-configuration #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (woman 87 man 110)) delete-other-windows split-window-below woman #[257 "\300\207" [nil] 2 "\n\n(fn _)"] fboundp make-byte-code 0 "\301\300M\207" vconcat vector [fboundp] man set-window-buffer selected-window magit-popup-help-mode fit-window-to-buffer next-window Man-find-section "OPTIONS" "-\\(?:. \\|-[^[:space:]]+ \\)?[^[:space:]]+" re-search-forward format "^[     ]+\\(?:%s, \\)*?\\(?1:%s\\)%s\\(?:, %s\\)*$" "=" string-suffix-p "\\(?: \\|\\[?=\\)[^[:space:]]*[^.[:space:]]" "\\(?:\\(?: \\| ?[\\[<:]\\)[^[:space:]]*[^.[:space:]]\\)?" t 1 case-fold-search] 16 (#$ . 44736)])
#@17 
 
(fn FUNCTION)
(defalias 'magit-popup-describe-function #[257 "\305 \306 \210\307 \210\310\311!\210\312\313\211\211\314!,\210\315 \210\310\311!\210\211\316 \207" [help-window-select display-buffer-overriding-action display-buffer-function display-buffer-alist magit-popup-previous-winconf current-window-configuration delete-other-windows split-window-below other-window 1 (("" display-buffer-use-some-window)) nil describe-function fit-window-to-buffer magit-popup-help-mode] 6 (#$ . 46539)])
#@24 Show the popup manual.
(defalias 'magit-popup-info #[0 "\301 \302 \210\303 \210\304\305!\210\306 \210\306 \210\307\310 !\207" [magit-popup-previous-winconf current-window-configuration delete-other-windows split-window-below info "(magit-popup.info)Usage" magit-popup-help-mode fit-window-to-buffer next-window] 3 (#$ . 47046) nil])
#@111 Non-nil if Magit-Popup-Help mode is enabled.
Use the command `magit-popup-help-mode' to change this variable.
(defvar magit-popup-help-mode nil (#$ . 47387))
(make-variable-buffer-local 'magit-popup-help-mode)
#@285 Auxiliary minor mode used to restore previous window configuration.
When some sort of help buffer is created from within a popup,
then this minor mode is turned on in that buffer, so that when
the user quits it, the previous window configuration is also
restored.
 
(fn &optional ARG)
(defalias 'magit-popup-help-mode #[256 "\301 \302=\203 ?\202\303!\304V\305\306\203\307\202\310\"\210\311\312!\203B\301 \2032\211\301 \232\203B\313\314\315\203=\316\202>\317#\266\210\320 \210\207" [magit-popup-help-mode current-message toggle prefix-numeric-value 0 run-hooks magit-popup-help-mode-hook magit-popup-help-mode-on-hook magit-popup-help-mode-off-hook called-interactively-p any " in current buffer" message "Magit-Popup-Help mode %sabled%s" "en" "dis" force-mode-line-update] 7 (#$ . 47604) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
(defvar magit-popup-help-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\300\207" [magit-popup-help-mode-hook variable-documentation put "Hook run after entering or leaving `magit-popup-help-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)"] 4)
#@37 Keymap for `magit-popup-help-mode'.
(defvar magit-popup-help-mode-map (byte-code "\300\301!\203 \211\202\211<\203\302!\202\303\304\"\207" [(([remap Man-quit] . magit-popup-quit) ([remap Info-exit] . magit-popup-quit) ([remap quit-window] . magit-popup-quit)) keymapp easy-mmode-define-keymap error "Invalid keymap %S"] 4) (#$ . 48828))
(byte-code "\301\302\303\303\211%\207" [magit-popup-help-mode-map add-minor-mode magit-popup-help-mode nil] 6)
(defvar magit-popup-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [magit-popup-mode-hook variable-documentation put "Hook run after entering MagitPopup mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp magit-popup-mode-map definition-name magit-popup-mode] 4)
(defvar magit-popup-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\317#\207" [magit-popup-mode-abbrev-table magit-popup-mode-map variable-documentation put purecopy "Keymap for `magit-popup-mode'." boundp magit-popup-mode-syntax-table definition-name magit-popup-mode (lambda (#1=#:def-tmp-var) (defvar magit-popup-mode-syntax-table #1#)) make-syntax-table "Syntax table for `magit-popup-mode'." (lambda (#1#) (defvar magit-popup-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `magit-popup-mode'." derived-mode-parent] 5)
#@170 Major mode for infix argument popups.
 
This mode runs the hook `magit-popup-mode-hook', as the final or penultimate step
during initialization.
 
\{magit-popup-mode-map}
(defalias 'magit-popup-mode #[0 "\306\300!\210\307\310 \210\311\312\313 !\210\314\f!\210 \307\211\306\315!\210\316 \306\317!\210\320 \210)\321\322!\207" [delay-mode-hooks major-mode mode-name magit-popup-mode-map magit-popup-mode-syntax-table magit-popup-mode-abbrev-table make-local-variable t kill-all-local-variables magit-popup-mode "MagitPopup" use-local-map set-syntax-table scroll-margin 0 magit-popup-show-common-commands hack-dir-local-variables-non-file-buffer run-mode-hooks magit-popup-mode-hook local-abbrev-table truncate-lines buffer-read-only] 3 (#$ . 50495) nil])
(put 'magit-popup-mode 'mode-class 'special)
#@16 
 
(fn VAL DEF)
(defalias 'magit-popup-default-setup #[514 "\300\301!\211\205    \211 \262\203\302\303\304\300\305!\"\"\207\306\307\"\310!\203&\211 \262\211\2032\302\307\311\"\"\210\210\302\312\313\306\312\"\"\"\210\302\314\315\306\314\"\"\"\210\302\303\304\306\303\"\"\"\207" [magit-popup-get :sequence-predicate magit-popup-put :actions magit-popup-convert-actions :sequence-actions plist-get :variables functionp magit-popup-convert-variables :switches magit-popup-convert-switches :options magit-popup-convert-options] 9 (#$ . 51310)])
#@19 
 
(fn POPUP MODE)
(defalias 'magit-popup-mode-setup #[514 "\305J\306\"JJp\307\310\311\312\"!\206\313\"\210\211\314\304!\2031\f\2031\315\304#\210\202<\316\317!\2068\320\"\210\266\321 \210\322\323\211\324d!#\207" [magit-current-popup magit-previous-popup magit-this-popup magit-pre-popup-buffer magit-popup-setup-hook plist-get :variable magit-popup-mode-display-buffer get-buffer-create format "*%s*" magit-popup-mode boundp run-hook-with-args magit-popup-get :setup-function magit-popup-default-setup magit-refresh-popup-buffer fit-window-to-buffer nil line-number-at-pos] 10 (#$ . 51870)])
#@20 
 
(fn BUFFER MODE)
(defalias 'magit-popup-mode-display-buffer #[514 "\302 \303\304\"!\210 \210\211\211\207" [magit-popup-display-buffer-action magit-popup-previous-winconf current-window-configuration select-window display-buffer] 7 (#$ . 52488)])
#@233 Hook run by `magit-refresh-popup-buffer'.
 
The hook is run right after inserting the representation of the
popup events but before optionally inserting the representation
of events shared by all popups and before point is adjusted.
(defvar magit-refresh-popup-buffer-hook nil (#$ . 52747))
(defalias 'magit-refresh-popup-buffer #[0 "\303\304`!\211\205 \305\306\"\205\305\307\"\310 \210\212\311\312!\211\203&\211 \210\2026\313\314!\210\313\315!\210\313\316!\210\313\317!\210\210\320\321!\210    \203D\322\323\n\"\210)\324\325!\210\211\205|\3261X\327\330!0\202]\210\325\202|\205|\304`!\305\306\"\232?\206t\305\307\"\232?\262\205|\202M)\207" [inhibit-read-only magit-popup-show-common-commands magit-popup-common-commands t button-at button-get prefix event erase-buffer magit-popup-get :refresh-function magit-popup-insert-section magit-popup-variable-button magit-popup-switch-button magit-popup-option-button magit-popup-action-button run-hooks magit-refresh-popup-buffer-hook magit-popup-insert-command-section magit-popup-internal-command-button set-buffer-modified-p nil (error) forward-button 1] 7])
#@64 Minimal amount of whitespace between columns in popup buffers.
(defvar magit-popup-min-padding 3 (#$ . 53877))
#@36 
 
(fn TYPE &optional SPEC HEADING)
(defalias 'magit-popup-insert-section #[769 "\204\231\301\302\303\"!\262\205\236@;\204\304@!\203\224\211\205u\305@\211C;\206/\304!\305A\211\203j\211@\211;\206@\304!\232\203Z\203]\237B\262\305\262\305\262\202]\306\262B\262A\266\203\2022\237B\262\237\266\206\262\307\205\223@\310A@#\266\211T\262A\262\202x\207\310\"\207\302\311\"\312\313\314\315\316\317    \"\320\"\321\322%\206\270\301\302\303\"!\"\302\323\"\301\324!\205\234\304!\203\332 \211\262\203\367\325\261\210\202\367\204\345\302\326\"\262\327\330\331#c\210\332\333\"\204\367\334c\210\211\203\211 \203\305\262\202\335!\203\301!\262\2029\203J\262\304!\203(!\262\205\234\336\337\312\340\"\"\\\211\203\214\211@n\204pi\246Z\341i#\342 W\203l\343i\344_\245!\206_\345W\203l\346\347\"c\210\202o\334c\210\210\211\350\232\204\205\211\203\202\336\351\"\210\202\205\347c\210A\266\202\2027\266`Sf\325U\203\232\334\202\233\352c\266\204\207" [magit-popup-min-padding magit-popup-get button-type-get property functionp nil t 0 magit-popup-insert-section formatter mapcar make-byte-code 257 "\211\205\f\301\300\"\206\f\302\207" vconcat vector [(#1="")] 4 "\n\n(fn EV)" maxcols :sequence-predicate 10 heading propertize face magit-popup-heading string-match "\n$" "\n" keywordp apply max #[257 "\211@G\207" [] 2 "\n\n(fn E)"] + window-width ceiling 1.0 1000 make-string 32 (#1#) insert-button "\n\n"] 15 (#$ . 53994)])
#@16 
 
(fn TYPE EV)
(defalias 'magit-popup-format-argument-button #[514 "\301\302\303\"\304\305\302\306\"\211\205\307!\262\310!P\311\312#B\313\314!>\204/\315\316\317D\"\210\320HB\321\305\314!>\204F\315\316\317    D\"\210\322H\311\314    !>\204\\\315\316\317 D\"\210\323H\203g\324\202h\325#B\326\314!>\204|\315\316\317    D\"\210\327H\314!>\204\221\315\316\317\nD\"\210\323H\203\251\211\330\232\204\251\305\303\331\"\311\332#\202\252\330\262BF\"\333\334\314!>\204\302\315\316\317D\"\210\335H\257\207" [cl-struct-magit-popup-event-tags format-spec button-type-get format 107 propertize prefix char-to-string magit-popup-event-keydsc face magit-popup-key 100 type-of signal wrong-type-argument magit-popup-event 2 97 3 5 magit-popup-argument magit-popup-disabled-argument 118 6 "" "\"%s\"" magit-popup-option-value type event 1] 14 (#$ . 55535)])
#@16 
 
(fn TYPE EV)
(defalias 'magit-popup-format-variable-button #[514 "\301!>\204\302\303\304D\"\210\211\305H\204\306\307\"\207\310\311\312\"\313\314\315!\316\317#B\320\301!>\2049\302\303\304D\"\210\305H BD\"\321\322\301!>\204S\302\303\304D\"\210\323H\257\207" [cl-struct-magit-popup-event-tags type-of signal wrong-type-argument magit-popup-event 3 magit-popup-format-action-button magit-popup-action-button format-spec button-type-get format 107 propertize magit-popup-event-keydsc face magit-popup-key 100 type event 1] 10 (#$ . 56428)])
#@16 
 
(fn TYPE EV)
(defalias 'magit-popup-format-action-button #[514 "\302!>\204\303\304\305D\"\210\211\306H\302!>\204!\303\304\305D\"\210\307H\310!\205+\211    \20579\2057\311N?\205\251\211\203[\211 \211\205W\312\313G\314\315%\203T\211\202W\316!\262\262\205\251\317\320\321\"\322\323\324!\314\325#B\326B\327\204\211\330\331!=\203\211\323\314\332#\202\213BE\"\333\334\302!>\204\243\303\304\305\nD\"\210\335H\257\207" [cl-struct-magit-popup-event-tags disabled-command-function type-of signal wrong-type-argument magit-popup-event 4 2 functionp disabled text-property-not-all 0 face nil magit-branch-set-face format-spec button-type-get format 107 propertize magit-popup-event-keydsc magit-popup-key 100 68 magit-popup-get :default-action bold type event 1] 14 (#$ . 56996)])
#@18 
 
(fn TYPE SPEC)
(defalias 'magit-popup-insert-command-section #[514 "\300\301\302\"\"\207" [magit-popup-insert-section mapcar #[257 "\300A@\301 \"@@D\207" [where-is-internal current-local-map] 4 "\n\n(fn ELT)"]] 7 (#$ . 57823)])
#@17 
 
(fn TYPE ELT)
(defalias 'magit-popup-format-command-button #[514 "\300\301\302@A@\303\211\211\211&\"\304\305\306 @\"D\244\207" [magit-popup-format-action-button record magit-popup-event nil function lookup-key current-local-map] 12 (#$ . 58063)])
#@19 
 
(fn ARGS FILES)
(defalias 'magit-popup-import-file-args #[514 "\211\203\300\301\302\303#PB\207\207" ["-- " mapconcat identity ","] 7 (#$ . 58323)])
#@13 
 
(fn ARGS)
(defalias 'magit-popup-export-file-args #[257 "\300\301\302\203.\203.@\203\300\262\202\"\303\304\"\203\"\211\262\210\211T\262A\262\202\266\211\262\211\203F\305\"\262\306\307\300O\310\"\262D\207" [nil t 0 string-prefix-p "-- " remove split-string 3 ","] 9 (#$ . 58484)])
(defconst magit-popup-font-lock-keywords '(("(\\(magit-define-popup\\)\\_>[     '(]*\\(\\(?:\\sw\\|\\s_\\)+\\)?" (1 'font-lock-keyword-face) (2 'font-lock-function-name-face nil t))))
(byte-code "\301\302\"\210\303\304!\207" [magit-popup-font-lock-keywords font-lock-add-keywords emacs-lisp-mode provide magit-popup] 3)