en-US/about_PSReadLine.help.txt

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
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
TOPIC
    about_PSReadLine

SHORT DESCRIPTION

    PSReadLine provides an improved command line editing experience in
    the PowerShell console.

LONG DESCRIPTION

    PSReadLine provides a powerful command line editing experience for the
    PowerShell console.  It provides:

      * Syntax coloring of the command line
      * A visual indication of syntax errors
      * A better multi-line experience (both editing and history)
      * Customizable key bindings
      * Cmd and Emacs modes
      * Many configuration options
      * Bash style completion (optional in Cmd mode, default in Emacs mode)
      * Emacs yank/kill ring
      * PowerShell token based "word" movement and kill

    The following functions are available in the class [Microsoft.PowerShell.PSConsoleReadLine]:

  Basic editing functions
  -----------------------

    Abort:

      Abort current action, e.g. incremental history search.

      Emacs: <Ctrl+g>

    AcceptAndGetNext:

      Attempt to execute the current input. If it can be executed (like AcceptLine), then 
      recall the next item from history the next time ReadLine is called.

      Emacs: <Ctrl+o>

    AcceptLine:

      Attempt to execute the current input. If the current input is incomplete (for 
      example there is a missing closing parenthesis, bracket, or quote, then the 
      continuation prompt is displayed on the next line and PSReadLine waits for keys to 
      edit the current input.

      Cmd: <Enter>
      Emacs: <Enter>
      Vi insert mode: <Enter>

    AddLine:

      The continuation prompt is displayed on the next line and PSReadLine waits for keys 
      to edit the current input. This is useful to enter multi-line input as a single 
      command even when a single line is complete input by itself.

      Cmd: <Shift+Enter>
      Emacs: <Shift+Enter>
      Vi insert mode: <Shift+Enter>
      Vi command mode: <Shift+Enter>

    BackwardDeleteChar:

      Delete the character before the cursor.

      Cmd: <Backspace>
      Emacs: <Backspace>
      Vi insert mode: <Backspace>
      Vi command mode: <X>, <d,h>

    BackwardDeleteLine:

      Like BackwardKillLine - deletes text from the point to the start of the line, but 
      does not put the deleted text in the kill ring.

      Cmd: <Ctrl+Home>
      Vi insert mode: <Ctrl+Home>
      Vi command mode: <Ctrl+u>, <Ctrl+Home>, <d,0>

    BackwardDeleteWord:

      Deletes the previous word.

      Vi command mode: <Ctrl+w>, <d,b>

    BackwardKillLine:

      Clear the input from the start of the input to the cursor. The cleared text is 
      placed in the kill ring.

      Emacs: <Ctrl+u>, <Ctrl+x,Backspace>

    BackwardKillWord:

      Clear the input from the start of the current word to the cursor. If the cursor is 
      between words, the input is cleared from the start of the previous word to the 
      cursor. The cleared text is placed in the kill ring.

      Cmd: <Ctrl+Backspace>
      Emacs: <Alt+Backspace>, <Escape,Backspace>
      Vi insert mode: <Ctrl+Backspace>
      Vi command mode: <Ctrl+Backspace>

    CancelLine:

      Cancel the current input, leaving the input on the screen, but returns back to the 
      host so the prompt is evaluated again.

      Vi insert mode: <Ctrl+c>
      Vi command mode: <Ctrl+c>

    Copy:

      Copy selected region to the system clipboard. If no region is selected, copy the whole line.

      Cmd: <Ctrl+C>

    CopyOrCancelLine:

      If text is selected, copy to the clipboard, otherwise cancel the line.

      Cmd: <Ctrl+c>
      Emacs: <Ctrl+c>

    Cut:

      Delete selected region placing deleted text in the system clipboard.

      Cmd: <Ctrl+x>

    DeleteChar:

      Delete the character under the cursor.

      Cmd: <Delete>
      Emacs: <Delete>
      Vi insert mode: <Delete>
      Vi command mode: <Delete>, <x>, <d,l>, <d,Space>

    DeleteCharOrExit:

      Delete the character under the cursor, or if the line is empty, exit the process.

      Emacs: <Ctrl+d>

    DeleteEndOfWord:

      Delete to the end of the word.

      Vi command mode: <d,e>

    DeleteLine:

      Deletes the current line, enabling undo.

      Vi command mode: <d,d>

    DeleteLineToFirstChar:

      Deletes text from the cursor to the first non-blank character of the line.

      Vi command mode: <d,^>

    DeleteToEnd:

      Delete to the end of the line.

      Vi command mode: <D>, <d,$>

    DeleteWord:

      Delete the next word.

      Vi command mode: <d,w>

    ForwardDeleteLine:

      Like ForwardKillLine - deletes text from the point to the end of the line, but does 
      not put the deleted text in the kill ring.

      Cmd: <Ctrl+End>
      Vi insert mode: <Ctrl+End>
      Vi command mode: <Ctrl+End>

    InsertLineAbove:

      A new empty line is created above the current line regardless of where the cursor is 
      on the current line. The cursor moves to the beginning of the new line.

      Cmd: <Ctrl+Enter>

    InsertLineBelow:

      A new empty line is created below the current line regardless of where the cursor is 
      on the current line. The cursor moves to the beginning of the new line.

      Cmd: <Shift+Ctrl+Enter>

    InvertCase:

      Invert the case of the current character and move to the next one.

      Vi command mode: <~>

    KillLine:

      Clear the input from the cursor to the end of the input. The cleared text is placed 
      in the kill ring.

      Emacs: <Ctrl+k>

    KillRegion:

      Kill the text between the cursor and the mark.

      Function is unbound.

    KillWord:

      Clear the input from the cursor to the end of the current word. If the cursor is 
      between words, the input is cleared from the cursor to the end of the next word. The 
      cleared text is placed in the kill ring.

      Cmd: <Ctrl+Delete>
      Emacs: <Alt+d>, <Escape,d>
      Vi insert mode: <Ctrl+Delete>
      Vi command mode: <Ctrl+Delete>

    Paste:

      Paste text from the system clipboard.

      Cmd: <Ctrl+v>, <Shift+Insert>
      Vi insert mode: <Ctrl+v>
      Vi command mode: <Ctrl+v>

    PasteAfter:

      Paste the clipboard after the cursor, moving the cursor to the end of the pasted text.

      Vi command mode: <p>

    PasteBefore:

      Paste the clipboard before the cursor, moving the cursor to the end of the pasted text.

      Vi command mode: <P>

    PrependAndAccept:

      Prepend a '#' and accept the line.

      Vi command mode: <#>

    Redo:

      Undo an undo.

      Cmd: <Ctrl+y>
      Vi insert mode: <Ctrl+y>
      Vi command mode: <Ctrl+y>

    RepeatLastCommand:

      Repeat the last text modification.

      Vi command mode: <.>

    RevertLine:

      Reverts all of the input to the current input.

      Cmd: <Escape>
      Emacs: <Alt+r>, <Escape,r>

    ShellBackwardKillWord:

      Clear the input from the start of the current word to the cursor. If the cursor is
      between words, the input is cleared from the start of the previous word to the
      cursor. The cleared text is placed in the kill ring.

      Function is unbound.

    ShellKillWord:

      Clear the input from the cursor to the end of the current word. If the cursor is
      between words, the input is cleared from the cursor to the end of the next word. The
      cleared text is placed in the kill ring.

      Function is unbound.

    SwapCharacters:

      Swap the current character and the one before it.

      Emacs: <Ctrl+t>
      Vi insert mode: <Ctrl+t>
      Vi command mode: <Ctrl+t>

    Undo:

      Undo a previous edit.

      Cmd: <Ctrl+z>
      Emacs: <Ctrl+_>, <Ctrl+x,Ctrl+u>
      Vi insert mode: <Ctrl+z>
      Vi command mode: <Ctrl+z>, <u>

    UndoAll:

      Undo all previous edits for line.

      Vi command mode: <U>

    UnixWordRubout:

      Clear the input from the start of the current word to the cursor. If the cursor is
      between words, the input is cleared from the start of the previous word to the
      cursor. The cleared text is placed in the kill ring.

      Emacs: <Ctrl+w>

    ValidateAndAcceptLine:

      Attempt to execute the current input. If the current input is incomplete (for
      example there is a missing closing parenthesis, bracket, or quote, then the
      continuation prompt is displayed on the next line and PSReadLine waits for keys to
      edit the current input.

      Emacs: <Ctrl+m>

    ViAcceptLine:

      Accept the line and switch to Insert mode.

      Vi command mode: <Enter>

    ViAcceptLineOrExit:

      Like DeleteCharOrExit in Emacs mode, but accepts the line instead of deleting a character.

      Vi insert mode: <Ctrl+d>
      Vi command mode: <Ctrl+d>

    ViAppendLine:

      A new line is inserted below the current line.

      Vi command mode: <o>

    ViBackwardDeleteGlob:

      Deletes the previous word, using only white space as the word delimiter.

      Vi command mode: <d,B>

    ViBackwardGlob:

      Moves the cursor back to the beginning of the previous word, using only white space
      as delimiters.

      Vi command mode: <B>

    ViDeleteBrace:

      Find the matching brace, paren, or square bracket and delete all contents within,
      including the brace.

      Vi command mode: <d,%>

    ViDeleteEndOfGlob:

      Delete to the end of the word.

      Vi command mode: <d,E>

    ViDeleteGlob:

      Delete the next glob (white space delimited word).

      Vi command mode: <d,W>

    ViDeleteToBeforeChar:

      Deletes until given character.

      Vi command mode: <d,t>

    ViDeleteToBeforeCharBackward:

      Deletes until given character.

      Vi command mode: <d,T>

    ViDeleteToChar:

      Deletes until given character.

      Vi command mode: <d,f>

    ViDeleteToCharBackward:

      Deletes backwards until given character.

      Vi command mode: <d,F>

    ViInsertAtBegining:

      Switch to Insert mode and position the cursor at the beginning of the line.

      Vi command mode: <I>

    ViInsertAtEnd:

      Switch to Insert mode and position the cursor at the end of the line.

      Vi command mode: <A>

    ViInsertLine:

      A new line is inserted above the current line.

      Vi command mode: <O>

    ViInsertWithAppend:

      Append from the current line position.

      Vi command mode: <a>

    ViInsertWithDelete:

      Delete the current character and switch to Insert mode.

      Vi command mode: <s>

    ViJoinLines:

      Joins the current line and the next line.

      Vi command mode: <J>

    ViReplaceLine:

      Erase the entire command line.

      Vi command mode: <S>, <c,c>

    ViReplaceToBeforeChar:

      Replaces until given character.

      Vi command mode: <c,t>

    ViReplaceToBeforeCharBackward:

      Replaces until given character.

      Vi command mode: <c,T>

    ViReplaceToChar:

      Deletes until given character.

      Vi command mode: <c,f>

    ViReplaceToCharBackward:

      Replaces until given character.

      Vi command mode: <c,F>

    ViYankBeginningOfLine:

      Yank from the beginning of the buffer to the cursor.

      Vi command mode: <y,0>

    ViYankEndOfGlob:

      Yank from the cursor to the end of the WORD(s).

      Vi command mode: <y,E>

    ViYankEndOfWord:

      Yank from the cursor to the end of the word(s).

      Vi command mode: <y,e>

    ViYankLeft:

      Yank character(s) to the left of the cursor.

      Vi command mode: <y,h>

    ViYankLine:

      Yank the entire buffer.

      Vi command mode: <y,y>

    ViYankNextGlob:

      Yank from cursor to the start of the next WORD(s).

      Vi command mode: <y,W>

    ViYankNextWord:

      Yank the word(s) after the cursor.

      Vi command mode: <y,w>

    ViYankPercent:

      Yank to/from matching brace.

      Vi command mode: <y,%>

    ViYankPreviousGlob:

      Yank from beginning of the WORD(s) to cursor.

      Vi command mode: <y,B>

    ViYankPreviousWord:

      Yank the word(s) before the cursor.

      Vi command mode: <y,b>

    ViYankRight:

      Yank character(s) under and to the right of the cursor.

      Vi command mode: <y,l>, <y,Space>

    ViYankToEndOfLine:

      Yank from the cursor to the end of the buffer.

      Vi command mode: <y,$>

    ViYankToFirstChar:

      Yank from the first non-whitespace character to the cursor.

      Vi command mode: <y,^>

    Yank:

      Add the most recently killed text to the input.

      Emacs: <Ctrl+y>

    YankLastArg:

      Yank the last argument from the previous history line. With an argument, the first
      time it is invoked, behaves just like YankNthArg. If invoked multiple times, instead
      it iterates through history and arg sets the direction (negative reverses the
      direction.)

      Cmd: <Alt+.>
      Emacs: <Alt+.>, <Alt+_>, <Escape,.>, <Escape,_>

    YankNthArg:

      Yank the first argument (after the command) from the previous history line. With an
      argument, yank the nth argument (starting from 0), if the argument is negative,
      start from the last argument.

      Emacs: <Ctrl+Alt+y>, <Escape,Ctrl+y>

    YankPop:

      If the previous operation was Yank or YankPop, replace the previously yanked text
      with the next killed text from the kill ring.

      Emacs: <Alt+y>, <Escape,y>

  Cursor movement functions
  -------------------------

    BackwardChar:

      Move the cursor one character to the left. This may move the cursor to the previous
      line of multi-line input.

      Cmd: <LeftArrow>
      Emacs: <LeftArrow>, <Ctrl+b>
      Vi insert mode: <LeftArrow>
      Vi command mode: <LeftArrow>, <Backspace>, <h>

    BackwardWord:

      Move the cursor back to the start of the current word, or if between words, the
      start of the previous word. Word boundaries are defined by a configurable set of
      characters.

      Cmd: <Ctrl+LeftArrow>
      Emacs: <Alt+b>, <Escape,b>
      Vi insert mode: <Ctrl+LeftArrow>
      Vi command mode: <Ctrl+LeftArrow>

    BeginningOfLine:

      If the input has multiple lines, move to the start of the current line, or if
      already at the start of the line, move to the start of the input. If the input has a
      single line, move to the start of the input.

      Cmd: <Home>
      Emacs: <Home>, <Ctrl+a>
      Vi insert mode: <Home>
      Vi command mode: <Home>

    EndOfLine:

      If the input has multiple lines, move to the end of the current line, or if already
      at the end of the line, move to the end of the input. If the input has a single
      line, move to the end of the input.

      Cmd: <End>
      Emacs: <End>, <Ctrl+e>
      Vi insert mode: <End>

    ForwardChar:

      Move the cursor one character to the right. This may move the cursor to the next
      line of multi-line input.

      Cmd: <RightArrow>
      Emacs: <RightArrow>, <Ctrl+f>
      Vi insert mode: <RightArrow>
      Vi command mode: <RightArrow>, <Space>, <l>

    ForwardWord:

      Move the cursor forward to the end of the current word, or if between words, to the
      end of the next word. Word boundaries are defined by a configurable set of
      characters.

      Emacs: <Alt+f>, <Escape,f>

    GotoBrace:

      Go to the matching brace, paren, or square bracket.

      Cmd: <Ctrl+]>
      Vi insert mode: <Ctrl+]>
      Vi command mode: <Ctrl+]>

    GotoColumn:

      Move to the column indicated by arg.

      Vi command mode: <|>

    GotoFirstNonBlankOfLine:

      Move the cursor to the first non-blank character in the line.

      Vi command mode: <^>

    MoveToEndOfLine:

      Move the cursor to the end of the input.

      Vi command mode: <End>, <$>

    NextLine:

      Move the cursor to the next line.

      Function is unbound.

    NextWord:

      Move the cursor forward to the start of the next word. Word boundaries are defined
      by a configurable set of characters.

      Cmd: <Ctrl+RightArrow>
      Vi insert mode: <Ctrl+RightArrow>
      Vi command mode: <Ctrl+RightArrow>

    NextWordEnd:

      Move the cursor forward to the end of the current word, or if between words, to the
      end of the next word. Word boundaries are defined by a configurable set of
      characters.

      Vi command mode: <e>

    PreviousLine:

      Move the cursor to the previous line.

      Function is unbound.

    ShellBackwardWord:

      Move the cursor back to the start of the current word, or if between words, the
      start of the previous word. Word boundaries are defined by PowerShell tokens.

      Function is unbound.

    ShellForwardWord:

      Move the cursor forward to the start of the next word. Word boundaries are defined
      by PowerShell tokens.

      Function is unbound.

    ShellNextWord:

      Move the cursor forward to the end of the current word, or if between words, to the
      end of the next word. Word boundaries are defined by PowerShell tokens.

      Function is unbound.

    ViBackwardWord:

      Move the cursor back to the start of the current word, or if between words, the
      start of the previous word. Word boundaries are defined by a configurable set of
      characters.

      Vi command mode: <b>

    ViEndOfGlob:

      Moves the cursor to the end of the word, using only white space as delimiters.

      Vi command mode: <E>

    ViEndOfPreviousGlob:

      Moves to the end of the previous word, using only white space as a word delimiter.

      Function is unbound.

    ViGotoBrace:

      Similar to GotoBrace, but is character based instead of token based.

      Vi command mode: <%>

    ViNextGlob:

      Moves to the next word, using only white space as a word delimiter.

      Vi command mode: <W>

    ViNextWord:

      Move the cursor forward to the start of the next word. Word boundaries are defined
      by a configurable set of characters.

      Vi command mode: <w>

  History functions
  -----------------

    BeginningOfHistory:

      Move to the first item in the history.

      Emacs: <Alt+<>

    ClearHistory:

      Clears history in PSReadLine. This does not affect PowerShell history.

      Cmd: <Alt+F7>

    EndOfHistory:

      Move to the last item (the current input) in the history.

      Emacs: <Alt+>>

    ForwardSearchHistory:

      Perform an incremental forward search through history.

      Cmd: <Ctrl+s>
      Emacs: <Ctrl+s>

    HistorySearchBackward:

      Replace the current input with the 'previous' item from PSReadLine history that
      matches the characters between the start and the input and the cursor.

      Cmd: <F8>

    HistorySearchForward:

      Replace the current input with the 'next' item from PSReadLine history that matches
      the characters between the start and the input and the cursor.

      Cmd: <Shift+F8>

    NextHistory:

      Replace the current input with the 'next' item from PSReadLine history.

      Cmd: <DownArrow>
      Emacs: <DownArrow>, <Ctrl+n>
      Vi insert mode: <DownArrow>
      Vi command mode: <DownArrow>, <j>, <+>

    PreviousHistory:

      Replace the current input with the 'previous' item from PSReadLine history.

      Cmd: <UpArrow>
      Emacs: <UpArrow>, <Ctrl+p>
      Vi insert mode: <UpArrow>
      Vi command mode: <UpArrow>, <k>, <->

    ReverseSearchHistory:

      Perform an incremental backward search through history.

      Cmd: <Ctrl+r>
      Emacs: <Ctrl+r>

    ViSearchHistoryBackward:

      Prompts for a search string and initiates search upon AcceptLine.

      Vi insert mode: <Ctrl+r>
      Vi command mode: </>, <Ctrl+r>

  Completion functions
  --------------------

    Complete:

      Attempt to perform completion on the text surrounding the cursor. If there are
      multiple possible completions, the longest unambiguous prefix is used for
      completion. If trying to complete the longest unambiguous completion, a list of
      possible completions is displayed.

      Emacs: <Tab>

    MenuComplete:

      Attempt to perform completion on the text surrounding the cursor. If there are
      multiple possible completions, the longest unambiguous prefix is used for
      completion. If trying to complete the longest unambiguous completion, a list of
      possible completions is displayed.

      Cmd: <Ctrl+Space>
      Emacs: <Ctrl+Space>

    PossibleCompletions:

      Display the list of possible completions.

      Emacs: <Alt+=>
      Vi insert mode: <Ctrl+Space>
      Vi command mode: <Ctrl+Space>

    TabCompleteNext:

      Attempt to complete the text surrounding the cursor with the next available completion.

      Cmd: <Tab>
      Vi command mode: <Tab>

    TabCompletePrevious:

      Attempt to complete the text surrounding the cursor with the previous available completion.

      Cmd: <Shift+Tab>
      Vi command mode: <Shift+Tab>

    ViTabCompleteNext:

      Ends the current edit group, if needed, and invokes TabCompleteNext.

      Vi insert mode: <Tab>

    ViTabCompletePrevious:

      Ends the current edit group, if needed, and invokes TabCompletePrevious.

      Vi insert mode: <Shift+Tab>

  Miscellaneous functions
  -----------------------

    CaptureScreen:

      Start interactive screen capture - up/down arrows select lines, enter copies
      selected text to clipboard as text and html.

      Function is unbound.

    ClearScreen:

      Clear the screen and draw the current line at the top of the screen.

      Cmd: <Ctrl+l>
      Emacs: <Ctrl+l>
      Vi insert mode: <Ctrl+l>
      Vi command mode: <Ctrl+l>

    DigitArgument:

      Start a new digit argument to pass to other functions.

      Cmd: <Alt+0>, <Alt+1>, <Alt+2>, <Alt+3>, <Alt+4>, <Alt+5>, <Alt+6>, <Alt+7>, <Alt+8>, <Alt+9>, <Alt+->
      Emacs: <Alt+0>, <Alt+1>, <Alt+2>, <Alt+3>, <Alt+4>, <Alt+5>, <Alt+6>, <Alt+7>, <Alt+8>, <Alt+9>, <Alt+->
      Vi command mode: <0>, <1>, <2>, <3>, <4>, <5>, <6>, <7>, <8>, <9>

    InvokePrompt:

      Erases the current prompt and calls the prompt function to redisplay the prompt.
      Useful for custom key handlers that change state, e.g. change the current directory.

      Function is unbound.

    ScrollDisplayDown:

      Scroll the display down one screen.

      Cmd: <PageDown>
      Emacs: <PageDown>

    ScrollDisplayDownLine:

      Scroll the display down one line.

      Cmd: <Ctrl+PageDown>
      Emacs: <Ctrl+PageDown>

    ScrollDisplayToCursor:

      Scroll the display to the cursor.

      Emacs: <Ctrl+End>

    ScrollDisplayTop:

      Scroll the display to the top.

      Emacs: <Ctrl+Home>

    ScrollDisplayUp:

      Scroll the display up one screen.

      Cmd: <PageUp>
      Emacs: <PageUp>

    ScrollDisplayUpLine:

      Scroll the display up one line.

      Cmd: <Ctrl+PageUp>
      Emacs: <Ctrl+PageUp>

    SelfInsert:

      Insert the key.

      Function is unbound.

    ShowKeyBindings:

      Show all bound keys.

      Cmd: <Ctrl+Alt+?>
      Emacs: <Ctrl+Alt+?>
      Vi insert mode: <Ctrl+Alt+?>

    ViCommandMode:

      Switch the current operating mode from Vi-Insert to Vi-Command.

      Vi insert mode: <Escape>

    ViDigitArgumentInChord:

      Start a new digit argument to pass to other functions while in one of vi's chords.

      Function is unbound.

    ViEditVisually:

      Edit the command line in a text editor specified by $env:EDITOR or $env:VISUAL.

      Emacs: <Ctrl+x,Ctrl+e>
      Vi command mode: <v>

    ViExit:

      Exits the shell.

      Function is unbound.

    ViInsertMode:

      Switch to Insert mode.

      Vi command mode: <i>

    WhatIsKey:

      Read a key and tell me what the key is bound to.

      Cmd: <Alt+?>
      Emacs: <Alt+?>

  Selection functions
  -------------------

    ExchangePointAndMark:

      The cursor is placed at the location of the mark and the mark is moved to the
      location of the cursor.

      Emacs: <Ctrl+x,Ctrl+x>

    SelectAll:

      Select the entire line.

      Cmd: <Ctrl+a>

    SelectBackwardChar:

      Adjust the current selection to include the previous character.

      Cmd: <Shift+LeftArrow>
      Emacs: <Shift+LeftArrow>

    SelectBackwardsLine:

      Adjust the current selection to include from the cursor to the start of the line.

      Cmd: <Shift+Home>
      Emacs: <Shift+Home>

    SelectBackwardWord:

      Adjust the current selection to include the previous word.

      Cmd: <Shift+Ctrl+LeftArrow>
      Emacs: <Alt+B>

    SelectForwardChar:

      Adjust the current selection to include the next character.

      Cmd: <Shift+RightArrow>
      Emacs: <Shift+RightArrow>

    SelectForwardWord:

      Adjust the current selection to include the next word using ForwardWord.

      Emacs: <Alt+F>

    SelectLine:

      Adjust the current selection to include from the cursor to the end of the line.

      Cmd: <Shift+End>
      Emacs: <Shift+End>

    SelectNextWord:

      Adjust the current selection to include the next word.

      Cmd: <Shift+Ctrl+RightArrow>

    SelectShellBackwardWord:

      Adjust the current selection to include the previous word using ShellBackwardWord.

      Function is unbound.

    SelectShellForwardWord:

      Adjust the current selection to include the next word using ShellForwardWord.

      Function is unbound.

    SelectShellNextWord:

      Adjust the current selection to include the next word using ShellNextWord.

      Function is unbound.

    SetMark:

      Mark the current location of the cursor for use in a subsequent editing command.

      Emacs: <Ctrl+`>

  Search functions
  ----------------

    CharacterSearch:

      Read a character and search forward for the next occurence of that character. If an
      argument is specified, search forward (or backward if negative) for the nth
      occurence.

      Cmd: <F3>
      Emacs: <Ctrl+]>
      Vi insert mode: <F3>
      Vi command mode: <F3>

    CharacterSearchBackward:

      Read a character and search backward for the next occurence of that character. If an
      argument is specified, search backward (or forward if negative) for the nth
      occurence.

      Cmd: <Shift+F3>
      Emacs: <Ctrl+Alt+]>
      Vi insert mode: <Shift+F3>
      Vi command mode: <Shift+F3>

    RepeatLastCharSearch:

      Repeat the last recorded character search.

      Vi command mode: <;>

    RepeatLastCharSearchBackwards:

      Repeat the last recorded character search, but in the opposite direction.

      Vi command mode: <,>

    RepeatSearch:

      Repeat the last search in the same direction as before.

      Vi command mode: <n>

    RepeatSearchBackward:

      Repeat the last search in the same direction as before.

      Vi command mode: <N>

    SearchChar:

      Read the next character and then find it, going forward, and then back off a
      character. This is for 't' functionality.

      Vi command mode: <f>

    SearchCharBackward:

      Read the next character and then find it, going backward, and then back off a
      character. This is for 'T' functionality.

      Vi command mode: <F>

    SearchCharBackwardWithBackoff:

      Read the next character and then find it, going backward, and then back off a
      character. This is for 'T' functionality.

      Vi command mode: <T>

    SearchCharWithBackoff:

      Read the next character and then find it, going forward, and then back off a
      character. This is for 't' functionality.

      Vi command mode: <t>

    SearchForward:

      Prompts for a search string and initiates search upon AcceptLine.

      Vi insert mode: <Ctrl+s>
      Vi command mode: <?>, <Ctrl+s>



  Custom Key Bindings
  -------------------

  PSReadLine supports custom key bindings using the cmdlet Set-PSReadLineKeyHandler. Most
  custom key bindings will call one of the above functions, for example:

      Set-PSReadLineKeyHandler -Key UpArrow -Function HistorySearchBackward

  You can bind a ScriptBlock to a key. The ScriptBlock can do pretty much anything you want.
  Some useful examples include:

      * edit the command line
      * opening a new window (e.g. help)
      * change directories without changing the command line

  The ScriptBlock is passed two arguments:

      * $key - A [ConsoleKeyInfo] that is the key that triggered the custom binding. If you bind
               the same ScriptBlock to multiple keys and need to perform different actions depending
               on the key, you can check $key. Many custom bindings ignore this argument.
      * $arg - An arbitrary argument. Most often, this would be an integer argument that the user
               passes from the key bindings DigitArgument. If your binding doesn't accept arguments,
               it's reasonable to ignore this argument.

  Let's take a look at an example that adds a command line to history without executing it. This is
  useful when you realize you forgot to do something, but don't want to re-enter the command line
  you've already entered.

        Set-PSReadLineKeyHandler -Key Alt+w `
                                 -BriefDescription SaveInHistory `
                                 -LongDescription "Save current line in history but do not execute" `
                                 -ScriptBlock {
            param($key, $arg) # The arguments are ignored in this example

            # We need the command line, GetBufferState gives us that (with the cursor position)
            $line = $null
            $cursor = $null
            [Microsoft.PowerShell.PSConsoleReadLine]::GetBufferState([ref]$line, [ref]$cursor)

            # AddToHistory saves the line in history, but does not execute the line.
            [Microsoft.PowerShell.PSConsoleReadLine]::AddToHistory($line)

            # RevertLine is like pressing Escape.
            [Microsoft.PowerShell.PSConsoleReadLine]::RevertLine()
        }

  You can see many more examples in the file SamplePSReadLineProfile.ps1 which is installed in the
  PSReadLine module folder.

  Most key bindings will want to take advantage of some helper functions for editing the command
  line those APIs are documented in the next section.

  Custom Key Binding Support APIs
  -------------------------------

  The following functions are public in Microsoft.PowerShell.PSConsoleReadLine, but cannot be directly
  bound to a key. Most are useful in custom key bindings.

    void AddToHistory(string command)

        Add a command line to history without executing it.

    void ClearKillRing()

        Clear the kill ring. This is mostly used for testing.

    void Delete(int start, int length)

        Delete length characters from start. This operation supports undo/redo.

    void Ding()

        Perform the Ding action based on the users preference.

    void GetBufferState([ref] string input, [ref] int cursor)
    void GetBufferState([ref] Ast ast, [ref] Token[] tokens, [ref] ParseError[] parseErrors, [ref] int cursor)

        These two functions retrieve useful information about the current state of
        the input buffer. The first is more commonly used for simple cases. The
        second is used if your binding is doing something more advanced with the Ast.

    IEnumerable[Microsoft.PowerShell.KeyHandler] GetKeyHandlers(bool includeBound, bool includeUnbound)

        This function is used by Get-PSReadLineKeyHandler and probably isn't useful in a custom
        key binding.

    Microsoft.PowerShell.PSConsoleReadLineOptions GetOptions()

        This function is used by Get-PSReadLineOption and probably isn't too useful in a custom
        key binding.

    void GetSelectionState([ref] int start, [ref] int length)

        If there is no selection on the command line, -1 will be returned in both start and length.
        If there is a selection on the command line, the start and length of the selection are returned.

    void Insert(char c)
    void Insert(string s)

        Insert a character or string at the cursor. This operation supports undo/redo.

    string ReadLine(runspace remoteRunspace, System.Management.Automation.EngineIntrinsics engineIntrinsics)

        This is the main entry point to PSReadLine. It does not support recursion, so is not useful
        in a custom key binding.

    void RemoveKeyHandler(string[] key)

        This function is used by Remove-PSReadLineKeyHandler and probably isn't too useful in a
        custom key binding.

    void Replace(int start, int length, string replacement)

        Replace some of the input. This operation supports undo/redo.
        This is preferred over Delete followed by Insert because it is treated as a single action
        for undo.

    void SetCursorPosition(int cursor)

        Move the cursor to the given offset. Cursor movement is not tracked for undo.

    void SetOptions(Microsoft.PowerShell.SetPSReadLineOption options)

        This function is a helper method used by the cmdlet Set-PSReadLineOption, but might be
        useful to a custom key binding that wants to temporarily change a setting.

    bool TryGetArgAsInt(System.Object arg, [ref] int numericArg, int defaultNumericArg)

        This helper method is used for custom bindings that honor DigitArgument. A typical call
        looks like:

            [int]$numericArg = 0
            [Microsoft.PowerShell.PSConsoleReadLine]::TryGetArgAsInt($arg, [ref]$numericArg, 1)

POWERSHELL COMPATIBILITY

    PSReadLine requires PowerShell version 3 or greater and the console host. It
    will not work in the ISE.

FEEDBACK

    https://github.com/lzybkr/PSReadLine

CONTRIBUTING TO PSREADLINE

    Feel free to submit a pull request or submit feedback on the github page.

SEE ALSO

    PSReadLine is heavily influenced by the GNU readline library:

        http://tiswww.case.edu/php/chet/readline/rltop.html