user.letter

command word user.letter

air a

bat b

cap c

drum d

each e

fine f

gust g

harp h

sit i

jury j

crunch k

look l

made m

near n

odd o

pit p

quench q

red r

sun s

trap t

urge u

vest v

whale w

plex x

yank y

zip z

user.number_key

command word user.number_key

zero 0

one 1

two 2

three 3

four 4

five 5

six 6

seven 7

eight 8

nine 9

user.modifier_key

command word user.modifier_key

alt alt

alter alt

control ctrl

troll ctrl

shift shift

sky shift

super super

command cmd

option alt

user.special_key

command word user.special_key

end end

enter enter

escape escape

home home

insert insert

pagedown pagedown

pageup pageup

space space

tab tab

wipe backspace

junk backspace

delete backspace

forward delete delete

page up pageup

page down pagedown

user.symbol_key

command word user.symbol_key

dot .

point .

quote '

question ?

apostrophe '

L square [

left square [

square [

R square ]

right square ]

slash /

backslash **

minus -

dash -

equals =

plus +

grave `

tilde ~

bang !

down score _

underscore _

paren (

brace {

left brace {

brack {

bracket {

left bracket {

r brace }

right brace }

r brack }

r bracket }

right bracket }

angle <

left angle <

less than <

rangle >

R angle >

right angle >

greater than >

star ***

hash #

percent %

caret ^

amper &

pipe |

dub quote "

double quote "

dollar $

pound £

*** *

, ,

back tick `

comma ,

coma ,

period .

full stop .

semicolon ;

colon :

forward slash /

question mark ?

exclamation mark !

exclamation point !

asterisk ***

hash sign #

number sign #

percent sign %

at sign @

and sign &

ampersand &

dollar sign $

pound sign £

hyphen -

L paren (

left paren (

R paren )

right paren )

user.arrow_key

command word user.arrow_key

down down

left left

right right

up up

user.punctuation

command word user.punctuation

*** *

, ,

back tick `

comma ,

coma ,

period .

full stop .

semicolon ;

colon :

forward slash /

question mark ?

exclamation mark !

exclamation point !

asterisk ***

hash sign #

number sign #

percent sign %

at sign @

and sign &

ampersand &

dollar sign $

pound sign £

hyphen -

L paren (

left paren (

R paren )

right paren )

user.function_key

command word user.function_key

F one f1

F two f2

F three f3

F four f4

F five f5

F six f6

F seven f7

F eight f8

F nine f9

F ten f10

F eleven f11

F twelve f12

F thirteen f13

F fourteen f14

F fifteen f15

F sixteen f16

F seventeen f17

F eighteen f18

F nineteen f19

F twenty f20

formatters

command word user.formatters
all cap EXAMPLE OF FORMATTING WITH ALL CAP

all down example of formatting with all down

camel exampleOfFormattingWithCamel

dotted example.of.formatting.with.dotted

dub string "example of formatting with dub string"

dunder __example__offormattingwithdunder

hammer ExampleOfFormattingWithHammer

kebab example-of-formatting-with-kebab

mock ExAmPlE oF FoRmAtTiNg wItH MoCk

packed example::of::formatting::with::packed

padded example of formatting with padded

slasher /example/of/formatting/with/slasher

smash exampleofformattingwithsmash

snake example_of_formatting_with_snake

spongebob ExAmPlE oF FoRmAtTiNg wItH SpOnGeBoB

string 'example of formatting with string'

title Example of Formatting With Title

1password

password new user.password_new()
password dup user.password_duplicate()
password edit user.password_edit()
password delete user.password_delete()

1password global

password fill user.password_fill()
password show user.password_show()

win slack win

workspace key("ctrl-{number}")
(slack | lack) [channel] info key(ctrl-shift-i)
focus (move | next) key(ctrl-)`
(section | zone) [next] key(f6)
(section | zone) (previous | last) key(shift-f6)
(slack | lack) [direct] messages key(ctrl-shift-k)
(slack | lack) threads key(ctrl-shift-t)
(slack | lack) (history [next] | back | backward) key(alt-left)
(slack | lack) forward key(alt-right)
(element | bit) [next] key(tab)
(element | bit) (previous | last) key(shift-tab)
(slack | lack) (my stuff | activity) key(ctrl-shift-m)
(slack | lack) directory key(ctrl-shift-e)
(slack | lack) (starred [items] | stars) key(ctrl-shift-s)
(slack | lack) unread [messages] key(ctrl-shift-a)
grab left key(shift-up)
grab right key(shift-down)
add line key(shift-enter)
(slack | lack) (react | reaction) key(ctrl-shift-\)
(insert command | commandify) key(ctrl-shift-c)
insert code insert("```")
(slack | lack) (bull | bullet | bulleted) [list] key(ctrl-shift-8)
(slack | lack) (number | numbered) [list] key(ctrl-shift-7)
(slack | lack) (quotes | quotation) key(ctrl-shift-9)
bold key(ctrl-b)
(italic | italicize) key(ctrl-i)
(strike | strikethrough) key(ctrl-shift-x)
(slack | lack) snippet key(ctrl-shift-enter)
([toggle] mute | unmute) key(m)
(slack | lack) ([toggle] video) key(v)
(slack | lack) invite key(a)
(slack | lack) shortcuts key(ctrl-/)
emote <user.text> "{text}"
toggle left sidebar key(ctrl-shift-d)
toggle right sidebar key(ctrl-.)
(move | next) focus app.notify("please use the voice command 'focus next' instead of 'next focus'") key(ctrl-)`
[next] (section | zone) app.notify("please use the voice command 'section next' instead of 'next section'") key(f6)
(previous | last) (section | zone) app.notify("please use the voice command 'section last' instead of 'last section'") key(shift-f6)
[next] (element | bit) app.notify("please use the voice command 'element next' instead of 'next element'") key(tab)
(previous | last) (element | bit) app.notify("please use the voice command 'element last' instead of 'last element'") key(shift-tab)

terraform

terraform "terraform "
terraform apply "terraform apply "
terraform destroy "terraform destroy "
terraform format recursive "terraform fmt -recursive\n"
terraform format "terraform fmt\n"
terraform help "terraform -help"
terraform init upgrade "terraform init -upgrade\n"
terraform init "terraform init\n"
terraform plan "terraform plan\n"
terraform state move "terraform state mv "
terraform validate "terraform validate\n"

thunderbird

go (mails | messages | inbox) user.tab_jump(1)
go (calendar | lightning) user.thunderbird_mod("shift-c")
go tasks user.thunderbird_mod("shift-d")
(open address [book] | address book | open contacts) user.thunderbird_mod("shift-b")
dev tools user.thunderbird_mod("shift-i")

thunderbird calendar

event new user.thunderbird_mod("i")
task new user.thunderbird_mod("d")
(task | event) delete key(delete)
toggle today key(f11)
view <number_small> user.thunderbird_calendar_view(number_small)
view day user.thunderbird_calendar_view(1)
view week user.thunderbird_calendar_view(2)
view multi [week] user.thunderbird_calendar_view(3)
view month user.thunderbird_calendar_view(4)

thunderbird composer

(draft | mail | message) save user.thunderbird_mod("s")
(draft | mail | message) print user.thunderbird_mod("p")
(draft | mail | message) send user.thunderbird_mod("enter")
toggle contacts key(f9)
go (inbox | thunderbird | main) user.thunderbird_mod("1")
cite paste user.thunderbird_mod("shift-o")
(unformatted | raw) paste user.thunderbird_mod("shift-v")
link new user.thunderbird_mod("k")
link delete user.thunderbird_mod("shift-k")

thunderbird contacts

contact new user.thunderbird_mod("n")
contact edit user.thunderbird_mod("i")
contact delete key(delete)
contact print user.thunderbird_mod("p")
contact message user.thunderbird_mod("m")
contact up key(up)
contact down key(down)

thunderbird inbox

(mail | message) open key(enter)
(mail | message) (up | last) key(b)
(mail | message) (down | next) key(f)
unread [mail | message] (up | last) key(p)
unread [mail | message] (down | next) key(n)
go home key(alt-home)
toggle (mail | message) [pane] key(f8)
(mail | message) (favorite | unfavorite) key(s)
(mail | message) (read | unread) key(m)
(mail | message) (watch | unwatch) key(w)
(mail | message) (ignore | unignore) key(k)
(mail | message) suspend key(c)
(mail | message) spam key(j)
(mail | message) new user.thunderbird_mod("n")
(mail | message) edit user.thunderbird_mod("e")
(mail | message) reply sender user.thunderbird_mod("r")
(mail | message) reply all user.thunderbird_mod("shift-r")
(mail | message) reply list user.thunderbird_mod("shift-l")
(mail | message) forward user.thunderbird_mod("l")
(mail | message) delete key(delete)
(mail | message) archive key(a)
(mail | message) save user.thunderbird_mod("s")
(mail | message) print user.thunderbird_mod("p")

thunderbird tasks

event new user.thunderbird_mod("i")
task new user.thunderbird_mod("d")
(task | event) delete key(delete)
toggle today key(f11)

visual studio

panel solution key(ctrl-alt-l)
panel properties key(f4)
panel output key(ctrl-alt-o)
panel class key(ctrl-shift-c)
panel errors key(ctrl-\ ctrl-e)
panel design key(shift-f7)
panel marks key(ctrl-k ctrl-w)
panel breakpoints key(ctrl-alt-b)
show settings key(alt-t o)
fullscreen switch key(shift-alt-enter)
wrap switch key(ctrl-e ctrl-w)
file hunt [<user.text>] key(ctrl-shift-t) insert(text or "")
file create key(ctrl-n)
file rename key(ctrl-[ s f2)
file reveal key(ctrl-[ s)
hint show key(ctrl-shift-space)
definition show key(f12)
definition peek key(alt-f12)
references find key(shift-f12)
format that key(ctrl-k ctrl-d)
format selection key(ctrl-k ctrl-f)
imports fix key(ctrl-r ctrl-g)
refactor field key(ctrl-r ctrl-e)
refactor interface key(ctrl-r ctrl-i)
refactor method key(ctrl-r ctrl-m)
refactor reorder parameters key(ctrl-r ctrl-o)
refactor remove parameters key(ctrl-r ctrl-v)
refactor that key(ctrl-r ctrl-r)
(go declaration | follow) key(ctrl-f12)
go back key(ctrl--)
go forward key(ctrl-shift--)
go implementation key(f12)
go recent [<user.text>] key(ctrl-1 ctrl-r) sleep(100ms) insert(text or "")
go type [<user.text>] key(ctrl-1 ctrl-t) sleep(100ms) insert(text or "")
go member [<user.text>] key(alt-\) sleep(100ms) insert(text or "")
go usage key(shift-f12)
go marks key(ctrl-k ctrl-w)
toggle mark key(ctrl-k ctrl-k)
go next mark key(ctrl-k ctrl-n)
go last mark key(ctrl-k ctrl-p)
fold toggle key(ctrl-m ctrl-m)
fold toggle all key(ctrl-m ctrl-l)
fold definitions key(ctrl-m ctrl-o)
break point key(f9)
step over key(f10)
debug step into key(f11)
debug step out [of] key(f10)
debug start key(f5)
debug stopper key(shift-f5)
debug continue key(f5)

batch

soft exit "exit /B 1\n"
hard exit "exit 1\n"
echo "echo "
echo off "@echo off\n"
call "call "
call shell "call cmd \\c "
if error "if errorlevel 1 "
go to "goto "
delayed expansion "SETLOCAL EnableDelayedExpansion\n"
arg <number_small> "%{number_small}"

php

(op | is) loosely equal " == "
(op | is) loosely not equal " != "
state try "try {\n"
state catch "catch (\\Throwable $exception) {\n"
var [over] insert("$") insert(user.formatted_text(phrase, "PRIVATE_CAMEL_CASE"))

proto

state message "message "
state package "package "
state reserved "reserved "
state enum "enum "
op equals " = "
state import "import "
state import public "import public "
state option "option "
state repeated "repeated "
type {user.code_type} "{code_type}"
repeated type {user.code_type} "repeated {code_type}"

sql

select "SELECT "
distinct "DISTINCT "
from "FROM "
select star from "SELECT *\nFROM "
where "WHERE "
order by "ORDER BY "
group by "GROUP BY "
having "HAVING "
descending " DESC"
ascending " ASC"
dot i d ".id"
inner join user.insert_between("INNER JOIN ", " ON ")
inner join using user.insert_between("INNER JOIN ", " USING ")
left outer join user.insert_between("LEFT OUTER JOIN ", " ON ")
right outer join user.insert_between("RIGHT OUTER JOIN ", " ON ")
with key(enter up) "WITH AS (" key(enter tab) "SELECT " key(enter shift-tab) edit.extend_line_end() edit.delete() ") " key(delete up:2 right:3)
column key(return) ", "
count user.code_insert_function("Count", "")
date user.insert_between("DATE '", "'")

comment documentation

dock comment user.code_comment_documentation()

data bool

state true user.code_insert_true()
state false user.code_insert_false()

functions common gui active

toggle funk user.code_toggle_functions()

keywords

keyword (<user.code_keyword>+) user.code_keyword(code_keyword_list)

libraries

state import user.code_import()

library gui open

toggle libraries close user.code_toggle_libraries()

operators array

op subscript user.code_operator_subscript()

operators lambda

op lambda user.code_operator_lambda()

operators math

op (minus | subtract) user.code_operator_subtraction()
op (plus | add) user.code_operator_addition()
op (times | multiply) user.code_operator_multiplication()
op divide user.code_operator_division()
op mod user.code_operator_modulo()
(op (power | exponent) | to the power [of]) user.code_operator_exponent()
(op | is) equal user.code_operator_equal()
(op | is) not equal user.code_operator_not_equal()
(op | is) (greater | more) user.code_operator_greater_than()
(op | is) (less | below) [than] user.code_operator_less_than()
(op | is) greater [than] or equal user.code_operator_greater_than_or_equal_to()
(op | is) less [than] or equal user.code_operator_less_than_or_equal_to()
(op | logical) and user.code_operator_and()
(op | logical) or user.code_operator_or()
(op | is) in user.code_operator_in()
(op | is) not in user.code_operator_not_in()
(op | pad) colon " : "

operators pointer

op dereference user.code_operator_indirection()
op address of user.code_operator_address_of()
op arrow user.code_operator_structure_dereference()

chrome

profile switch user.chrome_mod("shift-m")
tab search user.chrome_mod("shift-a")
tab search <user.text> user.chrome_mod("shift-a") sleep(200ms) insert("{text}") key(down)

wsl

go <user.letter> user.file_manager_open_volume("/mnt/{letter}")
(wsl | weasel) reset path detection user.wsl_reset_path_detection()
(wsl | weasel) speak user.wsl_speak()

twitter

(show shortcuts | shortcuts help) key(?)
next tweet key(j)
previous tweet key(k)
page down key(space)
load new tweet key(.)
go home insert("gh")
go explore insert("ge")
go notifications insert("gn")
go mentions insert("gr")
go profile insert("gp")
go likes insert("gl")
go lists insert("gi")
go direct messages insert("gm")
go settings insert("gs")
go book marks insert("gb")
go to user insert("gu")
display settings insert("gd")
new tweet key(n)
send tweet key(ctrl-enter)
new direct message key(m)
search key(/)
like message key(l)
reply message key(r)
re tweet [message] key(t)
share tweet key(s)
bookmark key(b)
mute account key(urge)
block account key(x)
open details key(enter)
expand photo key(o)

talon repl

test last phrase = user.history_get(1) command = "sim('{phrase}')" insert(command) key(enter)
test insert("sim('{phrase}')") key(enter)
test numb <number_small> phrase = user.history_get(number_small) command = "sim('{phrase}')" #to do: shouldn't this work? #user.paste("sim({phrase})") insert(command) key(enter) # requires user.talon_populate_lists tag. do not use with dragon
debug action {user.talon_actions} insert("actions.find('{user.talon_actions}')") key(enter) # requires user.talon_populate_lists tag. do not use with dragon
debug list {user.talon_lists} insert("actions.user.talon_pretty_print(registry.lists['{talon_lists}'])") key(enter)
debug tags insert("actions.user.talon_pretty_print(registry.tags)") key(enter)
debug settings insert("actions.user.talon_pretty_print(registry.settings)") key(enter)
debug modes insert("actions.user.talon_pretty_print(scope.get('mode'))") key(enter) # requires user.talon_populate_lists tag. do not use with dragon
debug scope {user.talon_scopes} insert("actions.user.talon_pretty_print(scope.get('{talon_scopes}'))") key(enter)
debug running apps insert("actions.user.talon_pretty_print(ui.apps(background=False))") key(enter)
debug all windows insert("actions.user.talon_pretty_print(ui.windows())") key(enter)
debug {user.running} windows insert("actions.user.talon_debug_app_windows('{running}')") key(enter)

gitlab

show shortcuts key(?)
go to projects [page] key(shift-p)
go to groups [page] key(shift-g)
go to activity [page] key(shift-a)
go to milestones [page] key(shift-l)
go to snippets [page] key(shift-s)
search page key(s)
go to issues [page] key(shift-i)
go to merge requests [page] key(shift-m)
go to to do [list] [page] key(shift-t)
(show | hide) performance bar key(p)
edit last comment key(1)
toggle mark down [preview] key(ctrl-shift-p)
go [to] project home [page] insert("gp")
go [to] project activity [feed] insert("gv")
go [to] project releases [list] insert("gr")
go [to] project files [list] insert("gf")
go [to] project file search [page] key(t)
go [to] project (commit | commits) [list] insert("gc")
go [to] (repository | repo) graph [page] insert("gn")
go [to] (repository | repo) charts insert("gd")
go [to] project issues [list] insert("gi")
go [to] new issues [list] insert("i")
go [to] project issues boards [list] insert("gb")
go [to] project merge requests [list] insert("gm")
go [to] jobs [list] insert("gj")
go [to] project metrics insert("gl")
go [to] project environments insert("ge")
go [to] project cubes insert("gk")
go [to] project snippets [list] insert("gs")
go [to] project wiki insert("gw")
edit description key(e)
change assignee key(a)
change milestone key(m)
change label key(l)
right comment key(r)
next [unresolved] discussion key(n)
previous [unresolved] discussion key(p)
next file key(])
previous file key([)
back to files key(escape)
open permalink key(y)
edit page key(e)

win windows terminal

settings open key(ctrl-,)
focus left key(ctrl-alt-shift-left)
focus right key(ctrl-alt-shift-right)
focus up key(ctrl-alt-shift-up)
focus down key(ctrl-alt-shift-down)
term menu key(ctrl-shift-f1)
find it edit.find()
find it # handle consecutive finds by first escaping out of any previous one key(escape) # make it so edit.find("{phrase}\n")

win windows explorer

go <user.letter> user.file_manager_open_volume("{letter}:")
go app data user.file_manager_open_directory("%AppData%")
go program files user.file_manager_open_directory("%programfiles%")

mac rstudio mac

run that key("cmd-enter")
run document key("cmd-alt-r")
run from top key("cmd-alt-b")
run to end key("cmd-alt-e")
run (function | funk) key("cmd-alt-f")
run section key("cmd-alt-t")
run previous chunks key("cmd-alt-p")
run chunk key("cmd-alt-c")
run next chunk key("cmd-alt-n")
run all key("cmd-shift-s")
run knitter key("cmd-shift-k")
run profiler key("cmd-shift-alt-p")
jump back key("cmd-f9")
jump forward key("cmd-f10")
close all tabs key("cmd-shift-w")
indent lines key("cmd-i")
toggle comment key("cmd-shift-c")
reformat comment key("cmd-shift-/")
reformat R code key("cmd-shift-a")
line up key("alt-up")
line down key("alt-down")
duplicate line up key("cmd-alt-up")
duplicate line [down] key("cmd-alt-down")
select to paren key("ctrl-shift-e")
select to matching paren key("ctrl-shift-alt-e")
jump to matching key("ctrl-p")
expand selection key("shift-alt-cmd-up")
reduce selection key("shift-alt-cmd-down")
add cursor up key("ctrl-alt-up")
add cursor down key("ctrl-alt-down")
move active cursor up key("ctrl-alt-shift-up")
move active cursor down key("ctrl-alt-shift-down")
delete line key("cmd-d")
delete word left key("alt-backspace")
delete word right key("alt-delete")
assign that key("alt--")
pipe that key("cmd-shift-m")
insert knitter chunk key("cmd-alt-i")
fold that key("cmd-alt-l")
unfold that key("cmd-shift-alt-l")
fold all key("cmd-alt-o")
unfold all key("cmd-shift-alt-o")
find and replace key("cmd-f")
find next key("cmd-g")
find previous key("cmd-shift-g")
find with selection key("cmd-e")
find in files key("cmd-shift-f")
run replace key("cmd-shift-j")
run spell check key("f7")
go to source key("ctrl-1")
go to console key("ctrl-2")
go to help key("ctrl-3")
go to history key("ctrl-4")
go to files key("ctrl-5")
go to (plots | plot) key("ctrl-6")
go to packages key("ctrl-7")
go to environment key("ctrl-8")
go to git key("ctrl-9")
go to build key("ctrl-0")
go to terminal key("alt-shift-t")
go to omni key("ctrl-.")
go to line key("cmd-shift-alt-g")
go to section key("cmd-shift-alt-j")
go to tab key("ctrl-shift-.")
go to previous tab key("ctrl-f11")
go to next tab key("ctrl-f12")
go to first tab key("ctrl-shift-f11")
go to last tab key("ctrl-shift-f12")
zoom source key("ctrl-shift-1")
(zoom | show) all key("ctrl-shift-0")
help that key("f1")
define that key("f2")
previous plot key("cmd-alt-f11")
next plot key("cmd-alt-f12")
restart R session key("cmd-shift-f10")
dev tools build key("cmd-shift-b")
dev tools load all key("cmd-shift-l")
dev tools test key("cmd-shift-t")
dev tools check key("cmd-shift-e")
dev tools document key("cmd-shift-d")
toggle breakpoint key("shift-f9")
debug next key("f10")
debug step into (function | funk) key("shift-f4")
debug finish (function | funk) key("shift-f6")
debug continue key("shift-f5")
debug stop key("shift-f8")
run git diff key("ctrl-alt-d")
run git commit key("ctrl-alt-m")

dunst

show notifications key(ctrl-)`
dismiss [notifications] user.system_command("dunstctl close")
dismiss all [notifications] user.system_command("dunstctl close-all")

mac emacs

cancel user.emacs("keyboard-quit")
exchange user.emacs("exchange-point-and-mark")
execute user.emacs("execute-extended-command")
execute {user.emacs_command} user.emacs(emacs_command)
execute <user.text> user.emacs("execute-extended-command") user.insert_formatted(text, "DASH_SEPARATED")
evaluate | (evaluate | eval) (exper | expression) user.emacs("eval-expression")
prefix user.emacs_prefix()
prefix <user.number_signed_small> user.emacs_prefix(number_signed_small)
abort recursive [edit] user.emacs("abort-recursive-edit")
browse kill ring user.emacs("browse-kill-ring")
fill paragraph user.emacs("fill-paragraph")
insert char user.emacs("insert-char")
occurs user.emacs("occur")
other scroll [down] user.emacs("scroll-other-window")
other scroll up user.emacs("scroll-other-window-down")
package autoremove user.emacs("package-autoremove")
package list | [package] list packages user.emacs("list-packages")
reverse (lines | region) user.emacs("reverse-region")
save buffers kill emacs user.emacs("save-buffers-kill-emacs")
save some buffers user.emacs("save-some-buffers")
sort lines user.emacs("sort-lines")
sort words user.emacs("sort-words")
go directory user.emacs("dired-jump")
other go directory user.emacs("dired-jump-other-window")
[toggle] debug on error user.emacs("toggle-debug-on-error")
[toggle] input method user.emacs("toggle-input-method")
[toggle] truncate lines user.emacs("toggle-truncate-lines")
[toggle] word wrap user.emacs("toggle-word-wrap")
manual user.emacs("man")
manual <user.text> `user.emacs("man") user.insert_formatted(text, "DASH_SEPARATED")
```
 # BUFFER SWITCHING #`
```
switch user.emacs("switch-to-buffer")
other switch user.emacs("switch-to-buffer-other-window")
display user.emacs("display-buffer")
shell command user.emacs("shell-command")
shell command inserting user.emacs_prefix() user.emacs("shell-command")
shell command on region user.emacs("shell-command-on-region")
shell command on region replacing `user.emacs_prefix() user.emacs("shell-command-on-region")
```
 # CUSTOMIZE #`
```
customize face user.emacs("customize-face")
customize face <user.text> user.emacs("customize-face") user.insert_formatted(text, "DASH_SEPARATED")
customize group user.emacs("customize-group")
customize variable user.emacs("customize-variable")
(customize | custom) [theme] visit theme user.emacs("custom-theme-visit-theme")
auto fill mode user.emacs("auto-fill-mode")
dired omit mode user.emacs("dired-omit-mode")
display line numbers mode user.emacs("display-line-numbers-mode")
electric quote local mode user.emacs("electric-quote-local-mode")
emacs lisp mode user.emacs("emacs-lisp-mode")
fundamental mode user.emacs("fundamental-mode")
global display line numbers mode user.emacs("global-display-line-numbers-mode")
global highlight line mode user.emacs("global-hl-line-mode")
global visual line mode user.emacs("global-visual-line-mode")
highlight line mode user.emacs("hl-line-mode")
lisp interaction mode user.emacs("lisp-interaction-mode")
markdown mode user.emacs("markdown-mode")
menu bar mode user.emacs("menu-bar-mode")
overwrite mode user.emacs("overwrite-mode")
paredit mode user.emacs("paredit-mode")
rainbow mode user.emacs("rainbow-mode")
read only mode user.emacs("read-only-mode")
shell script mode user.emacs("sh-mode")
sub word mode user.emacs("subword-mode")
tab bar mode user.emacs("tab-bar-mode")
talon script mode user.emacs("talonscript-mode")
text mode user.emacs("text-mode")
transient mark mode user.emacs("transient-mark-mode")
visual line mode user.emacs("visual-line-mode")
whitespace mode user.emacs("whitespace-mode")
emacs record user.emacs("kmacro-start-macro")
emacs stop user.emacs("kmacro-end-macro")
emacs play user.emacs("kmacro-end-and-call-macro")
profiler start user.emacs("profiler-start")
profiler stop user.emacs("profiler-stop")
profiler report user.emacs("profiler-report")
split solo user.emacs("delete-other-windows")
[split] rebalance user.emacs("balance-windows")
split shrink user.emacs("shrink-window-if-larger-than-buffer")
other [split] shrink user.split_next() user.emacs("shrink-window-if-larger-than-buffer") user.split_last()
split grow user.emacs("enlarge-window")
split grow <number_small> user.emacs("enlarge-window", number_small)
split shrink <number_small> amount = number_small or 1 user.emacs("enlarge-window", 0 - amount)
split widen [<number_small>] user.emacs("enlarge-window-horizontally", number_small or 1)
split narrow [<number_small>] `user.emacs("shrink-window-horizontally", number_small or 1)
```
 # ----- HELP ----- #`
```
apropos user.emacs_help("a")
describe (fun | function) user.emacs_help("f")
describe key user.emacs_help("k")
describe key briefly user.emacs_help("c")
describe symbol user.emacs_help("o")
describe variable user.emacs_help("v")
describe mode user.emacs_help("m")
describe bindings user.emacs_help("b")
describe (char | character) user.emacs("describe-character")
describe text properties user.emacs("describe-text-properties")
describe face user.emacs("describe-face")
view lossage user.emacs_help("l")
apropos <user.text> user.emacs_help("a") user.insert_formatted(text, "DASH_SEPARATED") key(enter)
describe (fun | function) <user.text> user.emacs_help("f") user.insert_formatted(text, "DASH_SEPARATED") key(enter)
describe symbol <user.text> user.emacs_help("o") user.insert_formatted(text, "DASH_SEPARATED") key(enter)
describe variable <user.text> `user.emacs_help("v") user.insert_formatted(text, "DASH_SEPARATED") key(enter)
```
 # ----- FILES & BUFFERS -----`
```
file open user.emacs("find-file")
file rename user.emacs("rename-file")
(file open | find file) at point user.emacs("ffap")
other file open user.emacs("find-file-other-window")
(file | buffer) close user.emacs("kill-buffer") key(enter)
buffer kill user.emacs("kill-buffer")
buffer bury user.emacs("bury-buffer")
buffer revert | revert buffer user.emacs("revert-buffer")
buffer finish edit.save() user.emacs("server-edit")
buffer list user.emacs("buffer-menu")
buffer next user.emacs("next-buffer")
buffer last user.emacs("previous-buffer")
buffer rename user.emacs("rename-buffer")
buffer widen user.emacs("widen")
buffer narrow | [buffer] narrow to region user.emacs("narrow-to-region")
diff (buffer | [buffer] with file) `user.emacs("diff-buffer-with-file") key(enter)
```
 # ----- MOTION AND EDITING ----- #`
```
mark user.emacs("set-mark-command")
go back user.emacs("pop-to-mark-command")
global [go] back user.emacs("pop-global-mark")
auto indent user.emacs("indent-region")
indent <user.number_signed_small> user.emacs("indent-rigidly", number_signed_small)
search back user.emacs("isearch-backward")
(search regex | regex search) user.emacs("isearch-forward-regexp")
(search regex | regex search) back user.emacs("isearch-backward-regexp")
replace user.emacs("query-replace")
replace regex | regex replace user.emacs("query-replace-regexp")
search [toggle] words user.emacs("isearch-forward-word")
search [toggle] symbol user.emacs("isearch-forward-symbol")
search edit user.emacs_meta("e")
search toggle case [fold | sensitive] user.emacs_meta("c")
search toggle regex user.emacs_meta("r")
highlight lines matching [regex] user.emacs("highlight-lines-matching-regexp")
highlight regex user.emacs("highlight-regexp")
unhighlight regex user.emacs("unhighlight-regexp")
unhighlight all user.emacs_prefix() user.emacs("unhighlight-regexp")
recenter user.emacs_prefix() user.emacs("recenter-top-bottom")
(center | [center] <number_small> from) top user.emacs("recenter-top-bottom", number_small or 0)
(center | [center] <number_small> from) bottom number = number_small or 0 user.emacs("recenter-top-bottom", -1 - number)
go top edit.jump_line(number) user.emacs("recenter-top-bottom", 0)
go bottom edit.jump_line(number) user.emacs("recenter-top-bottom", -2)
next error | error next user.emacs("next-error")
last error | error last user.emacs("previous-error")
term right user.emacs("forward-sexp")
term left user.emacs("backward-sexp")
term up user.emacs("backward-up-list")
term end user.emacs("up-list")
term down user.emacs("down-list")
term kill user.emacs("kill-sexp")
term wipe user.emacs("kill-sexp", -1)
term (mark | select) user.emacs("mark-sexp")
term copy user.emacs("mark-sexp") edit.copy()
term freeze user.emacs("mark-sexp") user.emacs("comment-region")
term [auto] indent user.emacs("mark-sexp") user.emacs("indent-region")
(sentence | sent) (right | end) edit.sentence_end()
(sentence | sent) (left | start) edit.sentence_start()
(sentence | sent) kill user.emacs("kill-sentence")
graph kill user.emacs("kill-paragraph")
graph up edit.paragraph_start()
graph down edit.paragraph_end()
graph mark user.emacs("mark-paragraph")
graph copy user.emacs("mark-paragraph") edit.copy()

graph cut `user.emacs("mark-paragraph") edit.cut()

 # NB. can use these to implement "drag <X> left/right/up/down" commands,
 # but note that 'transpose line' and 'drag line down' are different.`

transpose [word | words] user.emacs("transpose-words")
transpose (term | terms) user.emacs("transpose-sexps")
transpose (char | chars) user.emacs("transpose-chars")
transpose (line | lines) user.emacs("transpose-lines")
transpose (sentence | sentences) user.emacs("transpose-sentences")
transpose (graph | graphs | paragraphs) user.emacs("transpose-paragraphs")
register (copy | save) user.emacs("copy-to-register")
register (paste | insert) user.emacs("insert-register")
register jump user.emacs("jump-to-register")
register (copy | save) rectangle user.emacs("copy-rectangle-to-register")
rectangle clear user.emacs("clear-rectangle")
rectangle delete user.emacs("delete-rectangle")
rectangle kill user.emacs("kill-rectangle")
rectangle open user.emacs("open-rectangle")
rectangle (copy | save) [to] register user.emacs("copy-rectangle-to-register")
rectangle (yank | paste) user.emacs("yank-rectangle")
rectangle copy user.emacs("copy-rectangle-as-kill")
rectangle number lines user.emacs("rectangle-number-lines")
project [find] file user.emacs("project-find-file")
project [find] regexp user.emacs("project-find-regexp")
project [query] replace regexp user.emacs("project-query-replace-regexp")
project (dired | directory) user.emacs("projectile-dired")
project [run] shell user.emacs("projectile-run-shell")
project [run] eshell user.emacs("projectile-run-eshell")
project search user.emacs("project-search")
project vc dir user.emacs("project-vc-dir")
project compile [project] user.emacs("projectile-compile-project")
project [run] shell command user.emacs("projectile-run-shell-command-in-root")
project [run] async shell command user.emacs("projectile-run-async-shell-command-in-root")
project (switch [to buffer] | buffer | buff) user.emacs("projectile-switch-to-buffer")
project kill buffers user.emacs("projectile-kill-buffers")
project switch project user.emacs("project-switch-project")
vc (annotate | blame) user.emacs("vc-annotate")
python mode user.emacs("python-mode")
run python user.emacs("run-python")
python [shell] send buffer user.emacs("python-shell-send-buffer")
python [shell] send file user.emacs("python-shell-send-file")
python [shell] send region user.emacs("python-shell-send-region")
python [shell] send (function | defun) user.emacs("python-shell-send-defun")
python [shell] send statement user.emacs("python-shell-send-statement")
python (shell switch | switch [to] shell) user.emacs("python-shell-switch-to-shell")
smerge mode user.emacs("smerge-mode")
merge next user.emacs("smerge-next")
merge last user.emacs("smerge-prev")
merge keep upper user.emacs("smerge-keep-upper")
merge keep lower user.emacs("smerge-keep-lower")
merge keep this user.emacs("smerge-keep-current")
merge refine user.emacs("smerge-refine")
merge split user.emacs("smerge-resolve")
outline minor mode user.emacs("outline-minor-mode")
outline show all user.emacs("outline-show-all")
outline show entry user.emacs("outline-show-entry")
outline hide entry user.emacs("outline-hide-entry")
outline show [subtree] user.emacs("outline-show-subtree")
outline hide [subtree] user.emacs("outline-hide-subtree")
outline show children user.emacs("outline-show-children")
outline show branches user.emacs("outline-show-branches")
outline hide leaves user.emacs("outline-hide-leaves")
outline hide sublevels user.emacs("outline-hide-sublevels")
outline (hide body | [show] (overview | outline)) user.emacs("outline-hide-body")
outline hide other user.emacs("outline-hide-other")
outline forward [same level] user.emacs("outline-forward-same-level")
outline (backward | back) [same level] user.emacs("outline-backward-same-level")
outline next [visible heading] user.emacs("outline-next-visible-heading")
outline (previous | last) [visible heading] user.emacs("outline-previous-visible-heading")
outline insert [heading] user.emacs("outline-insert-heading")
outline up [heading] user.emacs("outline-up-heading")
outline promote user.emacs("outline-promote")
outline demote user.emacs("outline-demote")
outline move [subtree] down user.emacs("outline-move-subtree-down")
outline move [subtree] up user.emacs("outline-move-subtree-up")
outline mark [subtree] user.emacs("outline-mark-subtree")

apple notes

new note key(cmd-n)
duplicate note key(cmd-d)
new folder key(shift-cmd-n)
toggle folders key(alt-cmd-s)
show main key(cmd-0)
list view key(cmd-1)
gallery view key(cmd-2)
toggle attachments key(cmd-3)
find all key(alt-cmd-f)
print note key(cmd-p)
attach file key(shift-cmd-a)
create link key(cmd-k)
insert table key(alt-cmd-t)
apply title key(shift-cmd-t)
apply heading key(shift-cmd-h)
apply subheading key(shift-cmd-j)
apply body key(shift-cmd-b)
apply mono key(shift-cmd-m)
apply bullet key(shift-cmd-7)
apply dash key(shift-cmd-8)
apply number key(shift-cmd-9)
apply checklist key(shift-cmd-l)
increase font key(cmd-+)
decrease font key(cmd--)
line break key(ctrl-enter)
mark key(shift-cmd-u)
drag [line] down key('ctrl-cmd-down')
drag [line] up key('ctrl-cmd-up')

protonmail

open help key(?)
[focus] search key(/)
confirm active key(enter)
close active key(escape)
open command [palette] key(shift-space)
new message key(c)
send message key(ctrl-enter)
save message key(ctrl-s)
(go | jump) [to] inbox key(g) key(i)
(go | jump) [to] draft key(g) key(d)
(go | jump) [to] sent key(g) key(s)
(go | jump) [to] starred key(g) key(.)
(go | jump) [to] archive key(g) key(a)
(go | jump) [to] spam key(g) key(x)
(go | jump) [to] trash `key(g) key(t)
```
 ## Navigation`
```
(prev | previous) message key(up)
next message key(down)
exit message key(left)
enter message key(right)
(show | display) newer [message] key(k)
(show | display) older [message] key(j)
open message key(enter)
go back key(escape)
select all key(*) key(a)
(deselect | unselect) all key(*) key(n)
select [the] (message | conversation) key(x)
mark [as] read key(r)
mark [as] unread key(u)
star (message | conversation) key(.)
move to inbox key(i)
move to trash key(t)
move to archive key(a)
move to spam key(s)
reply to (message | conversation) key(shift-r)
reply all [to] (message | conversation) key(shift-a)
forward (message | conversation) key(shift-f)
(prev | previous) contact key(up)
next contact key(down)
enter contact key(right)
delete contact key(t)
exit contact key(left)
save contact key(ctrl-s)

github web

focus search key(s)
go to notifications insert("gn")
go to dashboard insert("gd")
(keyboard shortcuts show | show keyboard shortcuts) key(?)
(selection move down | move selection down) key(j)
(selection move up | move selection up) key(k)
(selection toggle | toggle selection) key(x)
(selection open | open selection) key(o)
go to code insert("gc")
go to issues insert("gi")
go to pull requests insert("gp")
go to wiki insert("gw")
go to actions insert("ga")
go to projects insert("gb")
go to discussions insert("gg")
[web] editor open key(.)
(file find | find file) key(t)
jump to line key(l)
((branch | tag) switch | switch (branch | tag)) key(w)
(url expand | expand url) key(y)
(show | hide) comments key(i)
blame view open key(b)
(show | hide) annotations key(a)
(issue create | create [an] issue) key(c)
search (issues | [pull] requests) key(/)
(filter by | edit) labels key(l)
(filter by | edit) milestones key(m)
(filter by | edit) assignee key(a)
reply key(r)
(comment submit | submit comment) key(ctrl-enter)
(comment preview | preview comment) key(ctrl-shift-p)
git hub full screen key(ctrl-shift-l)
(form close | close form) key(escape)
parent commit key(p)
other parent commit key(o)
mark as read key(y)
(thread mute | mute thread) key(shift-m)
(issue open | open issue) key(o)
(issue create | create issue) key(c)
reviewer request key(q)
milestone set key(m)
assignee set key(a)
label set key(l)
go to workflow insert("gf")
timestamps toggle key(shift-t)
fullscreen toggle key(shift-f)

finder

preferences key(cmd-,)
options key(cmd-j)
search key(cmd-alt-f)
sort by none key(ctrl-alt-cmd-0)
sort by name key(ctrl-alt-cmd-1)
sort by kind key(ctrl-alt-cmd-2)
sort by date opened key(ctrl-alt-cmd-3)
sort by date added key(ctrl-alt-cmd-4)
sort by date modified key(ctrl-alt-cmd-5)
sort by size key(ctrl-alt-cmd-6)
icon view key(cmd-1)
column view key(cmd-3)
list view key(cmd-2)
gallery view key(cmd-4)
copy path key(alt-cmd-c)
trash it key(cmd-backspace)
hide [finder] key(cmd-h)
hide others app.window_hide_others()

tmux

go split <user.arrow_key> user.tmux_keybind(arrow_key)
go split user.tmux_execute_command("display-panes -d 0")

linux tmux linux

mux "tmux "
mux new session insert("tmux new ")
mux sessions key(ctrl-b) key(s)
mux name session key(ctrl-b) key($)
mux kill session insert("tmux kill-session -t ")
mux new window key(ctrl-b) key(c)
mux window key(ctrl-b) key('{number}')
mux previous window key(ctrl-b) key(p)
mux next window key(ctrl-b) key(n)
mux rename window key(ctrl-b) key(,)
mux close window key(ctrl-b) key(&) #pane management
mux split horizontal key(ctrl-b) key(%)
mux split vertical key(ctrl-b) key(")
mux next pane key(ctrl-b) key(o)
mux move <user.arrow_key> key(ctrl-b) key(arrow_key)
mux close pane key(ctrl-b) key(x) #Say a number right after this command, to switch to pane
mux pane numbers key(ctrl-b) key(q)

apple terminal

suspend key(ctrl-z)
resume insert("fg") key(enter)

vivaldi

(sidebar | panel) history user.vivaldi_history_panel()
(sidebar | panel) downloads user.vivaldi_downloads_panel()
(sidebar | panel) bookmarks user.vivaldi_bookmarks_panel()
(sidebar | panel) notes user.vivaldi_notes_panel()
please [<user.text>] user.vivaldi_toggle_quick_commands() sleep(180ms) insert(user.text or "")

linux signal linux

show shortcuts key("ctrl-/")
(next | nav | navigate) [by] (sec | section) key("ctrl-t")
(prev | previous) (chat | conversation) key("alt-down")
next (chat | conversation) key("alt-up")
(prev | previous) unread key("alt-shift-down")
next unread key("alt-shift-up")
[open] (pref | preferences) key("ctrl-,")
open conversation menu key("ctrl-shift-l")
search key("ctrl-f")
search chat key("ctrl-shift-f")
focus (chat | composer) key("ctrl-shift-t")
open media key("ctrl-shift-m")
open emoji key("ctrl-shift-j")
open sticker key("ctrl-shift-s")
record [voice] message key("ctrl-shift-v")
archive chat key("ctrl-shift-a")
unarchive chat key("ctrl-shift-u")
(first | top) message key("ctrl-up")
(last | bottom) message key("ctrl-down")
close chat key("ctrl-shift-c")
send it key("enter")
message details key("ctrl-d")
reply [message] key("ctrl-shift-r")
react [message] key("ctrl-shift-e")
save attachment key("ctrl-s")
delete [message] key("ctrl-shift-d")
send message key("ctrl-enter")
expand chat key("ctrl-shift-x")
attach [file] key("ctrl-u")
remove [link] preview key("ctrl-p")
remove [link] attachment key("ctrl-shift-p")

termite

shell yank key("y")
shell select key("ctrl-shift-space")
shell insert key("escape")
visual line key("v")
visual line mode key("V")

git add patch

yank key(y) key(enter)
near key(n) key(enter)
quench key(q) key(enter)
drum key(d) key(enter)
air key(a) key(enter)

git

git {user.git_command} [<user.git_arguments>] args = git_arguments or "" "git {git_command}{args} "
git commit [<user.git_arguments>] message [<user.prose>] args = git_arguments or "" message = prose or "" user.insert_between("git commit{args} --message '{message}", "'")
git stash [push] [<user.git_arguments>] message [<user.prose>] `args = git_arguments or "" message = prose or "" user.insert_between("git stash push{args} --message '{message}", "'")
```
 # Optimistic execution for frequently used commands that are harmless (don't
 # change repository or index state).`
```
git status "git status\n"
git add patch "git add --patch\n"
git show head "git show HEAD\n"
git diff "git diff\n"
git diff (cached | cashed) "git diff --cached\n"
git clone clipboard insert("git clone ") edit.paste() key(enter)
git diff highlighted edit.copy() insert("git diff ") edit.paste() key(enter)
git diff clipboard insert("git diff ") edit.paste() key(enter)
git add highlighted edit.copy() insert("git add ") edit.paste() key(enter)
git add clipboard insert("git add ") edit.paste() key(enter)
git commit highlighted edit.copy() insert("git add ") edit.paste() insert("\ngit commit\n")

linux keepassx linux

open database key(ctrl-o)
save database key(ctrl-s)
close database key(ctrl-w)
lock database key(ctrl-l)
quit key(ctrl-q)
[add] new entry key(ctrl-n)
clone entry key(ctrl-k)
(view | edit) entry key(ctrl-e)
delete entry key(ctrl-d)
copy user [name] key(ctrl-b)
copy password key(ctrl-c)
open (earl | url | link) key(ctrl-u)
copy (earl | url | link) key(ctrl-alt-u)
find key(ctrl-f)
find <user.text> key(ctrl-f) insert("{text}")

linux taskwarrior linux

task version "task --version\n"
task commands "task commands\n"
task help "task help\n"
task list "task list\n"
task list orphans "task project: list\n"
task list untagged "task tags.none: list\n"
task list <user.text> "task list {text}\n"
task list project "task list project: "
task list project <user.text> "task list project:{text}\n"
task add "task add "
task add <user.text> "task add {text}\n"
task undo "task undo\n"
(tasks | task next) "task next\n"
task edit "task {number} edit"
task done "task {number} done"
task delete "task {number} delete"

outlook web

new message key(n)
send [this] message key(alt-s)
reply [to] [this] message key(r)
reply all [to] [this] message key(ctrl-shift-r)
forward [this] message key(ctrl-shift-f)
save [draft] key(ctrl-s)
discard [draft] key(esc)
insert [a] [hyper] link key(ctrl-k)
(select | unselect) [this] message key(ctrl-space)
select all [messages] key(ctrl-a)
clear all [messages] key(esc)
select first [message] key(home)
select last [message] key(and)
open [this] message key(o)
open [this] message [in] [a] new window key(shift-enter)
close [this] message key(esc)
[open] [the] next (item | message) key(ctrl-.)
[open] [the] (prev | previous) item key(ctrl-,)
next reading [pane] (item | message) key(.)
(prev | previous) [pane] (item | message) key(,)
(expand | collapse) [conversation] key(x)
go [to] mail key(ctrl-shift-1)
go [to] calendar key(ctrl-shift-2)
go [to] people key(ctrl-shift-3)
go [to] to do key(ctrl-shift-4)
go [to] inbox key(g) key(i)
go to drafts key(g) key(d)
go to sent key(g) key(s)
search [email] key(alt-q)
show help key(?)
undo [last] [action] key(ctrl-z)
delete [this] [message] key(delete)
(perm | permanently) delete [this] [message] key(shift+delete)
new folder key(shift-e)
mark [this] [(item | message)] as read key(q)
mark [this] [(item | message)] as unread key(u)
flag [this] [(item | message)] key(insert)
archive key(e)
mark [this] [message] [as] junk key(j)
moved to [a] folder key(v)
categorize [this] message key(c)

win outlook win

archive key(alt h o 1)
new e-mail key(ctrl-n)
calendar key(ctrl-2)
inbox key(ctrl-1)
Reply key(ctrl-r)
Reply all key(ctrl-shift-r)
Forward key(ctrl-f)
accept key(shift-f10 c c enter)

discord

{user.discord_destination} [<user.text>] user.discord_quick_switcher(user.discord_destination, user.text or "")
switcher user.discord_quick_switcher("", "")
[channel] mentions last user.discord_mentions_last()
[channel] mentions next user.discord_mentions_next()
oldest unread user.discord_oldest_unread()
current call user.discord_go_current_call()
toggle pins user.discord_toggle_pins()
toggle inbox user.discord_toggle_inbox()
toggle (members | member list) user.discord_toggle_members()
toggle (dee ems | dims) user.discord_toggle_dms()
pick emoji user.discord_emoji_picker()
pick (jif | gif | gift) user.discord_gif_picker()
pick sticker user.discord_sticker_picker()
mark inbox channel read user.discord_mark_inbox_read()
[toggle] (mute | unmute) user.discord_mute()
(mute | unmute) and sleep user.discord_mute() speech.disable()
[toggle] (deafen | undeafen) user.discord_deafen()
answer call user.discord_answer_call()
decline call user.discord_decline_call()

eclipse

please [<user.text>] `key(ctrl-3) insert(user.text or "")
```
 # Sidebar`
```
bar explore key(alt-shift-w p)
bar outline key(alt-shift-q o)
panel output key(alt-shift-q) sleep(200ms) key(c)
panel problems key(alt-shift-q) sleep(200ms) key(x)
panel errors key(alt-shift-q) sleep(200ms) key(l)
panel breakpoints key(alt-shift-q) sleep(200ms) key(b)
panel search key(alt-shift-q) sleep(200ms) key(s)
panel variables `key(alt-shift-q) sleep(200ms) key(v) # panel switch: # panel terminal:
```
 # Settings`
```
show settings key(alt-w p)
show shortcuts key(ctrl-shift-l)
file hunt [<user.text>] key(ctrl-shift-r) sleep(50ms) insert(text or "") # file copy path: # file create sibling:
file create key(ctrl-n)
file open folder key(alt-shift-w x)
file rename key(alt-shift-w p enter f2)
file reveal key(alt-shift-w p enter)
imports fix key(ctrl-shift-o)
refactor rename key(alt-shift-r)
refactor this key(alt-shift-i)
(go declaration | follow) key(f3)
go back key(alt-left)
go forward key(alt-right)
go marks key(alt-end)
toggle mark key(ctrl-alt-b down enter)
go next mark key(alt-pagedown)
go last mark key(alt-pageup)
break point key(ctrl-shift-b)
step over key(f6)
debug step into key(f5)
debug step out [of] key(f7)
debug continue key(f8)
copy line down key(ctrl-alt-down)
copy line up key(ctrl-alt-up)

firefox

tab search browser.focus_address() insert("% ")
tab search <user.text> browser.focus_address() insert("% {text}") key(down)
(sidebar | panel) bookmarks user.firefox_bookmarks_sidebar()
(sidebar | panel) history user.firefox_history_sidebar()

gdb global

[enable] debug mode user.gdb_enable()
disable debug mode user.gdb_disable()

gdb active

until "until {number}"
force clear all break points insert("d br\n") insert("y\n")
break [on] clipboard `insert("break ") key(ctrl-shift-v) key(enter)
```
 # information`
```
list [source] "list\n"
info source "info source\n"
print "p "
print [variable] <user.text> "p {text}"
print hex "p/x "
print hex [variable] <user.text> "p/x {text}"
print string "p/s "
hex dump bytes "x/{number}bx "
hex dump (half | short) words "x/{number}hx "
hex dump (d | long) words "x/{number}dx "
hex dump quad words "x/{number}gx "
hex dump "x/100gx "
hex dump highlighted insert("x/100gx ") edit.copy() edit.paste() key(enter)
hex dump clipboard `insert("x/100gx ") edit.paste() key(enter)
```
 # execution`
```
source "source \t\t"
(list | show | info) display "info display\n"
display assembly line "display /i $pc\n"
display source "display "
enable display <number_small> "enable display {number_small}\n"
disable display <number_small> "disable display {number_small}\n"
undisplay "undisplay\n"
(list | show | info) local "info local "
(list | show | info) local typed "info local -t "
(list | show | info) variable "info variable "
(list | show | info) variable typed "info variable -t "
(list | show | info) locals "info local\n"
(list | show | info) variables "info variables\n"
info threads "info threads\n"
restart [program] "r\n"
continue "c\n"
back trace "bt\n"
debug quit "quit\n"
debug force quit "quit\ny\n"
(show | info) (inf | inferiors) "info inferiors\n"
inferior <number_small> "inferior {number_small}\n"
inferior "inferior "
resume main (inf | inferior) insert("inferior 1\n") insert("c\n")
resume [from] (inf | inferior) <number_small> `insert("inferior {number_small}\n") insert("c\n")
```
 # arguments`
```
set args "set args "
show follow (fork | forks) [mode] "show follow-fork-mode\n"
[set] follow (fork | forks) [mode] child "set follow-fork-mode child\n"
[set] follow (fork | forks) [mode] parent "set follow-fork-mode parent\n"
show detach on fork "show detach-on-fork\n"
set detach on fork "set detach-on-fork on\n"
unset detach on fork "set detach-on-fork off\n"
show list size "show listsize\n"
set list size <number_small> "set listsize {number_small}\n"
clear screen "shell clear\n"

mac teams mac

open history key(super-shift-h)
view shortcuts key(super-.)
show shortcuts key(super-.)
[go] [to] search key(super-e)
show commands key(super-/)
open filter key(super-shift-f)
go to key(super-g)
open (apps | applications) key(ctrl-)`
[start] new chat key(super-n)
open settings key(super-,)
open help key(f1)
close key(escape)
reset key(escape) key(escape) key(escape) key(escape)
zoom reset key(super-0)
open (act | activity) key(super-1)
open chat key(super-2)
open teams key(super-3)
open calendar key(super-4)
open calls key(super-5)
open files key(super-6)
[go] [to] (prev | previous) [list] item key(alt-up)
[go] [to] next [list] item key(alt-down)
move [selected] team up key(super-shift-up)
move [selected] team down key(super-shift-down)
[go] [to] (prev | previous) section key(super-shift-f6)
[go] [to] next section key(super-f6)
[go] [to] compose [box] key(shift-alt-c)
[expand] compose [box] key(super-shift-x)
send message key(super-enter)
attach file key(shift-alt-o)
attach local file key(shift-alt-o) sleep(100ms) key(down) key(space)
[start] new line key(shift-enter)
reply [to] [thread] key(shift-alt-r)
accept video call key(super-shift-a)
accept audio call key(super-shift-s)
decline call key(super-shift-d)
start audio call key(super-shift-c)
start video call key(super-shift-u)
toggle mute key(super-shift-m)
starch screen share session key(super-shift-e)
toggle video key(super-shift-o)
[go] [to] sharing toolbar key(super-shift-space)
decline screen share key(super-shift-d)
accept screen share key(super-shift-a)
schedule [a] meeting key(alt-shift-n)
go to current time key(alt-.)
go to (prev | previous) (day | week) key(super-alt-left)
go to next (day | week) key(super-alt-right)
view day key(super-alt-1)
view work week key(super-alt-2)
view week key(super-alt-3)
(save | send) meeting request key(super-s)
join [from] meeting [details] key(alt-shift-j)
go to suggested time key(alt-shift-s)
(raise | lower) hand key(super-shift-k)
leave team meeting key(super-shift-h)

teams

show shortcuts key(ctrl-.)
[go] [to] search key(ctrl-e)
show commands key(ctrl-/)
open filter key(ctrl-shift-f)
go to key(ctrl-g)
open (apps | applications) key(ctrl-)`
[start] new chat key(ctrl-n)
open settings key(ctrl-,)
open help key(f1)
close key(escape)
open activity key(ctrl-1)
open chat key(ctrl-2)
open teams key(ctrl-3)
open calendar key(ctrl-4)
open planner key(ctrl-5)
open calls key(ctrl-6)
open files key(ctrl-7)
[go] [to] (prev | previous) [list] item key(alt-up)
[go] [to] next [list] item key(alt-down)
move [selected] team up key(ctrl-shift-up)
move [selected] team down key(ctrl-shift-down)
[go] [to] (prev | previous) section key(ctrl-shift-f6)
[go] [to] next section key(ctrl-f6)
[go] [to] compose [box] key(c)
[expand] compose [box] key(ctrl-shift-x)
send key(ctrl-enter)
attach file key(ctrl-o)
[start] new line key(shift-enter)
reply [to] [thread] key(r)
accept video call key(ctrl-shift-a)
accept audio call key(ctrl-shift-s)
decline call key(ctrl-shift-d)
start audio call key(ctrl-shift-c)
start video call key(ctrl-shift-u)
toggle mute key(ctrl-shift-m)
starch screen share session key(ctrl-shift-e)
toggle video key(ctrl-shift-o)
[go] [to] sharing toolbar key(ctrl-shift-space)
decline screen share key(ctrl-shift-d)
accept screen share key(ctrl-shift-a)
schedule [a] meeting key(alt-shift-n)
go to current time key(alt-.)
go to (prev | previous) (day | week) key(ctrl-alt-left)
go to next (day | week) key(ctrl-alt-right)
view day key(ctrl-alt-1)
view work week key(ctrl-alt-2)
view week key(ctrl-alt-3)
(safe | send) meeting request key(ctrl-s)
join [from] meeting [details] key(alt-shift-j)
go to suggested time key(alt-shift-s)

numbers

<user.number_string> "{number_string}"

abbreviate

(abbreviate | abreviate | brief) {user.abbreviation} "{abbreviation}"

language modes

force {user.language_mode} user.code_set_language_mode(language_mode)
clear language modes user.code_clear_language_mode()

wake and sleep wav2letter

go to sleep [] speech.disable()
(wake up)+ speech.enable()

dragon mode

dragon mode user.dragon_mode()
talon mode user.talon_mode()

modes

dictation mode mode.disable("sleep") mode.disable("command") mode.enable("dictation") user.code_clear_language_mode() user.gdb_disable()
command mode mode.disable("sleep") mode.disable("dictation") mode.enable("command")

wake and sleep

(welcome back)+ user.mouse_wake() user.history_enable() user.talon_mode()
sleep all [] user.switcher_hide_running() user.history_disable() user.homophones_hide() user.help_hide() user.mouse_sleep() speech.disable() user.engine_sleep()
talon sleep [] speech.disable()
(talon wake)+ speech.enable()

sleep mode wav2letter

skip()

websites and search engines

open {user.website} user.open_url(website)
{user.search_engine} hunt <user.text> user.search_with_search_engine(search_engine, user.text)
{user.search_engine} (that | this) text = edit.selected_text() user.search_with_search_engine(search_engine, text)

screens

screen numbers user.screens_show_numbering()

edit

zoom in edit.zoom_in()
zoom out edit.zoom_out()
zoom reset edit.zoom_reset()
find it edit.find()
next one edit.find_next()
scroll up edit.page_up()
scroll down edit.page_down()
go word left edit.word_left()
go word right edit.word_right()
go left edit.left()
go right edit.right()
go up edit.up()
go down edit.down()
go line start edit.line_start()
go line end edit.line_end()
go way left edit.line_start() edit.line_start()
go way right edit.line_end()
go way up edit.file_start()
go way down edit.file_end()
go top edit.file_start()
go bottom edit.file_end()
go page up edit.page_up()
go page down edit.page_down()
select all edit.select_all()
select line edit.select_line()
select line start user.select_line_start()
select line end user.select_line_end()
select left edit.extend_left()
select right edit.extend_right()
select up edit.extend_line_up()
select down edit.extend_line_down()
select word edit.select_word()
select word left edit.extend_word_left()
select word right edit.extend_word_right()
select way left edit.extend_line_start()
select way right edit.extend_line_end()
select way up edit.extend_file_start()
select way down edit.extend_file_end()
indent [more] edit.indent_more()
(indent less | out dent) edit.indent_less()
clear all user.delete_all()
clear line edit.delete_line()
clear line start user.delete_line_start()
clear line end user.delete_line_end()
clear left edit.delete()
clear right user.delete_right()
clear up edit.extend_line_up() edit.delete()
clear down edit.extend_line_down() edit.delete()
clear word edit.delete_word()
clear word left edit.extend_word_left() edit.delete()
clear word right edit.extend_word_right() edit.delete()
clear way left edit.extend_line_start() edit.delete()
clear way right edit.extend_line_end() edit.delete()
clear way up edit.extend_file_start() edit.delete()
clear way down `edit.extend_file_end() edit.delete()
```
 # Copy`
```
copy that edit.copy()
copy all user.copy_all()
copy line user.copy_line()
copy line start user.copy_line_start()
copy line end user.copy_line_end()
copy word user.copy_word()
copy word left user.copy_word_left()
copy word right user.copy_word_right()
cut that edit.cut()
cut all user.cut_all()
cut line user.cut_line()
cut line start user.cut_line_start()
cut line end user.cut_line_end()
cut word user.cut_word()
cut word left user.cut_word_left()
cut word right user.cut_word_right()
(pace | paste) that edit.paste()
(pace | paste) enter edit.paste() key(enter)
paste match edit.paste_match_style()
(pace | paste) all user.paste_all()
(pace | paste) line user.paste_line()
(pace | paste) line start user.paste_line_start()
(pace | paste) line end user.paste_line_end()
(pace | paste) word user.paste_word()
clone that edit.selection_clone()
clone line edit.line_clone()
new line above edit.line_insert_up()
new line below | slap edit.line_insert_down()
(pad | padding) user.insert_between(" ", " ")
(pad | padding) <user.symbol_key>+ `insert(" ") user.insert_many(symbol_key_list) insert(" ")
```
 # Undo/redo`
```
undo that edit.undo()
redo that edit.redo()
file save edit.save()
file save all edit.save_all()

edit settings

customize {user.talon_settings_csv} user.edit_text_file(talon_settings_csv) sleep(500ms) edit.file_end()

homophones

phones <user.homophones_canonical> user.homophones_show(homophones_canonical)
phones that user.homophones_show_auto()
phones force <user.homophones_canonical> user.homophones_force_show(homophones_canonical)
phones force user.homophones_force_show_selection()
phones hide user.homophones_hide()
phones word edit.select_word() user.homophones_show_selection()
phones [<user.ordinals>] word left n = ordinals or 1 user.words_left(n - 1) edit.extend_word_left() user.homophones_show_selection()
phones [<user.ordinals>] word right n = ordinals or 1 user.words_right(n - 1) edit.extend_word_right() user.homophones_show_selection()

homophones open

choose <number_small> result = user.homophones_select(number_small) insert(result) user.homophones_hide()
choose <user.formatters> <number_small> result = user.homophones_select(number_small) insert(user.formatted_text(result, formatters)) user.homophones_hide()

win window management

window (new | open) app.window_open()
window next app.window_next()
window last app.window_previous()
window close app.window_close()
window hide app.window_hide()
focus <user.running_applications> user.switcher_focus(running_applications)
focus user.switcher_menu()
running list user.switcher_toggle_running()
running close user.switcher_hide_running()
launch <user.launch_applications> user.switcher_launch(launch_applications)
snap <user.window_snap_position> user.snap_window(window_snap_position)
snap next [screen] user.move_window_next_screen()
snap last [screen] user.move_window_previous_screen()
snap screen user.move_window_to_screen(number)
snap <user.running_applications> <user.window_snap_position> user.snap_app(running_applications, window_snap_position)
snap <user.running_applications> [screen] user.move_app_to_screen(running_applications, number)

win tabs

tab (open | new) app.tab_open()
tab (last | previous) app.tab_previous()
tab next app.tab_next()
tab close user.tab_close_wrapper()
tab (reopen | restore) app.tab_reopen()
go tab user.tab_jump(number)
go tab final user.tab_final()
tab duplicate user.tab_duplicate()

text

phrase <user.text> user.add_phrase_to_history(text) insert(text)
phrase <user.text> over user.add_phrase_to_history(text) insert(text)
{user.prose_formatter} <user.prose> user.insert_formatted(prose, prose_formatter)
{user.prose_formatter} <user.prose> over user.insert_formatted(prose, prose_formatter)
<user.format_text>+ user.insert_many(format_text_list)
<user.format_text>+ over user.insert_many(format_text_list)
<user.formatters> that user.formatters_reformat_selection(user.formatters)
word <user.word> user.add_phrase_to_history(word) insert(word)
proud <user.word> user.insert_formatted(word, "CAPITALIZE_FIRST_WORD")
recent list user.toggle_phrase_history()
recent close user.phrase_history_hide()
recent repeat <number_small> recent_phrase = user.get_recent_phrase(number_small) user.add_phrase_to_history(recent_phrase) insert(recent_phrase)
recent copy <number_small> clip.set_text(user.get_recent_phrase(number_small))
select that user.select_last_phrase()
before that user.before_last_phrase()
nope that | scratch that user.clear_last_phrase()
nope that was <user.formatters> user.formatters_reformat_last(formatters)

file extension

{user.file_extension} "{file_extension}"

mouse grid open

<user.number_key> user.grid_narrow(number_key)
grid off user.grid_close()
grid reset user.grid_reset()
grid back user.grid_go_back()

mouse grid

M grid app.notify("please use the voice command 'mouse grid' instead of 'm grid'") user.grid_select_screen(1) user.grid_activate()

mouse grid always

mouse grid user.grid_select_screen(1) user.grid_activate()
grid win user.grid_place_window() user.grid_activate()
grid <user.number_key>+ user.grid_activate() user.grid_narrow_list(number_key_list)
grid screen [] user.grid_select_screen(number or 1) user.grid_activate()

edit vocabulary

copy to vocab [as ] user.add_selection_to_vocabulary(phrase or "")
copy name to vocab [as ] user.add_selection_to_vocabulary(phrase or "", "name") # Automatically adds plural form by simply appending "s".
copy noun to vocab [as ] user.add_selection_to_vocabulary(phrase or "", "noun")
copy to replacements as user.add_selection_to_words_to_replace(phrase)
copy name to replacements as user.add_selection_to_words_to_replace(phrase, "name") # Automatically adds plural form by simply appending "s".
copy noun to replacements as user.add_selection_to_words_to_replace(phrase, "noun")

help scope open

scope (hide | close) user.help_scope_toggle()

help open

help next user.help_next()
help previous user.help_previous()
help user.help_select_index(number - 1)
help return user.help_return()
help refresh user.help_refresh()
help close user.help_hide()

help

help alphabet user.help_list("user.letter")
help symbols user.help_list("user.symbol_key")
help numbers user.help_list("user.number_key")
help punctuation user.help_list("user.punctuation")
help modifier user.help_list("user.modifier_key")
help special keys user.help_list("user.special_key")
help function keys user.help_list("user.function_key")
help arrows user.help_list("user.arrow_key")
(help formatters | help format | format help) user.help_formatters(user.get_formatters_words())
help context user.help_context()
help active user.help_context_enabled()
help search <user.text> user.help_search(text)
help context {user.help_contexts} user.help_selected_context(help_contexts)
help help user.help_search("help")
help scope user.help_scope_toggle()

cancel

cancel cancel skip()
ignore [] app.notify("Command ignored")

dropdown

drop down <number_small> key("down:{number_small-1} enter")
drop down up <number_small> key("up:{number_small} enter")

draft editor

draft this user.draft_editor_open()
draft all edit.select_all() user.draft_editor_open()
draft line edit.select_line() user.draft_editor_open()
draft top edit.extend_file_start() user.draft_editor_open()
draft bottom edit.extend_file_end() user.draft_editor_open()
draft submit user.draft_editor_paste_last()

draft editor open

draft submit user.draft_editor_submit()
draft discard user.draft_editor_discard()

screenshot

grab screen user.screenshot()
grab screen <number_small> user.screenshot(number_small)
grab window user.screenshot_window()
grab selection user.screenshot_selection()
grab selection clip user.screenshot_selection_clip()
grab settings user.screenshot_settings()
grab screen clip user.screenshot_clipboard()
grab screen <number_small> clip user.screenshot_clipboard(number_small)
grab window clip user.screenshot_window_clipboard()

microphone selection

microphone show user.microphone_selection_toggle()
microphone close user.microphone_selection_hide()
microphone pick <number_small> user.microphone_select(number_small)

desktops

desk <number_small> user.desktop(number_small)
desk next user.desktop_next()
desk last user.desktop_last()
desk show user.desktop_show()
window move desk user.window_move_desktop(number)
window move desk left user.window_move_desktop_left()
window move desk right user.window_move_desktop_right()

mouse

control mouse tracking.control_toggle()
zoom mouse tracking.control_zoom_toggle()
camera overlay tracking.control_debug_toggle()
run calibration tracking.calibrate()
touch mouse_click(0) # close the mouse grid if open user.grid_close() # End any open drags # Touch automatically ends left drags so this is for right drags specifically user.mouse_drag_end()
righty mouse_click(1) # close the mouse grid if open user.grid_close()

mid click `mouse_click(2) # close the mouse grid user.grid_close()

 #see keys.py for modifiers.
 #defaults
 #command
 #control
 #option = alt
 #shift
 #super = windows key`

<user.modifiers> touch key("{modifiers}:down") mouse_click(0) key("{modifiers}:up") # close the mouse grid user.grid_close()
<user.modifiers> righty key("{modifiers}:down") mouse_click(1) key("{modifiers}:up") # close the mouse grid user.grid_close()
(dub click | duke) mouse_click() mouse_click() # close the mouse grid user.grid_close()
(trip click | trip lick) mouse_click() mouse_click() mouse_click() # close the mouse grid user.grid_close()
left drag | drag user.mouse_drag(0) # close the mouse grid user.grid_close()
right drag | righty drag user.mouse_drag(1) # close the mouse grid user.grid_close()
end drag | drag end user.mouse_drag_end()
wheel down user.mouse_scroll_down()
wheel down here user.mouse_move_center_active_window() user.mouse_scroll_down()
wheel tiny [down] user.mouse_scroll_down(0.2)
wheel tiny [down] here user.mouse_move_center_active_window() user.mouse_scroll_down(0.2)
wheel downer user.mouse_scroll_down_continuous()
wheel downer here user.mouse_move_center_active_window() user.mouse_scroll_down_continuous()
wheel up user.mouse_scroll_up()
wheel up here user.mouse_move_center_active_window() user.mouse_scroll_up()
wheel tiny up user.mouse_scroll_up(0.2)
wheel tiny up here user.mouse_move_center_active_window() user.mouse_scroll_up(0.2)
wheel upper user.mouse_scroll_up_continuous()
wheel upper here user.mouse_move_center_active_window() user.mouse_scroll_up_continuous()
wheel gaze user.mouse_gaze_scroll()
wheel gaze here user.mouse_move_center_active_window() user.mouse_gaze_scroll()
wheel stop user.mouse_scroll_stop()
wheel stop here user.mouse_move_center_active_window() user.mouse_scroll_stop()
wheel left user.mouse_scroll_left()
wheel left here user.mouse_move_center_active_window() user.mouse_scroll_left()
wheel tiny left user.mouse_scroll_left(0.5)
wheel tiny left here user.mouse_move_center_active_window() user.mouse_scroll_left(0.5)
wheel right user.mouse_scroll_right()
wheel right here user.mouse_move_center_active_window() user.mouse_scroll_right()
wheel tiny right user.mouse_scroll_right(0.5)
wheel tiny right here user.mouse_move_center_active_window() user.mouse_scroll_right(0.5)
copy mouse position user.copy_mouse_position()
curse no # Command added 2021-12-13, can remove after 2022-06-01 app.notify("Please activate the user.mouse_cursor_commands_enable tag to enable this command")

mouse cursor

curse yes user.mouse_show_cursor()
curse no user.mouse_hide_cursor()

win draft window open

draft hide user.draft_hide()
draft submit content = user.draft_get_text() user.draft_hide() insert(content) # user.paste may be somewhat faster, but seems to be unreliable on MacOSX, see # https://github.com/talonvoice/talon/issues/254#issuecomment-789355238 # user.paste(content)

win draft window

replace <user.draft_anchor> with <user.text> `user.draft_select("{draft_anchor}") result = user.formatted_text(text, "NOOP") insert(result)
```
 # Position cursor before word`
```
(pre | cursor | cursor before) <user.draft_anchor> `user.draft_position_caret("{draft_anchor}")
```
 # Position cursor after word`
```
(post | cursor after) <user.draft_anchor> `user.draft_position_caret("{draft_anchor}", 1)
```
 # Select a whole word`
```
(take | select) <user.draft_anchor> user.draft_select("{draft_anchor}")
(take | select) <user.draft_anchor> (through | past) <user.draft_anchor> `user.draft_select("{draft_anchor_1}", "{draft_anchor_2}")
```
 # Delete a word`
```
(change | chuck | clear) <user.draft_anchor> `user.draft_select("{draft_anchor}", "", 1) key(backspace)
```
 # Delete a range of words`
```
(change | chuck | clear) <user.draft_anchor> (through | past) <user.draft_anchor> `user.draft_select(draft_anchor_1, draft_anchor_2, 1) key(backspace)
```
 # reformat word`
```
<user.formatters> word <user.draft_anchor> `user.draft_select("{draft_anchor}", "", 1) user.formatters_reformat_selection(user.formatters)
```
 # reformat range`
```
<user.formatters> <user.draft_anchor> (through | past) <user.draft_anchor> user.draft_select(draft_anchor_1, draft_anchor_2, 1) user.formatters_reformat_selection(user.formatters)

win draft global

draft show # Do this toggle so we can have focus when saying 'draft show' user.draft_hide() user.draft_show()
draft show <user.draft_window_position> # Do this toggle so we can have focus when saying 'draft show' user.draft_hide() user.draft_show() user.draft_named_move(draft_window_position)
draft show small # Do this toggle so we can have focus when saying 'draft show' user.draft_hide() user.draft_show() user.draft_resize(600, 200)
draft show large # Do this toggle so we can have focus when saying 'draft show' user.draft_hide() user.draft_show() user.draft_resize(800, 500)
draft empty user.draft_show("")
draft edit text = edit.selected_text() key(backspace) user.draft_show(text)
draft edit all edit.select_all() text = edit.selected_text() key(backspace) user.draft_show(text)

text navigation

navigate [{user.arrow_key}] [{user.navigation_action}] [{user.navigation_target_name}] [{user.before_or_after}] [<user.ordinals>] <user.navigation_target> `## If you use this command a lot, you may wish to have a shorter syntax that omits the navigate keyword. Note that you then at least have to say either a navigation_action or before_or_after: #({user.navigation_action} [{user.arrow_key}] [{user.navigation_target_name}] [{user.before_or_after}] | [{user.arrow_key}] {user.before_or_after}) [<user.ordinals>] <user.navigation_target>: user.navigation(navigation_action or "GO", arrow_key or "RIGHT", navigation_target_name or "DEFAULT", before_or_after or "DEFAULT", navigation_target, ordinals or 1)

 # ===== Examples of use =====
 #
 #   navigate comma: moves after the next "," on the line.
 #   navigate before five: moves before the next "5" on the line.
 #   navigate left underscore: moves before the previous "_" on the line.
 #   navigate left after second plex: moves after the second-previous "x" on the line.
 #
 # Besides characters, we can find phrases or move in predetermined units:
 #
 #   navigate phrase hello world: moves after the next "hello world" on the line.
 #   navigate left third word: moves left over three words.
 #   navigate before second big: moves before the second-next 'big' word (a chunk of anything except white space).
 #   navigate left second small: moves left over two 'small' words (chunks of a camelCase name).
 #
 # We can search several lines (default 10) above or below the cursor:
 #
 #   navigate up phrase john: moves before the previous "john" (case-insensitive) on the preceding lines.
 #   navigate down third period: moves after the third period on the following lines.
 #
 # Besides movement, we can cut, copy, select, clear (delete), or extend the current selection:
 #
 #   navigate cut after comma: cut the word following the next comma on the line.
 #   navigate left copy third word: copy the third word to the left.
 #   navigate extend third big: extend the selection three big words right.
 #   navigate down clear phrase I think: delete the next occurrence of "I think" on the following lines.
 #   navigate up select colon: select the closest colon on the preceeding lines.
 #
 # We can specify what gets selected before or after the given input:
 #
 #    navigate select parens after equals: Select the first "(" and everything until the first ")" after the "="
 #    navigate left copy all before equals: Copy everything from the start of the line until the first "=" you encounter while moving left
 #    navigate clear constant before semicolon: Delete the last word consisting of only uppercase characters or underscores before a ";"
 #
 # ===== Explanation of the grammar =====
 #
 # [{user.arrow_key}]: left, right, up, down (default: right)
 #   Which direction to navigate in.
 #   left/right work on the current line.
 #   up/down work on the closest lines (default: 10) above or below.
 #
 # [{user.navigation_action}]: move, extend, select, clear, cut, copy (default: move)
 #   What action to perform.
 #
 # [{user.navigation_target_name}]: word, small, big, parens, squares, braces, quotes, angles, all, method, constant (default: word)
 #    The predetermined unit to select if before_or_after was specified.
 #    Defaults to "word"
 #
 # [{user.before_or_after}]: before, after (default: special behavior)
 #   For move/extend: where to leave the cursor, before or after the target.
 #   Defaults to "after" for right/down and "before" for left/up.
 #
 #   For select/copy/cut: if absent, select/copy/cut the target iself. If
 #   present, the navigation_target_name before/after the target.
 #
 # [<user.ordinals>]: an english ordinal, like "second" (default: first)
 #   Which occurrence of the target to navigate to.
 #
 # <user.navigation_target>: one of the following:
 #   - a character name, like "comma" or "five".
 #   - "word" or "big" or "small"
 #   - "phrase <some text to search for>"
 #   Specifies the target to search for/navigate to.
 
 # The functionality for all these commands is covered in the lines above, but these commands are kept here for convenience. Originally from word_selection.talon.`

word neck [<number_small>] user.navigation_by_name("SELECT", "RIGHT", "DEFAULT", "word", number_small or 1)
word pre [<number_small>] user.navigation_by_name("SELECT", "LEFT", "DEFAULT", "word", number_small or 1)
small word neck [<number_small>] user.navigation_by_name("SELECT", "RIGHT", "DEFAULT", "small", number_small or 1)
small word pre [<number_small>] user.navigation_by_name("SELECT", "LEFT", "DEFAULT", "small", number_small or 1)
big word neck [<number_small>] user.navigation_by_name("SELECT", "RIGHT", "DEFAULT", "big", number_small or 1)
big word pre [<number_small>] user.navigation_by_name("SELECT", "LEFT", "DEFAULT", "big", number_small or 1)

mac macro

macro record user.macro_record()
macro stop user.macro_stop()
macro play [{user.saved_macros}] user.macro_play(saved_macros or "")
macro copy [{user.saved_macros}] user.macro_copy(saved_macros or "")
macro copy as <user.text> user.macro_copy(text)
macro save as <user.text> user.macro_save(text)
macro list user.macro_list()
macro list close user.macro_list_close()

command history

command history user.history_toggle()
command history close user.history_disable()
command history clear user.history_clear()
command history less user.history_less()
command history more user.history_more()

datetimeinsert

date insert insert(user.time_format("%Y-%m-%d"))
date insert UTC insert(user.time_format_utc("%Y-%m-%d"))
timestamp insert insert(user.time_format("%Y-%m-%d %H:%M:%S"))
timestamp insert high resolution insert(user.time_format("%Y-%m-%d %H:%M:%S.%f"))
timestamp insert UTC insert(user.time_format_utc("%Y-%m-%d %H:%M:%S"))
timestamp insert UTC high resolution insert(user.time_format_utc("%Y-%m-%d %H:%M:%S.%f"))

symbols

new line "\n"
double dash "--"
triple quote "'''"
(triple grave | triple back tick | gravy) insert("```")
(dot dot | dotdot) ".."
ellipses "..."
(comma and | spamma) ", "
arrow "->"
dub arrow "=>"
empty dub string user.insert_between('"', '"')
empty escaped (dub string | dub quotes) user.insert_between('\\"', '\\"')
empty string user.insert_between("'", "'")
empty escaped string user.insert_between("\\'", "\\'")
(inside parens | args) user.insert_between("(", ")")
inside (squares | square brackets | list) user.insert_between("[", "]")
inside (bracket | braces) user.insert_between("{", "}")
inside percent user.insert_between("%", "%")
inside (quotes | string) user.insert_between("'", "'")
inside (double quotes | dub quotes) user.insert_between('"', '"')
inside (graves | back ticks) user.insert_between("", "")
angle that text = edit.selected_text() user.paste("<{text}>")
(square | square bracket) that text = edit.selected_text() user.paste("[{text}]")
(bracket | brace) that text = edit.selected_text() user.paste("{{{text}}}")
(parens | args) that text = edit.selected_text() user.paste("({text})")
percent that text = edit.selected_text() user.paste("%{text}%")
quote that text = edit.selected_text() user.paste("'{text}'")
(double quote | dub quote) that text = edit.selected_text() user.paste('"{text}"')
(grave | back tick) that text = edit.selected_text() user.paste("{text}")

talon helpers

talon check updates menu.check_for_updates()
talon open log menu.open_log()
talon open rebel menu.open_repl()
talon home menu.open_talon_home()
talon copy context pie user.talon_add_context_clipboard_python()
talon copy context user.talon_add_context_clipboard()
talon copy name name = app.name() clip.set_text(name)
talon copy executable executable = app.executable() clip.set_text(executable)
talon copy bundle bundle = app.bundle() clip.set_text(bundle)
talon copy title title = win.title() clip.set_text(title)
talon dump version result = user.talon_version_info() print(result)
talon insert version result = user.talon_version_info() user.paste(result)
talon dump context result = user.talon_get_active_context() print(result)
talon test last phrase = user.history_get(1) user.talon_sim_phrase(phrase)
talon test numb <number_small> phrase = user.history_get(number_small) user.talon_sim_phrase(phrase)
talon test user.talon_sim_phrase(phrase)
talon debug action {user.talon_actions} user.talon_action_find("{user.talon_actions}")
talon debug list {user.talon_lists} user.talon_debug_list(talon_lists)
talon copy list {user.talon_lists} user.talon_copy_list(talon_lists)
talon debug tags user.talon_debug_tags()
talon debug modes user.talon_debug_modes()
talon debug scope {user.talon_scopes} user.talon_debug_scope(talon_scopes)
talon debug setting {user.talon_settings} user.talon_debug_setting(talon_settings)
talon debug all settings user.talon_debug_all_settings()
talon debug active app result = user.talon_get_active_application_info() print("**** Dumping active application **** ") print(result) print("***********************")
talon copy active app result = user.talon_get_active_application_info() clip.set_text(result)
talon (bug report | report bug) user.open_url("https://github.com/knausj85/knausj_talon/issues")

repeater

<user.ordinals> core.repeat_command(ordinals - 1)
<number_small> times core.repeat_command(number_small - 1)
(repeat that | twice) core.repeat_command(1)
repeat that <number_small> [times] core.repeat_command(number_small)
(repeat phrase | again) [<number_small> times] core.repeat_partial_phrase(number_small or 1)

media

volume up key(volup)
volume down key(voldown)
set volume user.media_set_volume(number)
(volume | media) mute key(mute)
[media] play next key(next)
[media] play previous key(prev)
media (play | pause) user.play_pause()

line commands

lend edit.line_end()
bend edit.line_start()
go edit.jump_line(number)
go end edit.jump_line(number) edit.line_end()
comment [line] user.select_range(number, number) code.toggle_comment()
comment until user.select_range(number_1, number_2) code.toggle_comment()
clear [line] user.select_range(number, number) edit.delete()
clear until user.select_range(number_1, number_2) edit.delete()
copy [line] user.select_range(number, number) edit.copy()
copy until user.select_range(number_1, number_2) edit.copy()
cut [line] user.select_range(number, number) edit.cut()
cut [line] until user.select_range(number_1, number_2) edit.cut()
(paste | replace) until user.select_range(number_1, number_2) edit.paste()
(select | cell | sell) [line] user.select_range(number, number)
(select | cell | sell) until user.select_range(number_1, number_2)
tab that edit.indent_more()
tab [line] edit.jump_line(number) edit.indent_more()
tab until user.select_range(number_1, number_2) edit.indent_more()
retab that edit.indent_less()
retab [line] user.select_range(number, number) edit.indent_less()
retab until user.select_range(number_1, number_2) edit.indent_less()
drag [line] down edit.line_swap_down()
drag [line] up edit.line_swap_up()
drag up [line] user.select_range(number, number) edit.line_swap_up()
drag up until user.select_range(number_1, number_2) edit.line_swap_up()
drag down [line] user.select_range(number, number) edit.line_swap_down()
drag down until user.select_range(number_1, number_2) edit.line_swap_down()
clone [line] user.line_clone(number)
select camel left user.extend_camel_left()
select camel right user.extend_camel_right()
go camel left user.camel_left()
go camel right user.camel_right()

snippets

snip {user.snippets} user.snippet_insert(user.snippets)
snip hunt <user.text> user.snippet_search(user.text)
snip hunt user.snippet_search("")
snip create user.snippet_create()
snip show user.snippet_toggle()

snippets open

snip close user.snippet_hide()

find and replace

hunt this user.find("")
hunt this (pace | paste) user.find("") sleep(25ms) edit.paste()
hunt this <user.text> user.find(text)
hunt all user.find_everywhere("")
hunt all (pace | paste) user.find_everywhere("") sleep(25ms) edit.paste()
hunt all <user.text> user.find_everywhere(text)
hunt case user.find_toggle_match_by_case()
hunt word user.find_toggle_match_by_word()
hunt expression user.find_toggle_match_by_regex()
hunt next user.find_next()
hunt previous user.find_previous()
replace this [<user.text>] user.replace(text or "")
replace all user.replace_everywhere("")
replace <user.text> all user.replace_everywhere(text)
replace confirm that user.replace_confirm()
replace confirm all user.replace_confirm_all()
clear last <user.text> [over] user.select_previous_occurrence(text) sleep(100ms) edit.delete()
clear next <user.text> [over] user.select_next_occurrence(text) sleep(100ms) edit.delete()
clear last clip user.select_previous_occurrence(clip.text()) edit.delete()
clear next clip user.select_next_occurrence(clip.text()) sleep(100ms) edit.delete()
comment last <user.text> [over] user.select_previous_occurrence(text) sleep(100ms) code.toggle_comment()
comment last clip user.select_previous_occurrence(clip.text()) sleep(100ms) code.toggle_comment()
comment next <user.text> [over] user.select_next_occurrence(text) sleep(100ms) code.toggle_comment()
comment next clip user.select_next_occurrence(clip.text()) sleep(100ms) code.toggle_comment()
go last <user.text> [over] user.select_previous_occurrence(text) sleep(100ms) edit.right()
go last clip user.select_previous_occurrence(clip.text()) sleep(100ms) edit.right()
go next <user.text> [over] user.select_next_occurrence(text) edit.right()
go next clip user.select_next_occurrence(clip.text()) edit.right()
paste last <user.text> [over] user.select_previous_occurrence(text) sleep(100ms) edit.right() edit.paste()
paste next <user.text> [over] user.select_next_occurrence(text) sleep(100ms) edit.right() edit.paste()
replace last <user.text> [over] user.select_previous_occurrence(text) sleep(100ms) edit.paste()
replace next <user.text> [over] user.select_next_occurrence(text) sleep(100ms) edit.paste()
select last <user.text> [over] user.select_previous_occurrence(text)
select next <user.text> [over] user.select_next_occurrence(text)
select last clip user.select_previous_occurrence(clip.text())
select next clip user.select_next_occurrence(clip.text())

chapters

chapter next user.chapter_next()
chapter last user.chapter_previous()
go chapter user.chapter_jump(number)
go chapter final user.chapter_final()

emoji

emoticon {user.emoticon} "{emoticon}"
emoji {user.emoji} user.paste(emoji)
kaomoji {user.kaomoji} user.paste(kaomoji)

unix utilities

core {user.unix_utility} "{unix_utility} "

terminal

lisa user.terminal_list_directories()
lisa all user.terminal_list_all_directories()
katie [dir] [<user.text>] user.terminal_change_directory(text or "")
katie root user.terminal_change_directory_root()
katie (up | back) user.terminal_change_directory("..")
go <user.system_path> insert('cd "{system_path}"\n')
path <user.system_path> insert('"{system_path}"')
clear screen user.terminal_clear_screen()
run last user.terminal_run_last()
rerun [<user.text>] user.terminal_rerun_search(text or "")
rerun search user.terminal_rerun_search("")
kill all user.terminal_kill_all()
copy paste edit.copy() sleep(50ms) edit.paste()

browser

address bar | go address | go url browser.focus_address()
go page | page focus browser.focus_page()
address copy | url copy | copy address | copy url browser.focus_address() sleep(50ms) edit.copy()
go home browser.go_home()
[go] forward browser.go_forward()
go (back | backward) browser.go_back()
go to {user.website} browser.go(website)
go private browser.open_private_window()
bookmark it browser.bookmark()
bookmark tabs browser.bookmark_tabs()
(refresh | reload) it browser.reload()
(refresh | reload) it hard browser.reload_hard()
bookmark show browser.bookmarks()
bookmark bar [show] browser.bookmarks_bar()
downloads show browser.show_downloads()
extensions show browser.show_extensions()
history show browser.show_history()
cache show browser.show_clear_cache()
dev tools [show] browser.toggle_dev_tools()
show downloads browser.show_downloads()
show extensions browser.show_extensions()
show history browser.show_history()
show cache browser.show_clear_cache()

file manager

title force user.file_manager_refresh_title()
manager show user.file_manager_toggle_pickers()
manager close user.file_manager_hide_pickers()
manager refresh user.file_manager_update_lists()
go <user.system_path> user.file_manager_open_directory(system_path)
go back user.file_manager_go_back()
go forward user.file_manager_go_forward()
(go parent | daddy) user.file_manager_open_parent()
follow numb <number_small> directory = user.file_manager_get_directory_by_index(number_small - 1) user.file_manager_open_directory(directory)
follow {user.file_manager_directories} user.file_manager_open_directory(file_manager_directories)
(select | cell) folder {user.file_manager_directories} user.file_manager_select_directory(file_manager_directories)
open <number_small> file = user.file_manager_get_file_by_index(number_small - 1) user.file_manager_open_file(file)
folder numb <number_small> directory = user.file_manager_get_directory_by_index(number_small - 1) user.file_manager_select_directory(directory)
file numb <number_small> file = user.file_manager_get_file_by_index(number_small - 1) user.file_manager_select_file(file)
file {user.file_manager_files} user.file_manager_select_file(file_manager_files)
(select | cell) file {user.file_manager_files} `user.file_manager_select_file(file_manager_files)
```
 #new folder`
```
folder new <user.text> user.file_manager_new_folder(text)
properties show user.file_manager_show_properties()
terminal here user.file_manager_terminal_here()
folder next user.file_manager_next_folder_page()
folder last user.file_manager_previous_folder_page()
file next user.file_manager_next_file_page()
file last user.file_manager_previous_file_page()

debugger

step into user.debugger_step_into()
step over user.debugger_step_over()
step line user.debugger_step_line()
step over line user.debugger_step_over_line()
step out user.debugger_step_out()
continue user.debugger_continue()
debug start user.debugger_start()
debug stop user.debugger_stop()
debug exit user.debugger_exit()
debug detach user.debugger_detach()
debug restart user.debugger_restart()
show registers user.debugger_show_registers()
get register user.debugger_get_register()
set register user.debugger_set_register()
break now user.debugger_break_now()
break here user.debugger_break_here()
(list | show) (breaks | break points) user.debugger_show_breakpoints()
(set | add) (break | break point) user.debugger_add_sw_breakpoint()
(set | add) hardware (break | break point) user.debugger_add_hw_breakpoint()
clear all (breaks | break points) user.debugger_clear_all_breakpoints()
clear (break | break point) user.debugger_clear_breakpoint()
clear (break | break point) <number_small> user.debugger_clear_breakpoint_id(number_small)
disable all (breaks | break points) user.debugger_disable_all_breakpoints()
disable (break | break point) user.debugger_disable_breakpoint()
disable (break | break point) <number_small> user.debugger_disable_breakpoint_id(number_small)
enable all (breaks | break points) user.debugger_enable_all_breakpoints()
enable (break | break point) user.debugger_enable_breakpoint()
enable (break | break point) <number_small> `user.debugger_enable_breakpoint_id(number_small)
```
 # Navigation
 
 # Memory Inspection`
```
(stack | back) trace user.debugger_backtrace()
disassemble user.debugger_disassemble()
disassemble here user.debugger_disassemble_here()
disassemble clipboard user.debugger_disassemble_clipboard()
jump to address user.debugger_goto_address()
jump to clipboard user.debugger_goto_clipboard()
jump to highlighted user.debugger_goto_highlighted()
dump string user.debugger_dump_ascii_string()
dump unicode [string] user.debugger_dump_unicode_string()
dump pointers user.debugger_dump_pointers()
list modules user.debugger_list_modules()
inspect type user.debugger_inspect_type()
clear line user.debugger_clear_line()

multiple cursors

cursor multiple user.multi_cursor_enable()
cursor stop user.multi_cursor_disable()
cursor up user.multi_cursor_add_above()
cursor down user.multi_cursor_add_below()
cursor less user.multi_cursor_select_fewer_occurrences()
cursor more user.multi_cursor_select_more_occurrences()
cursor skip user.multi_cursor_skip_occurrence()
cursor all user.multi_cursor_select_all_occurrences()
cursor lines user.multi_cursor_add_to_line_ends()

pages

page next user.page_next()
page last user.page_previous()
go page user.page_jump(number)
go page final user.page_final()

messaging

previous (workspace | server) user.messaging_workspace_previous()
next (workspace | server) user.messaging_workspace_next()
channel user.messaging_open_channel_picker()
channel <user.text> user.messaging_open_channel_picker() insert(user.formatted_text(user.text, "ALL_LOWERCASE"))
channel up user.messaging_channel_previous()
channel down user.messaging_channel_next()
([channel] unread last | gopreev) user.messaging_unread_previous()
([channel] unread next | goneck) user.messaging_unread_next()
go (find | search) user.messaging_open_search()
mark (all | workspace | server) read user.messaging_mark_workspace_read()
mark channel read user.messaging_mark_channel_read()
upload file user.messaging_upload_file()

splits

split right user.split_window_right()
split left user.split_window_left()
split down user.split_window_down()
split up user.split_window_up()
split (vertically | vertical) user.split_window_vertically()
split (horizontally | horizontal) user.split_window_horizontally()
split flip user.split_flip()
split max user.split_maximize()
split reset user.split_reset()
split window user.split_window()
split clear user.split_clear()
split clear all user.split_clear_all()
split next user.split_next()
split last user.split_last()
go split user.split_number(number)

c

state include insert("#include ")
state include system user.insert_between("#include <", ">")
state include local user.insert_between('#include "', '"')
state type deaf insert("typedef ")
state type deaf struct `insert("typedef struct") insert("{\n\n}") edit.up() key('tab')
```
 # XXX - create a preprocessor tag for these, as they will match cpp, etc`
```
state define "#define "
state (undefine | undeaf) "#undef "
state if (define | deaf) "#ifdef "
[state] define <user.text> "#define {user.formatted_text(text, 'ALL_CAPS,SNAKE_CASE')}"
[state] (undefine | undeaf) <user.text> "#undef {user.formatted_text(text, 'ALL_CAPS,SNAKE_CASE')}"
[state] if (define | deaf) <user.text> `"#ifdef {user.formatted_text(text, 'ALL_CAPS,SNAKE_CASE')}"
```
 # XXX - preprocessor instead of pre?`
```
state pre if "#if "
state error "#error "
state pre else if "#elif "
state pre end "#endif "
state pragma "#pragma "
state default "default:\nbreak;"
push brackets `edit.line_end() #insert("{") #key(enter) insert("{}") edit.left() key(enter) key(enter) edit.up()
```
 # Declare variables or structs etc.
 # Ex. * int myList`
```
<user.c_variable> insert("{c_variable} ") insert(user.formatted_text(phrase, "PRIVATE_CAMEL_CASE,NO_SPACES"))
<user.c_variable> <user.letter> insert("{c_variable} {letter} ")
cast to <user.c_cast> "{c_cast}"
standard cast to <user.stdint_cast> "{stdint_cast}"
<user.c_types> "{c_types}"
<user.c_pointers> "{c_pointers}"
<user.c_keywords> "{c_keywords}"
<user.c_signed> "{c_signed}"
standard <user.stdint_types> "{stdint_types}"
int main user.insert_between("int main(", ")")
toggle includes user.code_toggle_libraries()
include <user.code_libraries> user.code_insert_library(code_libraries, "") key(end enter)

javascript

(op | is) strict equal " === "
(op | is) strict not equal " !== "
op null else " ?? "
state const "const "
state let "let "
state var "var "
state export "export "
state async "async "
state await "await "
dot {user.code_common_member_function} user.insert_between(".{code_common_member_function}(", ")")
state map app.notify('ERROR: Command deprecated; please use "dot map"')
state filter app.notify('ERROR: Command deprecated; please use "dot filter"')
state reduce app.notify('ERROR: Command deprecated; please use "dot reduce"')
state spread "..."
from import user.insert_between(' from "', '"')

r

(op | is) in " %in% "
toggle library user.code_toggle_libraries()
library <user.code_libraries> `user.code_insert_library(code_libraries, "") key(end enter)
```
 # R specific commands`
```
(chain | pipe that) key(end) " %>%" key(enter)
state na insert("NA")
function define <user.text> user.code_private_function(text)
named arg {user.code_parameter_name} user.code_insert_named_argument(code_parameter_name)

talon

dot talon insert(".talon")
action block user.insert_between("action(", "):")
setting block insert("settings():\n\t")
setting {user.talon_settings} user.paste("{talon_settings} = ")
win require insert("os: windows\n")
mac require insert("os: mac\n")
linux require insert("os: linux\n")
title require insert("win.title: ")
application [require] [{user.talon_apps}] app = talon_apps or "" user.paste("app: {app}")
mode require [{user.talon_modes}] mode = talon_modes or "" user.paste("mode: {mode}")
tag require [{user.talon_tags}] tag = talon_tags or "" user.paste("tag: {tag}")
tag set [{user.talon_tags}] tag = talon_tags or "" user.paste("tag(): {tag}")
host require hostname = user.talon_get_hostname() user.paste("hostname: {hostname}\n") # requires user.talon_populate_lists tag. do not use with dragon
list {user.talon_lists} "{{{talon_lists}}}"
capture {user.talon_captures} "<{talon_captures}>"
key <user.keys> over "{keys}"
key <user.modifiers> over "{modifiers}"
funk {user.talon_actions} user.code_insert_function(talon_actions, edit.selected_text())
funk cell user.code_select_function(number - 1, "")
funk wrap <user.code_common_function> user.code_insert_function(code_common_function, edit.selected_text())
funk wrap user.code_select_function(number - 1, edit.selected_text())

vscode

window reload user.vscode("workbench.action.reloadWindow")
window close user.vscode("workbench.action.closeWindow")
please [<user.text>] `user.vscode("workbench.action.showCommands") insert(user.text or "")
```
 # Sidebar`
```
bar explore user.vscode("workbench.view.explorer")
bar extensions user.vscode("workbench.view.extensions")
bar outline user.vscode("outline.focus")
bar run user.vscode("workbench.view.debug")
bar search user.vscode("workbench.view.search")
bar source user.vscode("workbench.view.scm")
bar test user.vscode("workbench.view.testing.focus")
bar switch user.vscode("workbench.action.toggleSidebarVisibility")
symbol hunt [<user.text>] user.vscode("workbench.action.gotoSymbol") sleep(50ms) insert(text or "")
symbol hunt all [<user.text>] `user.vscode("workbench.action.showAllSymbols") sleep(50ms) insert(text or "")
```
 # Panels`
```
panel control user.vscode("workbench.panel.repl.view.focus")
panel output user.vscode("workbench.panel.output.focus")
panel problems user.vscode("workbench.panel.markers.view.focus")
panel switch user.vscode("workbench.action.togglePanel")
panel terminal user.vscode("workbench.action.terminal.focus")
focus editor user.vscode("workbench.action.focusActiveEditorGroup")
show settings user.vscode("workbench.action.openGlobalSettings")
show settings json user.vscode("workbench.action.openSettingsJson")
show settings folder user.vscode("workbench.action.openFolderSettings")
show settings folder json user.vscode("workbench.action.openFolderSettingsFile")
show settings workspace user.vscode("workbench.action.openWorkspaceSettings")
show settings workspace json user.vscode("workbench.action.openWorkspaceSettingsFile")
show shortcuts user.vscode("workbench.action.openGlobalKeybindings")
show shortcuts json user.vscode("workbench.action.openGlobalKeybindingsFile")
show snippets user.vscode("workbench.action.openSnippets")
centered switch user.vscode("workbench.action.toggleCenteredLayout")
fullscreen switch user.vscode("workbench.action.toggleFullScreen")
theme switch user.vscode("workbench.action.selectTheme")
wrap switch user.vscode("editor.action.toggleWordWrap")
zen switch user.vscode("workbench.action.toggleZenMode")
file hunt [<user.text>] user.vscode("workbench.action.quickOpen") sleep(50ms) insert(text or "")
file hunt (pace | paste) user.vscode("workbench.action.quickOpen") sleep(50ms) edit.paste()
file copy name user.vscode("fileutils.copyFileName")
file copy path user.vscode("copyFilePath")
file copy local [path] user.vscode("copyRelativeFilePath")
file create sibling user.vscode_and_wait("explorer.newFile")
file create user.vscode("workbench.action.files.newUntitledFile")
file create relative user.vscode("fileutils.newFile")
file create root user.vscode("fileutils.newFileAtRoot")
file rename user.vscode("fileutils.renameFile") sleep(150ms)
file move user.vscode("fileutils.moveFile") sleep(150ms)
file clone user.vscode("fileutils.duplicateFile") sleep(150ms)
file delete user.vscode("fileutils.removeFile") sleep(150ms)
file open folder user.vscode("revealFileInOS")
file reveal user.vscode("workbench.files.action.showActiveFileInExplorer")
save ugly user.vscode("workbench.action.files.saveWithoutFormatting")
suggest show user.vscode("editor.action.triggerSuggest")
hint show user.vscode("editor.action.triggerParameterHints")
definition show user.vscode("editor.action.revealDefinition")
definition peek user.vscode("editor.action.peekDefinition")
definition side user.vscode("editor.action.revealDefinitionAside")
references show user.vscode("editor.action.goToReferences")
hierarchy peek user.vscode("editor.showCallHierarchy")
references find user.vscode("references-view.find")
format that user.vscode("editor.action.formatDocument")
format selection user.vscode("editor.action.formatSelection")
imports fix user.vscode("editor.action.organizeImports")
problem next user.vscode("editor.action.marker.nextInFiles")
problem last user.vscode("editor.action.marker.prevInFiles")
problem fix user.vscode("problems.action.showQuickFixes")
rename that user.vscode("editor.action.rename")
refactor that user.vscode("editor.action.refactor")
whitespace trim user.vscode("editor.action.trimTrailingWhitespace")
language switch user.vscode("workbench.action.editor.changeLanguageMode")
refactor rename user.vscode("editor.action.rename")
refactor this user.vscode("editor.action.refactor")
(go declaration | follow) user.vscode("editor.action.revealDefinition")
go back user.vscode("workbench.action.navigateBack")
go forward user.vscode("workbench.action.navigateForward")
go implementation user.vscode("editor.action.goToImplementation")
go type user.vscode("editor.action.goToTypeDefinition")
go usage user.vscode("references-view.find")
go recent [<user.text>] user.vscode("workbench.action.openRecent") sleep(50ms) insert(text or "") sleep(250ms)
go edit user.vscode("workbench.action.navigateToLastEditLocation")
bar marks user.vscode("workbench.view.extension.bookmarks")
go marks user.deprecate_command("2023-06-06", "go marks", "bar marks") user.vscode("workbench.view.extension.bookmarks")
toggle mark user.vscode("bookmarks.toggle")
go next mark user.vscode("bookmarks.jumpToNext")
go last mark user.vscode("bookmarks.jumpToPrevious")
close other tabs user.vscode("workbench.action.closeOtherEditors")
close all tabs user.vscode("workbench.action.closeAllEditors")
close tabs way right user.vscode("workbench.action.closeEditorsToTheRight")
close tabs way left user.vscode("workbench.action.closeEditorsToTheLeft")
fold that user.vscode("editor.fold")
unfold that user.vscode("editor.unfold")
fold those user.vscode("editor.foldAllMarkerRegions")
unfold those user.vscode("editor.unfoldRecursively")
fold all user.vscode("editor.foldAll")
unfold all user.vscode("editor.unfoldAll")
fold comments user.vscode("editor.foldAllBlockComments")
fold one user.vscode("editor.foldLevel1")
fold two user.vscode("editor.foldLevel2")
fold three user.vscode("editor.foldLevel3")
fold four user.vscode("editor.foldLevel4")
fold five user.vscode("editor.foldLevel5")
fold six user.vscode("editor.foldLevel6")
fold seven user.vscode("editor.foldLevel7")
git branch user.vscode("git.branchFrom")
git branch this user.vscode("git.branch")
git checkout [<user.text>] user.vscode("git.checkout") sleep(50ms) insert(text or "")
git commit [<user.text>] user.vscode("git.commitStaged") sleep(100ms) user.insert_formatted(text or "", "CAPITALIZE_FIRST_WORD")
git commit undo user.vscode("git.undoCommit")
git commit amend user.vscode("git.commitStagedAmend")
git diff user.vscode("git.openChange")
git fetch user.vscode("git.fetch")
git fetch all user.vscode("git.fetchAll")
git ignore user.vscode("git.ignore")
git merge user.vscode("git.merge")
git output user.vscode("git.showOutput")
git pull user.vscode("git.pullRebase")
git push user.vscode("git.push")
git push focus user.vscode("git.pushForce")
git rebase abort user.vscode("git.rebaseAbort")
git reveal user.vscode("git.revealInExplorer")
git revert user.vscode("git.revertChange")
git stash user.vscode("git.stash")
git stash pop user.vscode("git.stashPop")
git status user.vscode("workbench.scm.focus")
git stage user.vscode("git.stage")
git stage all user.vscode("git.stageAll")
git sync user.vscode("git.sync")
git unstage user.vscode("git.unstage")
git unstage all user.vscode("git.unstageAll")
pull request user.vscode("pr.create")
change next key(alt-f5)
change last key(shift-alt-f5)
test run user.vscode("testing.runAtCursor")
test run file user.vscode("testing.runCurrentFile")
test run all user.vscode("testing.runAll")
test run failed user.vscode("testing.reRunFailTests")
test run last user.vscode("testing.reRunLastRun")
test debug user.vscode("testing.debugAtCursor")
test debug file user.vscode("testing.debugCurrentFile")
test debug all user.vscode("testing.debugAll")
test debug failed user.vscode("testing.debugFailTests")
test debug last user.vscode("testing.debugLastRun")
test cancel user.vscode("testing.cancelRun")
break point user.vscode("editor.debug.action.toggleBreakpoint")
step over user.vscode("workbench.action.debug.stepOver")
debug step into user.vscode("workbench.action.debug.stepInto")
debug step out [of] user.vscode("workbench.action.debug.stepOut")
debug start user.vscode("workbench.action.debug.start")
debug pause user.vscode("workbench.action.debug.pause")
debug stopper user.vscode("workbench.action.debug.stop")
debug continue user.vscode("workbench.action.debug.continue")
debug restart user.vscode("workbench.action.debug.restart")
debug console user.vscode("workbench.debug.action.toggleRepl")
debug clean user.vscode("workbench.debug.panel.action.clearReplAction")
terminal external user.vscode("workbench.action.terminal.openNativeConsole")
terminal new user.vscode("workbench.action.terminal.new")
terminal next user.vscode("workbench.action.terminal.focusNext")
terminal last user.vscode("workbench.action.terminal.focusPrevious")
terminal split user.vscode("workbench.action.terminal.split")
terminal zoom user.vscode("workbench.action.toggleMaximizedPanel")
terminal trash user.vscode("workbench.action.terminal.kill")
terminal toggle user.vscode_and_wait("workbench.action.terminal.toggleTerminal")
terminal scroll up user.vscode("workbench.action.terminal.scrollUp")
terminal scroll down user.vscode("workbench.action.terminal.scrollDown")
terminal <number_small> user.vscode_terminal(number_small)
copy line down user.vscode("editor.action.copyLinesDownAction")
copy line up user.vscode("editor.action.copyLinesUpAction")
select less user.vscode("editor.action.smartSelect.shrink")
select (more | this) user.vscode("editor.action.smartSelect.expand")
minimap user.vscode("editor.action.toggleMinimap")
maximize user.vscode("workbench.action.minimizeOtherEditors")
restore user.vscode("workbench.action.evenEditorWidths")
select breadcrumb user.vscode("breadcrumbs.focusAndSelect")
replace here user.replace("") key(cmd-alt-l)
hover show user.vscode("editor.action.showHover")
join lines user.vscode("editor.action.joinLines")
full screen user.vscode("workbench.action.toggleFullScreen")
curse undo user.vscode("cursorUndo")
select word user.vscode("editor.action.addSelectionToNextFindMatch")
skip word user.vscode("editor.action.moveSelectionToNextFindMatch")
cell next user.vscode("notebook.focusNextEditor")
cell last user.vscode("notebook.focusPreviousEditor")
cell run above user.vscode("notebook.cell.executeCellsAbove")
cell run user.vscode("notebook.cell.execute")
install local user.vscode("workbench.extensions.action.installVSIX")
preview markdown user.vscode("markdown.showPreview")

jetbrains

complete user.idea("action CodeCompletion")
perfect user.idea("action CodeCompletion,action CodeCompletion")
smart user.idea("action SmartTypeCompletion")
(done | finish) user.idea("action EditorCompleteStatement")
grab user.idea_grab(number)
(action | please) user.idea("action GotoAction")
(action | please) <user.text> user.idea("action GotoAction") insert(text) # Refactoring
refactor user.idea("action Refactorings.QuickListPopupAction")
refactor <user.text> user.idea("action Refactorings.QuickListPopupAction") insert(text)
extract variable user.idea("action IntroduceVariable")
extract field user.idea("action IntroduceField")
extract constant user.idea("action IntroduceConstant")
extract parameter user.idea("action IntroduceParameter")
extract interface user.idea("action ExtractInterface")
extract method user.idea("action ExtractMethod")
refactor in line user.idea("action Inline")
refactor move user.idea("action Move")
refactor rename user.idea("action RenameElement")
rename file user.idea("action RenameFile")
fix (format | formatting) user.idea("action ReformatCode")
fix imports user.idea("action OptimizeImports")
(go declaration | follow) user.idea("action GotoDeclaration")
go implementation user.idea("action GotoImplementation")
go usage user.idea("action FindUsages")
go type user.idea("action GotoTypeDeclaration")
go test user.idea("action GotoTest")
go back user.idea("action Back")
go forward user.idea("action Forward")
find (everywhere | all) user.idea("action SearchEverywhere")
find (everywhere | all) <user.text> [over] user.idea("action SearchEverywhere") sleep(500ms) insert(text)
(search | find) class user.idea("action GotoClass")
(search | find) file user.idea("action GotoFile")
(search | find) path user.idea("action FindInPath")
(search | find) symbol user.idea("action GotoSymbol")
(search | find) symbol <user.text> user.idea("action GotoSymbol") insert(text) key("enter")
recent user.idea("action RecentFiles")
surround [this] with <user.text> [over] idea("action SurroundWith") sleep(500ms) insert(text) # Making these longer to reduce collisions with real code dictation.
insert generated <user.text> [over] user.idea("action Generate") sleep(500ms) insert(text)
insert template <user.text> [over] idea("action InsertLiveTemplate") sleep(500ms) insert(text)
create (template | snippet) user.idea("action SaveAsTemplate")
toggle recording user.idea("action StartStopMacroRecording")
change (recording | recordings) user.idea("action EditMacros")
play recording user.idea("action PlaybackLastMacro")
play recording <user.text> [over] idea("action PlaySavedMacrosAction") insert(text) sleep(500ms) Key("enter") # Marks
go mark user.idea("action ShowBookmarks")
toggle mark user.idea("action ToggleBookmark")
go next mark user.idea("action GotoNextBookmark")
go last mark user.idea("action GotoPreviousBookmark")
toggle mark user.idea("action ToggleBookmark{number}")
go mark user.idea("action GotoBookmark{number}")
expand deep user.idea("action ExpandRegionRecursively")
expand all user.idea("action ExpandAllRegions")
collapse deep user.idea("action CollapseRegionRecursively")
collapse all user.idea("action CollapseAllRegions")
go next (method | function) user.idea("action MethodDown")
go last (method | function) user.idea("action MethodUp")
clippings user.idea("action PasteMultiple")
copy path user.idea("action CopyPaths")
copy reference user.idea("action CopyReference")
copy pretty user.idea("action CopyAsRichText")
create sibling user.idea("action NewElementSamePlace")
create sibling <user.text> [over] user.idea("action NewElementSamePlace") sleep(500ms) insert(text)
create file user.idea("action NewElement")
create file <user.text> [over] user.idea("action NewElement") sleep(500ms) insert(text) # Task Management
go task user.idea("action tasks.goto")
go browser task user.idea("action tasks.open.in.browser")
switch task user.idea("action tasks.switch")
clear task user.idea("action tasks.close")
configure servers user.idea("action tasks.configure.servers")
git pull user.idea("action Vcs.UpdateProject")
git commit user.idea("action CheckinProject")
git push user.idea("action CheckinProject")
git log user.idea("action Vcs.ShowTabbedFileHistory")
git browse user.idea("action Github.Open.In.Browser")
git (gets | gist) user.idea("action Github.Create.Gist")
git (pull request | request) user.idea("action Github.Create.Pull.Request")
git (view | show | list) (requests | request) user.idea("action Github.View.Pull.Request")
git (annotate | blame) user.idea("action Annotate")
git menu user.idea("action Vcs.QuickListPopupAction")
toggle project user.idea("action ActivateProjectToolWindow")
toggle find user.idea("action ActivateFindToolWindow")
toggle run user.idea("action ActivateRunToolWindow")
toggle debug user.idea("action ActivateDebugToolWindow")
toggle events user.idea("action ActivateEventLogToolWindow")
toggle terminal user.idea("action ActivateTerminalToolWindow")
toggle git user.idea("action ActivateVersionControlToolWindow")
toggle structure user.idea("action ActivateStructureToolWindow")
toggle database user.idea("action ActivateDatabaseToolWindow")
toggle database changes user.idea("action ActivateDatabaseChangesToolWindow")
toggle make user.idea("action ActivatemakeToolWindow")
toggle to do user.idea("action ActivateTODOToolWindow")
toggle docker user.idea("action ActivateDockerToolWindow")
toggle favorites user.idea("action ActivateFavoritesToolWindow")
toggle last user.idea("action JumpToLastWindow")
toggle pinned user.idea("action TogglePinnedMode")
toggle docked user.idea("action ToggleDockMode")
toggle floating user.idea("action ToggleFloatingMode")
toggle windowed user.idea("action ToggleWindowedMode")
toggle split user.idea("action ToggleSideMode")
toggle tool buttons user.idea("action ViewToolButtons")
toggle toolbar user.idea("action ViewToolBar")
toggle status [bar] user.idea("action ViewStatusBar")
toggle navigation [bar] user.idea("action ViewNavigationBar")
toggle power save user.idea("action TogglePowerSave")
toggle whitespace user.idea("action EditorToggleShowWhitespaces")
toggle indents user.idea("action EditorToggleShowIndentLines")
toggle line numbers user.idea("action EditorToggleShowLineNumbers")
toggle (bread crumbs | breadcrumbs) user.idea("action EditorToggleShowBreadcrumbs")
toggle gutter icons user.idea("action EditorToggleShowGutterIcons")
toggle wrap user.idea("action EditorToggleUseSoftWraps")
toggle parameters user.idea("action ToggleInlineHintsAction")
toggle fullscreen user.idea("action ToggleFullScreen")
toggle distraction [free mode] user.idea("action ToggleDistractionFreeMode")
toggle presentation [mode] user.idea("action TogglePresentationMode")
toggle comment code.toggle_comment()
change scheme user.idea("action QuickChangeScheme")
(toggle | pop) (doc | documentation) user.idea("action QuickJavaDoc")
(pop deaf | toggle definition) user.idea("action QuickImplementations")
pop type user.idea("action ExpressionTypeInfo")
pop parameters user.idea("action ParameterInfo")
go breakpoints user.idea("action ViewBreakpoints")
toggle [line] breakpoint user.idea("action ToggleLineBreakpoint")
toggle method breakpoint user.idea("action ToggleMethodBreakpoint")
run menu user.idea("action ChooseRunConfiguration")
run test user.idea("action RunClass")
run test again user.idea("action Rerun")
debug test user.idea("action DebugClass")
step over user.idea("action StepOver")
step into user.idea("action StepInto")
step smart user.idea("action SmartStepInto")
step to line user.idea("action RunToCursor")
continue user.idea("action Resume")
(grow | shrink) window right user.idea("action ResizeToolWindowRight")
(grow | shrink) window left user.idea("action ResizeToolWindowLeft")
(grow | shrink) window up user.idea("action ResizeToolWindowUp")
(grow | shrink) window down user.idea("action ResizeToolWindowDown")
go next (error | air) user.idea("action GotoNextError")
go last (error | air) user.idea("action GotoPreviousError")
fix next (error | air) user.idea("action GotoNextError") user.idea("action ShowIntentionActions")
fix last (error | air) user.idea("action GotoPreviousError") user.idea("action ShowIntentionActions") # Special Selects
select less user.idea("action EditorUnSelectWord")
select (more | this) user.idea("action EditorSelectWord")
expand until user.select_range(number_1, number_2) user.idea("action ExpandRegion")
collapse until user.select_range(number_1, number_2) user.idea("action CollapseRegion")
paste until user.select_range(number_1, number_2) user.idea("action EditorPaste")
refactor until user.select_range(number_1, number_2) user.idea("action Refactorings.QuickListPopupAction")
clone user.line_clone(number)
clear last <user.text> [over] user.idea("find prev {text}, action EditorBackSpace")
clear next <user.text> [over] user.idea("find next {text}, action EditorBackSpace")
comment last <user.text> [over] user.idea("find prev {text}, action CommentByLineComment")
comment next <user.text> [over] user.idea("find next {text}, action CommentByLineComment")
go last <user.text> [over] user.idea("find prev {text}, action EditorRight")
go next <user.text> [over] user.idea("find next {text}, action EditorRight")
paste last <user.text> [over] user.idea("find prev {text}, action EditorRight, action EditorPaste")
paste next <user.text> [over] user.idea("find next {text}, action EditorRight, action EditorPaste")
refactor last <user.text> [over] user.idea("find prev {text}, action Refactorings.QuickListPopupAction")
refactor next <user.text> [over] user.idea("find next {text}, action Refactorings.QuickListPopupAction")
replace last <user.text> [over] user.idea("find prev {text}, action EditorPaste")
replace next <user.text> [over] user.idea("find next {text}, action EditorPaste")
select last <user.text> [over] user.idea("find prev {text}")
select next <user.text> [over] user.idea("find next {text}")
select camel left user.extend_camel_left()
select camel right user.extend_camel_right()
go camel left user.camel_left()
go camel right user.camel_right()
blacken user.idea("action BLACKReformatCode")

python

dunder in it "__init__"
state (def | deaf | deft) "def "
state try "try:\n"
state except "except "
state raise "raise "
self taught "self."
pie test "pytest"
state past "pass"
[state] raise {user.python_exception} user.insert_between("raise {python_exception}(", ")")
[state] except {user.python_exception} "except {python_exception}:"
dock string user.code_comment_documentation()
dock {user.python_docstring_fields} insert("{python_docstring_fields}") edit.left()
dock type {user.code_type} user.insert_between(":type ", ": {code_type}")
dock returns type {user.code_type} user.insert_between(":rtype ", ": {code_type}")
toggle imports user.code_toggle_libraries()
import <user.code_libraries> user.code_insert_library(code_libraries, "") key(end enter)
from import user.insert_between("from ", " import ")

anaconda

anaconda "conda "
anaconda help "conda --help\n"
anaconda version "conda --version\n"
anaconda environment list "conda env list\n"
anaconda environment create "conda env create -f "
anaconda environment remove "conda env remove -n "
anaconda activate "conda activate "
anaconda clean "conda clean "
anaconda compare "conda compare "
anaconda config "conda config "
anaconda create "conda create "
anaconda info "conda info "
anaconda init "conda init "
anaconda install "conda install "
anaconda list "conda list "
anaconda package "conda package "
anaconda remove "conda remove "
anaconda uninstall "conda uninstall "
anaconda run "conda run "
anaconda search "conda search "
anaconda update "conda update "
anaconda upgrade "conda upgrade "
anaconda build "conda build "
anaconda convert "conda convert "
anaconda debug "conda debug "
anaconda develop "conda develop "
anaconda environment "conda env "
anaconda index "conda index "
anaconda inspect "conda inspect "
anaconda metapackage "conda metapackage "
anaconda render "conda render "
anaconda server "conda server "
anaconda skeleton "conda skeleton "
anaconda verify "conda verify "

ruby

args pipe user.insert_between("|", "|")
dock string user.code_comment_documentation()
state end "end"
state begin "begin"
state rescue "rescue "
state module "module "
instance <user.text> insert("@") user.code_public_variable_formatter(text)

rust

state unsafe "unsafe "
unsafe block user.code_state_unsafe()
state (struct | structure) <user.text> insert("struct ") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
state enum <user.text> insert("enum ") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
toggle use user.code_toggle_libraries()
borrow "&"
borrow mutable "&mut "
state (a sink | async | asynchronous) "async "
state (pub | public) "pub "
state (pub | public) crate "pub(crate) "
state (dyn | dynamic) "dyn "
state constant "const "
state (funk | func | function) "fn "
state (imp | implements) "impl "
state let mute "let mut "
state let "let "
state (mute | mutable) "mut "
state (mod | module) "mod "
state ref (mute | mutable) "ref mut "
state ref "ref "
state trait "trait "
state match user.code_state_switch()
state (some | sum) "Some"
state static "static "
self taught "self."
state use user.code_import()
use <user.code_libraries> `user.code_insert_library(code_libraries, "") key(; enter)
```
 ## specialist flow control`
```
state if let some user.code_insert_if_let_some()
state if let (ok | okay) user.code_insert_if_let_okay()
state if let error user.code_insert_if_let_error()
is some user.code_insert_is_not_null()
implement (struct | structure) user.code_state_implements()
is implemented trait {user.code_trait} user.code_insert_trait_annotation(code_trait)
is implemented trait ": impl "
returns implemented trait {user.code_trait} user.code_insert_return_trait(code_trait)
returns implemented trait " -> impl "
trait {user.code_trait} insert("{code_trait}")
implemented trait {user.code_trait} insert("impl {code_trait}")
dynamic trait {user.code_trait} insert("dyn {code_trait}")
macro {user.code_macros} user.code_insert_macro(code_macros, "")
macro wrap {user.code_macros} `user.code_insert_macro(code_macros, edit.selected_text())
```
 ## rust specific document comments`
```
block dock comment user.code_comment_documentation_block()
inner dock comment user.code_comment_documentation_inner()
inner block dock comment user.code_comment_documentation_block_inner()

terraform

state {user.terraform_module_block} user.code_terraform_module_block(user.terraform_module_block)
resource <user.text> user.code_terraform_resource(text)
data [source] <user.text> user.code_terraform_data_source(text)
[state] prop {user.terraform_common_property} insert(user.terraform_common_property) user.code_operator_assignment()
type {user.code_type} insert("{code_type}")

java

state var "var "
boxed [type] {user.java_boxed_type} insert(user.java_boxed_type + " ")
generic [type] {user.java_generic_data_structure} `user.insert_between(java_generic_data_structure + "<", ">")
```
 # Arrays`
```
type {user.code_type} array insert(user.code_type) user.code_operator_subscript()
[state] {user.java_modifier} insert(user.java_modifier + " ")
op array user.code_operator_subscript()
op new insert("new ")

i3wm

port <number_small> user.i3wm_switch_to_workspace(number_small)
(port flip | flipper) user.i3wm_switch_to_workspace("back_and_forth")
port right user.i3wm_switch_to_workspace("next")
port left user.i3wm_switch_to_workspace("prev")
(win | window) left user.i3wm_focus("left")
(win | window) right user.i3wm_focus("right")
(win | window) up user.i3wm_focus("up")
(win | window) down user.i3wm_focus("down")
(win | window) kill app.window_close()
(win | window) stacking user.i3wm_layout("stacking")
(win | window) default user.i3wm_layout()
(win | window) tabbed user.i3wm_layout("tabbed")
reload i three config user.i3wm_reload()
restart i three user.i3wm_restart()
(full screen | scuba) user.i3wm_fullscreen()
toggle floating user.i3wm_float()
focus floating user.i3wm_focus("mode_toggle")
center window user.i3wm_move_position("center")
resize mode user.i3wm_mode("resize")
focus parent user.i3wm_focus("parent")
focus child user.i3wm_focus("child")
grow window `user.i3wm_mode("resize") key(right:10) key(down:10) # escape resize mode key(escape) # center window sleep(200ms) user.i3wm_move_position("center")
```
 # resize helpers`
```
shrink window user.i3wm_mode("resize") key(left:10) key(up:10) # escape resize mode key(escape) # center window sleep(200ms) user.i3wm_move_position("center")
horizontal (shell | terminal) user.i3wm_split("h") user.i3wm_shell()

vertical (shell | terminal) `user.i3wm_split("v") user.i3wm_shell()

 # XXX - just replace with shuffle eventually?
 # XXX - like also need to match the generic talon commands`

(shuffle | move (win | window) [to] port) <number_small> user.i3wm_move_to_workspace(number_small)
(shuffle | move (win | window) [to] last port) user.i3wm_move_to_workspace("back_and_forth")
(shuffle | move) flipper user.i3wm_move_to_workspace("back_and_forth")
(shuffle | move (win | window) left) user.i3wm_move("left")
(shuffle | move (win | window) right) user.i3wm_move("right")
(shuffle | move (win | window) up) user.i3wm_move("up")
(shuffle | move (win | window) down) user.i3wm_move("down")
(win | window) horizontal user.i3wm_split("h")
(win | window) vertical user.i3wm_split("v")
make scratch user.i3wm_move("scratchpad")
[(show | hide)] scratch user.i3wm_show_scratchpad()

next scratch `user.i3wm_show_scratchpad() user.i3wm_show_scratchpad()

 # these rely on the user settings for the mod key. see i3wm.py Actions class`

launch user.i3wm_launch()
launch <user.text> user.i3wm_launch() sleep(100ms) insert("{text}")
lock screen user.i3wm_lock()
(launch shell | koopa) user.i3wm_shell()
new scratch (shell | window) user.i3wm_shell() sleep(200ms) user.i3wm_move("scratchpad") user.i3wm_show_scratchpad()
murder user.deprecate_command("2023-02-04", "murder", "win kill") app.window_close()

kubectl

cube [control] "kubectl "
cube create "kubectl create "
cube expose "kubectl expose "
cube run "kubectl run "
cube set "kubectl set "
cube run container "kubectl run-container "
cube explain "kubectl explain "
cube get "kubectl get "
cube edit "kubectl edit "
cube delete "kubectl delete "
cube rollout "kubectl rollout "
cube rolling update "kubectl rolling-update "
cube scale "kubectl scale "
cube auto scale "kubectl autoscale "
cube certificate "kubectl certificate "
cube top "kubectl top "
cube drain "kubectl drain "
cube taint "kubectl taint "
cube (cord | cordon) "kubectl cordon "
cube (uncord | uncordon) "kubectl uncordon "
cube cluster (info | information) "kubectl cluster-info "
cube describe "kubectl describe "
cube logs "kubectl logs "
cube attach "kubectl attach "
cube exec "kubectl exec "
cube port forward "kubectl port-forward "
cube proxy "kubectl proxy "
cube copy "kubectl cp "
cube auth "kubectl auth "
cube diff "kubectl diff "
cube apply "kubectl apply "
cube patch "kubectl patch "
cube replace "kubectl replace "
cube wait "kubectl wait "
cube convert "kubectl convert "
cube customize "kubectl kustomize "
cube label "kubectl label "
cube annotate "kubectl annotate "
cube completion "kubectl completion "
cube (interface | API) "kubectl api "
cube interface resources "kubectl api-resources "
cube interface versions "kubectl api-versions "
cube config "kubectl config "
cube help "kubectl help "
cube plugin "kubectl plugin "
cube version "kubectl version "
cube {user.kubectl_action} [{user.kubectl_object}] insert("kubectl {kubectl_action} ") insert(kubectl_object or "")
cube detach key("ctrl-p") key("ctrl-q")
cube shell user.insert_between("kubectl exec -it ", " -- /bin/bash")

go

variadic "..."
logical and " && "
logical or " || "
state comment "// "

[line] comment <user.text> `key("cmd-right") insert(" // ") insert(user.formatted_text(text, "sentence"))

 # "add comment <user.text> [over]:
 #     key("cmd-right")
 #     text_with_leading(" // ")
 # ]
 # "[state] context: insert("ctx")`

state (funk | func | fun) "func "
function (Annette | init) [over] "func init() {\n"
function <user.text> [over] insert("func ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE")) insert("(") sleep(100ms)
method <user.text> [over] insert("meth ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE")) sleep(100ms)
state var "var "
variable [<user.text>] [over] insert("var ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE")) # insert(" ") sleep(100ms)

of type [<user.text>] [over] `insert(" ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))

 # "set <user.text> [over]:
 #     insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
 #     insert(" := ")
 #     sleep(100ms)
 # ]`

state break "break"
state (chan | channel) " chan "
state go "go "
state if "if "
if <user.text> [over] insert("if ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
spawn <user.text> [over] insert("go ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state else if " else if "
else if <user.text> [over] insert(" else if ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state else " else "
else <user.text> [over] insert(" else {") key("enter") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state while "while "
while <user.text> [over] insert("while ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state for "for "
for <user.text> [over] insert("for ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state for range "forr "
range <user.text> [over] insert("forr ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state format "fmt"
format <user.text> [over] insert("fmt.") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
state switch "switch "
switch <user.text> [over] insert("switch ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state select "select "
state (const | constant) " const "
constant <user.text> [over] insert("const ") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
state case " case "
state default " default:"
case <user.text> [over] insert("case ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state type " type "
type <user.text> [over] insert("type ") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
state true " true "
state false " false "
state (start | struct | struck) insert(" struct {") key("enter")
(struct | struck) <user.text> [over] insert(" struct {") key("enter") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
[state] empty interface " interface{} "
state interface insert(" interface {") key("enter")
interface <user.text> [over] insert(" interface {") key("enter") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
state string " string "
[state] (int | integer | ant) "int"
state slice " []"
slice of "[]"
[state] (no | nil) "nil"
state (int | integer | ant) sixty four " int64 "
state tag user.insert_between(" ", "")
field tag <user.text> [over] user.insert_between(" ", "") sleep(100ms) insert(user.formatted_text(text, "snake")) insert(" ") sleep(100ms)
state return " return "
return <user.text> [over] insert("return ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
map of string to string " map[string]string "
map of <user.text> [over] insert("map[") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE")) key("right") sleep(100ms)
receive " <- "
make "make("
loggers [<user.text>] [over] insert("logrus.") insert(user.formatted_text(text, "PUBLIC_CAMEL_CASE"))
length <user.text> [over] insert("len(") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
append <user.text> [over] insert("append(") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
state (air | err) "err"
error " err "
loop over [<user.text>] [over] insert("forr ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
item <user.text> [over] insert(", ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
value <user.text> [over] insert(": ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
address of [<user.text>] [over] insert("&") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
pointer to [<user.text>] [over] insert("*") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))
swipe [<user.text>] [over] key("right") insert(", ") insert(user.formatted_text(text, "PRIVATE_CAMEL_CASE"))

markdown

(level | heading | header) one edit.line_start() "# "
(level | heading | header) two edit.line_start() "## "
(level | heading | header) three edit.line_start() "### "
(level | heading | header) four edit.line_start() "#### "
(level | heading | header) five edit.line_start() "##### "
(level | heading | header) six edit.line_start() "###### "
list [one] edit.line_start() "- "
list two edit.line_start() " - "
list three edit.line_start() " - "
list four edit.line_start() " - "
list five edit.line_start() " - "
list six edit.line_start() " - "
{user.markdown_code_block_language} block "```{markdown_code_block_language}" key(enter:2) "```" key(up)
link "[]()" key(left:3)

win windbg

register <user.registers> key(@) insert("{registers}")
open help insert(".hh\n")
add microsoft symbols insert("srv*C:\\symbols*http://msdl.microsoft.com/download/symbols;\n")
force reload symbols insert(".reload /f\n")
reload symbols insert(".reload\n")
loaded modules insert("lm l\n")
display pointers insert("dps ")
dereference pointer user.insert_between("poi(", ")")
show version key(ctrl-alt-w)
view command key(alt-1)
view watch key(alt-2)
view locals key(alt-3)
view registers key(alt-4)
view memory key(alt-5)
view call stack key(alt-6)
view disassembly key(alt-7)
view scratch pad key(alt-8)
view (processes | threads) key(alt-9)
dump function params "r @rcx,@rdx,@r8,@r9\n"
(lib | library) <user.windows_dlls> "{windows_dlls}"

css

block user.code_block()
attribute [<user.text>] name = user.formatted_text(text or "", "DASH_SEPARATED") user.insert_between("[{name}", "]")
prop <user.text> `name = user.formatted_text(text, "DASH_SEPARATED") user.insert_between("{name}: ", ";")
```
 # for media/supports queries, or if you don't like prop`
```
rule <user.text> name = user.formatted_text(text, "DASH_SEPARATED") insert("{name}: ")
value <user.number_string> [{user.css_unit}] "{number_string}{css_unit or ''}"
value <user.number_string> point <digit_string> [{user.css_unit}] "{number_string}.{digit_string}{css_unit or ''}"
(value | state) {user.css_global_value} "{css_global_value}"
value <user.text> user.insert_formatted(text, "DASH_SEPARATED")
variable <user.text> name = user.formatted_text(text, "DASH_SEPARATED") insert("var(--{name})")
op var user.insert_between("var(--", ")")
at {user.css_at_rule} "@{css_at_rule} "
unit {user.css_unit} insert(css_unit)
[value] current color "currentColor"
op important " !important"

vimscript

assign [<user.vimscript_scope>] (variable | var) [<user.text>] [over] insert("let ") insert(vimscript_scope or "") user.code_private_variable_formatter(text)
[<user.vimscript_scope>] (variable | var) [<user.text>] [over] `insert(vimscript_scope or "") user.code_private_variable_formatter(text)
```
 # see lang/vimscript/vimscript.py for list`
```
<user.vimscript_functions> insert("{vimscript_functions} ")
state command "command! "
state end if "endif"
state end for "endfor"
state end while "endwhile"
state end function "endfunction"
state continue "continue"

comment block

block comment user.code_comment_block()
block comment line #todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_start() user.code_comment_block_prefix() key(space) edit.line_end() key(space) user.code_comment_block_suffix() #adds comment to the start of the line
block comment line <user.text> over #todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_start() user.code_comment_block() insert(user.text)
block comment <user.text> over #todo: this should probably be a single function once #.talon supports implementing actions with parameters? user.code_comment_block() insert(user.text)
block comment <user.text> #todo: this should probably be a single function once #.talon supports implementing actions with parameters? user.code_comment_block() insert(user.text)
(line | inline) block comment <user.text> over #todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_end() user.code_comment_block_prefix() key(space) insert(user.text) key(space) user.code_comment_block_suffix()
(line | inline) block comment <user.text> #todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_end() user.code_comment_block_prefix() key(space) insert(user.text) key(space) user.code_comment_block_suffix()
open block comment user.code_comment_block_prefix()
close block comment user.code_comment_block_suffix()

functions common

toggle funk user.code_toggle_functions()
funk <user.code_common_function> user.code_insert_function(code_common_function, "")
funk cell user.code_select_function(number - 1, "")
funk wrap <user.code_common_function> user.code_insert_function(code_common_function, edit.selected_text())
funk wrap user.code_select_function(number - 1, edit.selected_text())

comment line

comment user.code_comment_line_prefix()
comment line #todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_start() user.code_comment_line_prefix() #adds comment to the start of the line
comment line <user.text> over #todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_start() user.code_comment_line_prefix() insert(user.text) insert(" ")
comment <user.text> over #todo: this should probably be a single function once #.talon supports implementing actions with parameters? user.code_comment_line_prefix() insert(user.text)
comment <user.text> #todo: this should probably be a single function once #.talon supports implementing actions with parameters? user.code_comment_line_prefix() insert(user.text)
(line | inline) comment <user.text> over #todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_end() user.code_comment_line_prefix() insert(user.text)
(line | inline) comment <user.text> #todo: this should probably be a single function once #.talon supports implementing actions with parameters? edit.line_end() user.code_comment_line_prefix() insert(user.text)

data null

state (no | none | nil | null) user.code_insert_null()
is not (none | null) user.code_insert_is_not_null()
is (none | null) user.code_insert_is_null()

object oriented

self dot user.code_self() user.code_operator_object_accessor()
state self user.code_self()
state class user.code_define_class()

functions

{user.code_function_modifier} funky <user.text>* `user.code_modified_function(code_function_modifier_list or 0, text)
```
 # for annotating function parameters`
```
is type <user.code_type> user.code_insert_type_annotation(code_type)
returns [type] <user.code_type> user.code_insert_return_type(code_type)
type <user.code_type> insert(code_type)

operators assignment

op (equals | assign) user.code_operator_assignment()
op (minus | subtract) equals user.code_operator_subtraction_assignment()
op (plus | add) equals user.code_operator_addition_assignment()
op (times | multiply) equals user.code_operator_multiplication_assignment()
op divide equals user.code_operator_division_assignment()
op mod equals user.code_operator_modulo_assignment()
[op] increment user.code_operator_increment()
[op] bit [wise] and equals user.code_operator_bitwise_and_assignment()
[op] bit [wise] or equals user.code_operator_bitwise_or_assignment()
(op | logical | bitwise) (ex | exclusive) or equals user.code_operator_bitwise_exclusive_or_assignment()
[(op | logical | bitwise)] (left shift | shift left) equals user.code_operator_bitwise_left_shift_assignment()
[(op | logical | bitwise)] (right shift | shift right) equals user.code_operator_bitwise_right_shift_assignment()

imperative

block user.code_block()
state if user.code_state_if()
state else if user.code_state_else_if()
state else user.code_state_else()
state while user.code_state_while()
state loop user.code_state_infinite_loop()
state for user.code_state_for()
state for in user.code_state_for_each()
state switch user.code_state_switch()
state case user.code_state_case()
state do user.code_state_do()
state goto user.code_state_go_to()
state return user.code_state_return()
state break user.code_break()
state (continue | next) user.code_next()

operators bitwise

[op] bitwise and user.code_operator_bitwise_and()
[op] bitwise or user.code_operator_bitwise_or()
(op | logical | bitwise) (ex | exclusive) or user.code_operator_bitwise_exclusive_or()
(op | logical | bitwise) (left shift | shift left) user.code_operator_bitwise_left_shift()
(op | logical | bitwise) (right shift | shift right) user.code_operator_bitwise_right_shift()

amethyst

window next key("alt-shift-j")
window previous key("alt-shift-k")
window full key("alt-shift-d")
window float key(alt-shift-t)
window tall key("alt-shift-a")
window middle key("alt-shift-")`
window move main key("alt-shift-enter")
window grow key("alt-shift-l")
window shrink key("alt-shift-h")
window reevaluate key("alt-shift-z")

stylua

lint ignore "-- stylua: ignore"
lint ignore start "-- stylua: ignore start"
lint ignore end "-- stylua: ignore end"

lua

state local "local"
state end "end"
state then "then"
state repeat "repeat"
state until "until"
state return (null | nil) "return nil"
state return true "return true"
state return false "return false"
state return table user.insert_between("return {", "}")
state append string " .. "
state label <user.text> insert("::") user.insert_formatted(text, "snake") insert("::")
require <user.code_libraries> user.code_insert_library("", code_libraries) key(end enter)
state (variable | var) [<user.text>] [over] user.code_public_variable_formatter(text)
state local (variable | var) [<user.text>] [over] `insert("local ") user.code_private_variable_formatter(text)
```
 # for built in object methods, ex: foo:gsub()`
```
method <user.text> insert(":") user.code_public_function_formatter(text) insert("()") edit.left()
self dot "self."
index <user.word> '["{word}"]'
index (var | variable) <user.text> var = user.formatted_text(text, "snake") insert("[{var}]")
state return dick user.insert_between("return {", "}")

scala

state {user.scala_modifier} insert("{user.scala_modifier} ")
state {user.scala_keyword} insert("{scala_keyword} ")
op right arrow " -> "
op left arrow " <- "
op plus plus " ++ "
op subtype " <: "
state match user.code_state_switch()
block string insert('""""""') key("left left left")

zoom

(mute | unmute) key(shift-cmd-a)
(start | stop) audio key(shift-cmd-a)
(start | stop) video key(shift-cmd-v)
share screen key(shift-cmd-s)
stop [screen] (share | sharing) key(shift-cmd-s)
(leave | end) meeting key(cmd-w)

iterm

clear word key(alt-backspace)
tab previous key(cmd-shift-[)
tab next key(cmd-shift-])
history key(ctrl-r)
files key(ctrl-t)
(vim | vin) mode key(cmd-shift-c)

win rectangle

window left key(ctrl-alt-shift-left)
window right key(ctrl-alt-shift-right)
window up key(ctrl-alt-shift-up)
window down key(ctrl-alt-shift-down)
window top left key(ctrl-alt-shift-m)
window top right key(ctrl-alt-shift-')
window bottom left key(ctrl-alt-')
window bottom right key(ctrl-alt-shift-/)
window left third key(ctrl-alt-shift-s)
window center third key(ctrl-alt-shift-t)
window right third key(ctrl-alt-shift-d)
window left two thirds key(ctrl-alt-shift-f)
window right two thirds key(ctrl-alt-shift-g)
window top left sixth key(ctrl-alt-shift-j)
window top center sixth key(ctrl-alt-shift-l)
window top right sixth key(ctrl-alt-shift-u)
window bottom left sixth key(ctrl-alt-shift-h)
window bottom center sixth key(ctrl-alt-shift-n)
window bottom right sixth key(ctrl-alt-shift-e)
window first fourth key(ctrl-alt-shift-y)
window last fourth key(ctrl-alt-shift-o)
display next key(ctrl-alt-shift-cmd-right)
display previous key(ctrl-alt-shift-cmd-left)
window max key(ctrl-alt-shift-return)
window center key(ctrl-alt-shift-c)
window center half key(ctrl-alt-shift-right) key(ctrl-alt-shift-c)

raycast

ray cast key(cmd-space)
ray cast [user.text] key(cmd-space) insert(user.text or "")

homerow

[show] links key(cmd-shift-space)
scroll mode key(cmd-shift-alt-ctrl-j)

hammerspoon

hyper <user.letter> key('cmd-shift-alt-ctrl-{letter}')

mac slack mac

workspace key("cmd-{number}")
(slack | lack) [channel] info key(cmd-shift-i)
(slack | lack) [all] unread key(cmd-shift-a)
(slack | lack) jump key(cmd-k)
focus (move | next) key(ctrl-)`
(section | zone) [next] key(f6)
(section | zone) (previous | last) key(shift-f6)
(slack | lack) [direct] messages key(cmd-shift-k)
(slack | lack) threads key(cmd-shift-t)
(slack | lack) (history [next] | back | backward) key(cmd-[)
(slack | lack) forward key(cmd-])
(element | bit) [next] key(tab)
(element | bit) (previous | last) key(shift-tab)
(slack | lack) (my stuff | activity) key(cmd-shift-m)
(slack | lack) (mentions | reactions) key(cmd-shift-m)
(slack | lack) directory key(cmd-shift-e)
(slack | lack) (starred [items] | stars) key(cmd-shift-s)
(slack | lack) unread [messages] key(cmd-shift-a)
(go | undo | toggle) full key(ctrl-cmd-f)
grab left key(shift-up)
grab right key(shift-down)
add line key(shift-enter)
(slack | lack) (slap | slaw | slapper) key(cmd-right shift-enter)
(slack | lack) (react | reaction) key(cmd-shift-\)
(insert command | commandify) key(cmd-shift-c)
insert link key(cmd-shift-u)
insert code key(cmd-shift-alt-c)
(slack | lack) (bull | bullet | bulleted) [list] key(cmd-shift-8)
(slack | lack) (number | numbered) [list] key(cmd-shift-7)
(slack | lack) (quotes | quotation) key(cmd-shift->)
bold key(cmd-b)
(italic | italicize) key(cmd-i)
(strike | strikethrough) key(cmd-shift-x)
(slack | lack) snippet key(cmd-shift-enter)
([toggle] mute | unmute) key(m)
(slack | lack) huddle key(cmd-shift-h)
(slack | lack) ([toggle] video) key(v)
(slack | lack) invite key(a)
(slack | lack) shortcuts key(cmd-/)
emote <user.text> "{text}"
toggle left sidebar key(cmd-shift-d)
toggle right sidebar key(cmd-.)
(move | next) focus app.notify("please use the voice command 'focus next' instead of 'next focus'") key(ctrl-)`
[next] (section | zone) app.notify("please use the voice command 'section next' instead of 'next section'") key(f6)
(previous | last) (section | zone) app.notify("please use the voice command 'section last' instead of 'last section'") key(shift-f6)
[next] (element | bit) app.notify("please use the voice command 'element next' instead of 'next element'") key(tab)
(previous | last) (element | bit) app.notify("please use the voice command 'element last' instead of 'last element'") key(shift-tab)

keys

go <user.arrow_keys> user.move_cursor(arrow_keys)
<user.letter> key(letter)
(ship | uppercase) <user.letters> [(lowercase | sunk)] user.insert_formatted(letters, "ALL_CAPS")
<user.symbol_key> key(symbol_key)
<user.function_key> key(function_key)
<user.special_key> key(special_key)
<user.modifiers> <user.unmodified_key> key("{modifiers}-{unmodified_key}")
press <user.modifiers> key(modifiers)
press <user.keys> key(keys)

dictation mode

press <user.modifiers> key(modifiers)
press <user.keys> key(keys)
<user.raw_prose> user.dictation_insert(raw_prose)
cap user.dictation_format_cap()
(no cap | no-caps) user.dictation_format_no_cap()
(no space | no-space) user.dictation_format_no_space()
cap that user.dictation_reformat_cap()
(no cap | no-caps) that user.dictation_reformat_no_cap()
(no space | no-space) that user.dictation_reformat_no_space()
go up <number_small> (line | lines) edit.up() repeat(number_small - 1)
go down <number_small> (line | lines) edit.down() repeat(number_small - 1)
go left <number_small> (word | words) edit.word_left() repeat(number_small - 1)
go right <number_small> (word | words) edit.word_right() repeat(number_small - 1)
go line start edit.line_start()
go line end edit.line_end()
select all that key(cmd-a)
select left <number_small> (word | words) edit.extend_word_left() repeat(number_small - 1)
select right <number_small> (word | words) edit.extend_word_right() repeat(number_small - 1)
select left <number_small> (character | characters) edit.extend_left() repeat(number_small - 1)
select right <number_small> (character | characters) edit.extend_right() repeat(number_small - 1)
clear left <number_small> (word | words) edit.extend_word_left() repeat(number_small - 1) edit.delete()
clear right <number_small> (word | words) edit.extend_word_right() repeat(number_small - 1) edit.delete()
clear left <number_small> (character | characters) edit.extend_left() repeat(number_small - 1) edit.delete()
clear right <number_small> (character | characters) `edit.extend_right() repeat(number_small - 1) edit.delete()
```
 # Formatting`
```
formatted <user.format_text> user.dictation_insert_raw(format_text)
format selection <user.formatters> user.formatters_reformat_selection(formatters)
nope that | scratch that user.clear_last_phrase()
(nope | scratch) selection edit.delete()
scratch that user.clear_last_phrase()
scratch selection edit.delete()
scratch all that key(cmd-a) key(backspace)
select that user.select_last_phrase()
spell that <user.letters> user.dictation_insert(letters)
spell that <user.formatters> <user.letters> `result = user.formatted_text(letters, formatters) user.dictation_insert_raw(result)
```
 # Escape, type things that would otherwise be commands`
```
escape <user.text> user.dictation_insert(user.text)

cheatsheet

print cheatsheet user.cheatsheet()

Files

cheatsheet.md

Latest commit

History

cheatsheet.md

File metadata and controls

user.letter

user.number_key

user.modifier_key

user.special_key

user.symbol_key

user.arrow_key

user.punctuation

user.function_key

formatters

1password

1password global

win slack win

terraform

thunderbird

thunderbird calendar

thunderbird composer

thunderbird contacts

thunderbird inbox

thunderbird tasks

visual studio

batch

php

proto

sql

comment documentation

data bool

functions common gui active

keywords

libraries

library gui open

operators array

operators lambda

operators math

operators pointer

chrome

wsl

twitter

talon repl

gitlab

win windows terminal

win windows explorer

mac rstudio mac

dunst

mac emacs

apple notes

protonmail

github web

finder

tmux

linux tmux linux

apple terminal

vivaldi

linux signal linux

termite

git add patch

git

linux keepassx linux

linux taskwarrior linux

outlook web

win outlook win

discord

eclipse

firefox

gdb global

gdb active

mac teams mac

teams

numbers

abbreviate

language modes

wake and sleep wav2letter

dragon mode

modes

wake and sleep