Snippets sharing thread

[artisticat1]

You can share custom snippets you've written with others here!

[Shesh6]

Here are my favorite custom snippets, for your pleasure. I have plenty of text mode snippets, because this plugin is useful for more than just formatting math!

Text Mode Snippets

• Colored text in Obsidian using HTML snippets in text mode:
  {trigger: "clr", replacement: "\<font style=\"color:${0:Red}\"\>$1\<\/font\> $2", options: "tA", description: "Add colored font HTML"},

• Automatically prettify header links
  {trigger: "\\[\\[(.*)#(.+)\\]\\]P", replacement: "[[[[0]]#[[1]]|[[1]]]]", options: "rtA", description: "Auto-prettify links (Capitalized headers)"},
  Note 1: I have versions of this snippet that paste in the alias in lower case, but it necessitates adding some lines to the JavaScript.
  Note 2: A tabstop of the kind "...|${0:[[1]]}]]" does not work to auto-select the alias, as the entire link is selected automatically. I tried adding zero-width characters but Obsidian highlights them as errors.

• Automatically treat lone letters as math symbols:
  {trigger: "([^'])\\b((?![aAI])[a-zA-Z])\\b([\\n\\s\\.,])", replacement: "[[0]]$[[1]]$[[2]]", options: "rtA", description: "Automatically treat lone characters as math (except a, A, I)"},
  Note 1: This triggers before newline, space, comma and period, but not after an apostrophe. This can be changed in the first and last capture groups (...).
  Note 2: Currently, this converts abbreviations like "i.e." "e.g." to math. To avoid this behavior add "ieg" to the lookahead exclusion group (?!...).

• Automatically treat numbers as math:
  {trigger: "\\b(-?\\d*\\.?\\d+)\\b(\\s|,|\\.\\s)", replacement: "$\\hspace{0pt}[[0]]$[[1]]", options: "rtA", description: "Automatically convert numbers to math"},
  Note 1: This detects positive numbers and decimals. It triggers before space, comma, or a period followed by a space. Therefore, for lists it's important to use the alternate notation "1) " rather than "1. "
  Note 2: As of the writing of this comment (Replacements with "$\d" or "[[\d" #49), we can't have a digit follow the $ symbol in replacements, so a zero-width character is inserted.

Math Mode Snippets

• Color control in math mode:
  {trigger: "clr", replacement: "\\color{${0:white} $1", options: "mA", description: "Control math mode color"},

• Common subscripts
  {trigger: "([a-zA-Z])(i|j|n|m|k|x|y)\\2{1}", replacement: "[[0]]_{[[1]]}", options: "rmA", description: "Common subscripts"},
{trigger: "([a-zA-Z])([a-zA-Z])p(\d)", replacement: "[[0]]_{[[1]]+[[2]]}", options: "rmA", description: "Common subscripts (plus)"},
{trigger: "([a-zA-Z])([a-zA-Z])m(\d)", replacement: "[[0]]_{[[1]]-[[2]]}", options: "rmA", description: "Common subscripts (minus)"},
  Note 1: This will subscript the letters in the group (i|j|...) if typed twice after a letter (xii $\to x_{i}$). Be careful writing out "gamma", or alter the list.
  Note 2: The other lines implement xip1 $\to x_{i+1}$, ftm3 $\to f_{t-3}$ etc. .
  Note 3: I made sure to remove "xi" from the Greek letter list in the JavaScript, but you can write custom snippets to override this issue.

• Articulated Sum
  {trigger: "\\summ", replacement: "\\sum_{${0:i}=1}^{${1:n}} $2", options: "mA", description: "Articulated sum"},

• Vector/matrix transpose
  {trigger: "\\\\mathbf{([A-Za-z])}T", replacement: "\\mathbf{[[0]]}^{\\top}", options: "rmA", description: "Transpose"},

• Align visual after the fact
  {trigger: "A", replacement: "\\begin{align}\n${VISUAL}\n\\end{align}", options: "mA", description: "Align visual"},

Feel free to use any of these, and please let me know of any bugs and edge cases! Thanks again to @artisticat1 for this plugin.

[smerkousdavid]

Ahh I was just looking for the vec/matrix transpose! Thank you!

[JaimeVicent]

@Shesh6 I'm having troubles with the snippet "Automatically treat lone letters as math symbols:" when I type letters with accents (I'm Spanish). When I type "también" it automatically changes to "tambié$n$". Any idea on how could I solve this issue? Thanks in advance!

Edit: I think I've solved it. For anyone with the same issue: here's what I did: I added 'áéíóúÁÉÍÓÚ' to the capturing group as "([^']): This is a capturing group that matches any character except a single quote (')."

Here's the snippet updated:
{trigger: "([^'áéíóúÁÉÍÓÚ])\\b((?![aeoyAI])[a-zA-Z])\\b([\\n\\s\\.,])", replacement: "[[0]]$[[1]]$[[2]]", options: "rtA", description: "Automatically treat lone characters as math (except a, A, I)"}

Por lo menos he aprendido un poco de regex xD

[math-feng]

太牛逼了！！！

[firehuoyan]

有些时候需要三个一样的字母，比如三重积分iiint。并且考虑到下标和原字母一般不会相同，所以进行修改，只有一个字母后面跟随两个与该字母不一样的字母时才会转换为下标。
Sometimes, three identical letters are needed, such as in the triple integral symbol iiint. Considering that subscripts and the original letter are generally not the same, the rule has been modified: only when a single letter is followed by two different letters will it be converted into a subscript.
{trigger: "([a-zA-Z])(i|j|n|m|k|x|y)\\2(?!\\2)", replacement: "[[0]]_{[[1]]}", options: "rmA", description: "Common subscripts (no triple match)"},

[mxxxyia]

Hi, thanks so much for these. just quick and v basic question, how do you use the color control in math mode snippet? I've inserted it into my snippets but im unsure of how to use it. I'm very much a beginner to all this.

[smerkousdavid]

Here are some useful sums that I use (I like the limits above/below look) and defaulting to common sums.

    {trigger: "ssum", replacement: "\\sum\\limits_{ ${0:s \\in C} } }", options: "mA"},
    {trigger: "bsum", replacement: "\\sum\\limits_{ ${0:i=1} }^{ ${1:m} } \\sum\\limits_{ ${2:j=1} }^{ ${3:n} }", options: "mA"},
    {trigger: "lsum", replacement: "\\sum\\limits_{ ${0:i=1} }^{ ${1:n} }", options: "mA"},

For those who are tired of typing \mathbb{R}^{m \times n} or other common set dimension stuff then this is for you.

    {trigger: "\\\\mathbb{(C|R|Z|N|1)}n", replacement: "\\mathbb{[[0]]}^{ ${0:n} }", options: "rmA"},
    {trigger: "\\\\mathbb{(C|R|Z|N|1)}mn", replacement: "\\mathbb{[[0]]}^{ ${0:m} \\times ${1:n} }", options: "rmA"},

[sunsoy]

include a latex font size command when beginning new latex sections
e.g. large

    // Math mode
    {trigger: "mk", replacement: "$\\large\ $0$", options: "tA"},
    {trigger: "dm", replacement: "$$\n\\large\ $0\n$$", options: "tAw"},

[kerbless]

Kerbless's additions

Entering math mode as quick latex for obsidian.

    {trigger: "$", replacement: "$$0$", options: "tA"},
    {trigger: "$", replacement: "$$0$", options: "mA"},

Functions.

    {trigger: "fx", replacement: "f(x)", options: "mA"},
    {trigger: "ff", replacement: "f($0)", options: "mA"},

[j-finger]

Nice stuff. I do find the following to have a bit more control though

{trigger: "$$", replacement: "\$$0\$", options: "tA"}, // Inline equation
{trigger: "$ $", replacement: "\$\$ $0 \$\$", options: "tA"}, // Standalone equation 

[cossio]

Basic question. Where am I supposed to write these custom snippets to have them working in my Obsidian notes?

[radillus]

First you need to install this plugin and enable it at ObisidianSettings->Options->CommunityPlugins, then you can change it at ObisidianSettings->CommunityPlugins->LatexSuite->Snippets. Glad to help you :D

[cossio]

Thanks! Is there a local file where these custom snippets are being written?

[radillus]

It's under your_ObsidianVault_file\ .obsidian\plugins\obsidian-latex-suite\data.json (on Windows)

[cossio]

Great, thanks

[MultisampledNight]

Arrows in specific directions!

    {trigger: "lra", replacement: "\\longrightarrow", options: "mA"},
    {trigger: "(nna|uua)", replacement: "\\uparrow", options: "mAr"},
    {trigger: "nea", replacement: "\\nearrow", options: "mA"},
    {trigger: "(eea|rra)", replacement: "\\rightarrow", options: "mAr"},
    {trigger: "sea", replacement: "\\searrow", options: "mA"},
    {trigger: "(ssa|dda)", replacement: "\\downarrow", options: "mAr"},
    {trigger: "swa", replacement: "\\swarrow", options: "mA"},
    {trigger: "(wwa|lla)", replacement: "\\leftarrow", options: "mAr"},
    {trigger: "nwa", replacement: "\\nwarrow", options: "mA"},

Codeblocks! The bg color definition is just for mixing with xcolor in TikZ, set it to the background color of your theme if you'd like to use it.

    {trigger: "cbl", replacement: "```$0\n```", options: "tA"},
    {trigger: "dvcbl", replacement: "```dataview\n$0\n```", options: "tA"},
    {trigger: "rscbl", replacement: "```rust\n$0\n```", options: "tA"},
    {trigger: "tscbl", replacement: "```typescript\n$0\n```", options: "tA"},
    {trigger: "jscbl", replacement: "```javascript\n$0\n```", options: "tA"},
    {trigger: "tikzcbl", replacement: "```tikz\n\\definecolor{bg}{HTML}{1e1e1e}\n\\usetikzlibrary{arrows.meta}\n\n\\begin{document}\n\\LARGE\n\\begin{tikzpicture}[very thick,scale=2,>=Stealth]\n\n$0\n\n\\end{tikzpicture}\n\\end{document}\n```$1", options: "tA"},
    {trigger: "chbl", replacement: "```tikz\n\\definecolor{bg}{HTML}{1e1e1e}\n\\usepackage{chemfig}\n\n\\begin{document}\n\\LARGE\n\n\\chemfig{$0}\n\n\\end{document}\n```$1", options: "tA"},

Miscellaneous niceties! Warnings:

• mod is already defined in the default mapping with another meaning.
• lor might conflict with color if you type that manually.

    {trigger: "adm", replacement: "$$\n\\begin{align}\n$0\n\\end{align}\n$$", options: "tAw"},
    {trigger: "lor", replacement: "\\lor", options: "mA"},
    {trigger: "land", replacement: "\\land", options: "mA"},
    {trigger: "lxor", replacement: "\\oplus", options: "mA"},
    {trigger: "neg", replacement: "\\neg", options: "mA"},
    {trigger: "col", replacement: ":-: | ", options: "t"},
    {trigger: "nin", replacement: "\\notin", options: "mA"},
    {trigger: "deg", replacement: "^{\\circ}", options: "mA"},
    {trigger: "fah", replacement: "\\text{F} ", options: "mA"},
    {trigger: "cel", replacement: "\\text{C} ", options: "mA"},
    {trigger: "mod", replacement: "\\mod ", options: "mAw"},
    {trigger: "max", replacement: "\\max", options: "mAw"},
    {trigger: "min", replacement: "\\min", options: "mAw"},

[j-finger]

The arrows and colours are NICE. These are my codeblock commands which allow for both highlighting and replacement as well as generation via typing them in

 // Codeblocks       
// MATLAB
{trigger: "M", replacement: " ```matlab\n ${VISUAL} \n```", options: "tA"},
{trigger: "``m", replacement: " ```matlab\n $0 \n```", options: "tA"},
// Python
{trigger: "P", replacement: " ```python\n ${VISUAL} \n```", options: "tA"},
{trigger: "``p", replacement: " ```python\n $0 \n```", options: "tA"},
// powershell
{trigger: "S", replacement: " ```powershell\n ${VISUAL} \n```", options: "tA"},
{trigger: "``s", replacement: " ```powershell\n $0 \n```", options: "tA"},
// JSON
{trigger: "J", replacement: " ```json\n ${VISUAL} \n```", options: "tA"},
{trigger: "``j", replacement: " ```json\n $0 \n```", options: "tA"}, 

[A-B-asdf]

I wanna help. How to do that Arccos would replaced into \operatorname{Arccos}? This is used in Complex analysis.

[TimeTravelPenguin]

There are already trig functions by default (as of me writing this. I presume they were there when you posted). It should look like

{trigger: "([^\\\\])(arcsin|arccos|arctan|arccot|arccsc|arcsec|sin|cos|tan|cot|csc)", replacement: "[[0]]\\[[1]]", options: "rmA"},
{trigger: "\\\\(arcsin|arccos|arctan|arccot|arccsc|arcsec|sin|cos|tan|cot|csc)([A-Za-gi-z])", replacement: "\\[[0]] [[1]]", options: "rmA"}, // Insert space after trig funcs. Skips letter "h" to allow sinh, cosh, etc.
{trigger: "\\\\(arcsinh|arccosh|arctanh|arccoth|arcsch|arcsech|sinh|cosh|tanh|coth|csch)([A-Za-z])", replacement: "\\[[0]] [[1]]", options: "rmA"}, // Insert space after trig funcs

If you specifically want a capitalised one, you can add Arccos to each of these triggers (remember to add a new |). So, you would then have:

{trigger: "([^\\\\])(Arccos|arcsin|arccos|arctan|arccot|arccsc|arcsec|sin|cos|tan|cot|csc)", replacement: "[[0]]\\[[1]]", options: "rmA"},
{trigger: "\\\\(Arccos|arcsin|arccos|arctan|arccot|arccsc|arcsec|sin|cos|tan|cot|csc)([A-Za-gi-z])", replacement: "\\[[0]] [[1]]", options: "rmA"}, // Insert space after trig funcs. Skips letter "h" to allow sinh, cosh, etc.
{trigger: "\\\\(Arccos|arcsinh|arccosh|arctanh|arccoth|arcsch|arcsech|sinh|cosh|tanh|coth|csch)([A-Za-z])", replacement: "\\[[0]] [[1]]", options: "rmA"}, // Insert space after trig funcs

[rambip]

Hi everyone !
After being tired of some design choices of the authors of this plugin (Some behaviours are pretty weird by default, like exists that turn into e\xi sts and then \exists), I decided to change some of the strange default behaviors, and rewrite them in a way that does not add that complexity.
Here is what I came out with:

Special modes

    {trigger: "#d", replacement: "\\displaystyle ", options: "mA"}, 
   {trigger: "#t", replacement: "\\text{$0}", options: "mA"},
   {trigger: "#b", replacement: "\\mathbf{$0}", options: "mA"},
   {trigger: "#n", replacement: "\\mathrm{$0}", options: "mA"},

over / underlining:

    {trigger: ",b", replacement: "\\bar{$0}$1", options: "mA"},
    {trigger: ",h", replacement: "\\hat{$0}$1", options: "mA"},
    {trigger: ",H", replacement: "\\widehat{$0}$1", options: "mA"},
    {trigger: ",d", replacement: "\\dot{$0}$1", options: "mA"},
    {trigger: ",t", replacement: "\\tilde{$0}$1", options: "mA"},
    {trigger: ",T", replacement: "\\widetilde{$0}$1", options: "mA"},
    {trigger: ",D", replacement: "\\ddot{$0}$1", options: "mA", priority: 2},
    {trigger: ",v", replacement: "\\vec{$0}$1", options: "mA"},
    {trigger: ",V", replacement: "\\overrightarrow{$0}$1", options: "mA"},

Sums and products

    {trigger: "sum", replacement: "\\sum", options: "mA"},
    {trigger: "\\sum", replacement: "\\sum_{ $0 }^{ $1 }", options: "m"},
    {trigger: "prod", replacement: "\\prod", options: "mA"},
    {trigger: "\\prod", replacement: "\\prod_{ $0 }^{ $1 }", options: "m"},
    {trigger: "lim", replacement: "\\lim_{ ${0:n} \\to ${1:\\infty} } $2", options: "m"},

Some set-theory operators

    {trigger: "empty", replacement: "\\emptyset", options: "m"},
    {trigger: "set", replacement: "\\{ $0 \\}$1", options: "m"},
    {trigger: "oo", replacement: "\\infty ", options: "m"},
    {trigger: "fa", replacement: "\\forall ", options: "m"},
    {trigger: "ex", replacement: "\\exists ", options: "m"},
    {trigger: "sub", replacement: "\\subset ", options: "m"},
    {trigger: "sub=", replacement: "\\subseteq ", options: "m"},
    {trigger: "sup", replacement: "\\supset ", options: "m"},
    {trigger: "\\", replacement: "\\setminus ", options: "m"},
    {trigger: "sq", replacement: "\\square", options: "m"},

Overall result: my config is a lot shorter and cleaner than the default, despite having added things.

And you, do you think the default has too much automatic bindings ?
Are you irritated when a snippet unfolds but you meant something totally different ?

[universemaster]

I like my notes to never contain the latex command when there is an equivalent unicode character. For example, my notes never contain \alpha in a math block and instead contain only the single character $α$.

Using the unicode characters rather than the command creates identical output for mathjax, katex, temml, and latex itself using the unicode-math package.

Using unicode characters means that the conceal functionality creates less distraction when navigating through an equation, because most of the conceal "replacements" are already used directly in the note.

To input the unicode characters I have some (messy) snippets to replace "\alpha" with "α", etc. I also have some (messy) replacements for the greek bold characters, so again I can use only one character.

However, (and here is my point):
I want to utilize other snippets that assume I am using the commands not the unicode characters. For example {greek} does not list the unicode characters.

Does anyone else have snippets I can use that work with unicode characters and would like to share, as it'll be a while before I can sort my snippets out, and would prefer to use the work of someone who has already done this.

[LuisOropeza7]

I think I posted my snippet as an issue haha

sorry for the inconvenience

{trigger: "Ntor", replacement: "<${0:x}{1}, ${0:x}{2}, \cdots ,${0:x}_{n}>", options: "mA"}

I use this one to denote vectors in n dimension spaces

[0Mysterio0]

Just beginning to experiment with regex, decided to create a replacement for a column vector using dots as separation instead of tabbing through each item.

{trigger: "3dcol\\.([-\\d|A-Za-z|\_|\{|\}|\^|\+]+)\\.([-\\d|A-Za-z|\_|\{|\}|\^|\+]+)\\.([-\\d|A-Za-z|\_|\{|\}|\^|\+]+)",

 replacement: "\n %vector \n \\begin{pmatrix}\n [[0]] \\\\  [[1]]   \\\\ [[2]]  \\\\ \n\\end{pmatrix} $0", 
 
 description: "Uses the syntax '3dcol.a.b.c' to create a pmatrix (a,b,c). a,b,c can be multiple characters.", 
 
 options: "rm"},

Would it be possible to generalize this to an N dimensional vector without having to make each case a separate snippet?

[TheFibonacciEffect]

Questions using a callout, checkbox and tag:

{trigger: "Q:", replacement: "> [!question]\n> - [ ] $0 #questions", options: "tA"},

Solutions using a collapsable callout

{trigger: "S:", replacement: "> [!solution]-\n> $0", options: "tA"},

[TheFibonacciEffect]

Repeated indicies to write subscripts

{
trigger: 
	"(?!.\\s?[RC])(?<![_^]\{)(?!umm)(?!inn)(?!app)(?![A-Za-z]ll)(?![A-Za-z]\\s)(\\\\${GREEK}|[a-zA-Z])(\}?)\\s?([a-zA-Z])\\3{1}",
// Do not replace the following, which already have snippets:
// summ -> sum with limits
// inn -> \in
// letter + RR -> "letter + Real numbers" eg. "inn RR"
// same for CC
// approx -> ~=
// Also do not append a subscript to already subscripted characters: _{a} bb will not be replaced
replacement: 
	"[[0]][[1]]_{[[2]]}",
options: "rmA",
"description": "auto add index if letter is repeated after symbol"
},

[LetianLi]

I have no clue what mk and dm stand for so I changed how to enter math mode. Type one $ for inline, then another $ for Block.
It is similar to Kerbless but it fixes the block formatting.

// Math mode
{trigger: "$", replacement: "$$0$", options: "tA"},
{trigger: "$", replacement: "$\n$0\n$", options: "mA"},

[LynetteCullens]

This should be defaulted.

[LetianLi]

I'm actually now using a combination of Latex Suite and Quick Latex for Obsidian. Preferred Quick Latex's less aggressive text-replacement based system but kept Latex Suite's popup visualizer.

[NittenRenegade]

Hi there!
My obsidian have a bug: \\ doesn't make a new line. I've read advice somewhere to use \displaylines{ \\ \\ ...} instead. It works. So, if someone has the same problem, you can use simple (my fisrt!) snippet:
{trigger: "dl", replacement: "\\displaylines{\n$0\n}", options:"M"}

[I0amLK]

I have some snippets as follow:

[
	// math environment
	// i- ---> $ $
	// d- ---> $$ $$
	{
	  trigger: "i-",
	  replacement: "$$0$",
	  options: "tA"
	},
	{
	  trigger: "d-",
	  replacement: "$$ $0$$",
	  options: "tAw"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// math index
	// fonts+number ---> fonts_{number}\mathcal{J}_K^{\mathfrak{m}}
	// sc ---> _{}
	// pw ---> ^{}
	// inverse for letter or greek letter
	{
	  trigger: /([A-Za-z])(\d)/,
	  replacement: "[[0]]_{[[1]]}",
	  options: "mA"
	},
	{
	  trigger: "pw",
	  replacement: "^{$0}",
	  priority: 10000,
	  options: "mA"
	},
	{
	  trigger: "sc",
	  replacement: "_{$0}",
	  options: "mA",
	  priority: 10000
	},
	{
	  trigger: "([a-zA-Z]|${GREEK})inv",
	  replacement: "[[0]]^{-1}",
	  options: "rmA"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// mathbb fonts
	// RR ---> \mathbb{R}
	// NN ---> \mathbb{N}
	// QQ ---> \mathbb{Q}
	// ZZ ---> \mathbb{Z}
	// CC ---> \mathbb{C}
	{
	  trigger: "CC",
	  replacement: "\\mathbb{C}",
	  options: "mA"
	},
	{
	  trigger: "ZZ",
	  replacement: "\\mathbb{Z}",
	  options: "mA"
	},
	{
	  trigger: "QQ",
	  replacement: "\\mathbb{Q}",
	  options: "mA"
	},
	{
	  trigger: "RR",
	  replacement: "\\mathbb{R}",
	  options: "mA"
	},
	{
	  trigger: "NN",
	  replacement: "\\mathbb{N}",
	  options: "mA"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// mathcal characters
	// calGREEK ---> \mathcal{GREEK}
	// scrGREEK ---> \mathscr{GREEK}
	// bfGREEK ---> \mathbf{GREEK}
	// bbGREEK ---> \mathbb{GREEK}
	// frakGREEK ---> \mathfrak{GREEK}
	// sfGREEK ---> \mathsf{GREEK}
	// itGREEK ---> \mathit{GREEK}
	{
	  trigger: "([a-zA-Z])cal",
	  replacement: "\\mathcal{[[0]]}",
	  options: "rmA"
	},
	{
	  trigger: "([a-zA-Z])scr",
	  replacement: "\\mathscr{[[0]]}",
	  options: "rmA",
	  priority: 1000
	},
	{
	  trigger: "([a-zA-Z])bf",
	  replacement: "\\mathbf{[[0]]}",
	  options: "rmA"
	},
	{
	  trigger: /([a-zA-Z]|\d)bb/,
	  replacement: "\\mathbb{[[0]]}",
	  options: "rmA"
	},
	{
	  trigger: "([a-zA-Z])frak",
	  replacement: "\\mathfrak{[[0]]}",
	  options: "rmA"
	},
	{
	  trigger: "([a-zA-Z])sf",
	  replacement: "\\mathsf{[[0]]}",
	  options: "rmA"
	},
	{
	  trigger: "([a-zA-Z])it",
	  replacement: "\\mathit{[[0]]}",
	  options: "rmA"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// math operations
	// sum ---> \sum
	// prod ---> \prod
	// coprod ---> \coprod
	// int ---> \int
	// cap ---> \cap
	// cup ---> \cup
	{
	  trigger: "sum",
	  replacement: "\\sum",
	  options: "mA"
	},
	{
	  trigger: "prod",
	  replacement: "\\prod",
	  options: "mA"
	},
	{
	  trigger: "coprod",
	  replacement: "\\coprod",
	  options: "mA"
	},
	{
	  trigger: "int",
	  replacement: "\\int",
	  options: "mA"
	},
	{
	  trigger: "cap",
	  replacement: "\\cap",
	  options: "mA"
	},
	{
	  trigger: "cup",
	  replacement: "\\cup",
	  options: "mA"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// mathcal characters
	// cal ---> \mathcal{}
	// scr ---> \mathscr{}
	// bf ---> \mathbf{}
	// mb; ---> \mathbb{}
	// frak ---> \mathfrak{}
	// sf ---> \mathsf{}
	// op; ---> \operatorname{}
	{
	  trigger: "cal",
	  replacement: "\\mathcal{$0}",
	  options: "mA"
	},
	{
	  trigger: "scr",
	  replacement: "\\mathscr{$0}",
	  options: "mA"
	},
	{
	  trigger: "bf",
	  replacement: "\\mathbf{$0}",
	  options: "mA"
	},
	{
	  trigger: "mb;",
	  replacement: "\\mathbb{$0}",
	  options: "mA"
	},
	{
	  trigger: "frak",
	  replacement: "\\mathfrak{$0}",
	  options: "mA"
	},
	{
	  trigger: "sf",
	  replacement: "\\mathsf{$0}",
	  options: "mA"
	},
	{
	  trigger: "op;",
	  replacement: "\\operatorname{$0}",
	  options: "mA"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// bold text
	// bt ---> ** **
	{
	  trigger: "bt",
	  replacement: "**$0**",
	  options: "t"
	},
  
	// italic text
	// it ---> * *
	{
	  trigger: "it",
	  replacement: "*$0*",
	  options: "t"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// math symbols
	// 'letter'bar ---> \bar{letter}
	// 'letter'hat ---> \hat{letter}
	// 'letter'ddot ---> \ddot{letter}
	// 'letter'dot ---> \dot{letter}
	// 'letter'vec ---> \vec{letter}
	// 'letter'tilde ---> \tilde{letter}
	// 'letter'und ---> \underline{letter}
	{
	  trigger: "([a-zA-Z])bar",
	  replacement: "\\bar{[[0]]}",
	  options: "rmA"
	},
	{
	  trigger: "([a-zA-Z])hat",
	  replacement: "\\hat{[[0]]}",
	  options: "rmA"
	},
	{
	  trigger: "([a-zA-Z])ddot",
	  replacement: "\\ddot{[[0]]}",
	  options: "rmA",
	  priority: 3
	},
	{
	  trigger: "([a-zA-Z])dot",
	  replacement: "\\dot{[[0]]}",
	  options: "rmA",
	  priority: 1
	},
	{
	  trigger: "([a-zA-Z])vec",
	  replacement: "\\vec{[[0]]}",
	  options: "rmA"
	},
	{
	  trigger: "([a-zA-Z])tilde",
	  replacement: "\\tilde{[[0]]}",
	  options: "rmA"
	},
	{
	  trigger: "([a-zA-Z])und",
	  replacement: "\\underline{[[0]]}",
	  options: "rmA"
	},
  
	// Geek letters + hat|bar|tilde|widehat|widetilde
	{
	  trigger: "(\\${GREEK})(hat|bar|tilde|widehat|widetilde|overline)",
	  replacement: "[[1]]\{\\[[0]]\}",
	  options: "rmA",
	  description: "Greek letters with hat, bar, tilde, widehat, widetilde, overline"
	},
  
	// visual overline
	{
	  trigger: "o",
	  replacement: "\\overline{${VISUAL}}",
	  options: "vmA",
	  description: "Visual overline"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// math symbols
	// a; ---> \alpha
	// b; ---> \beta
	// g; ---> \gamma
	// d; ---> \delta
	// e; ---> \epsilon
	// z; ---> \zeta
	// h; ---> \eta
	// t; ---> \theta
	// i; ---> \iota
	// k; ---> \kappa
	// l; ---> \lambda
	// m; ---> \mu
	// n; ---> \nu
	// x; ---> \xi
	// p; ---> \pi
	// r; ---> \rho
	// s; ---> \sigma
	// t; ---> \tau
	// u; ---> \upsilon
	// f; ---> \phi
	// c; ---> \chi
	// y; ---> \psi
	// w; ---> \omega
	// A; ---> \Alpha
	// B; ---> \Beta
	// G; ---> \Gamma
	// D; ---> \Delta
	// E; ---> \Epsilon
	// Z; ---> \Zeta
	// H; ---> \Eta
	// T; ---> \Theta
	// I; ---> \Iota
	// K; ---> \Kappa
	// L; ---> \Lambda
	// M; ---> \Mu
	// N; ---> \Nu
	// X; ---> \Xi
	// P; ---> \Pi
	// R; ---> \Rho
	// S; ---> \Sigma
	// T; ---> \Tau
	// U; ---> \Upsilon
	// F; ---> \Phi
	// C; ---> \Chi
	// Y; ---> \Psi
	// W; ---> \Omega
	{
	  trigger: "a;",
	  replacement: "\\alpha",
	  options: "mA"
	},
	{
	  trigger: "b;",
	  replacement: "\\beta",
	  options: "mA"
	},
	{
	  trigger: "g;",
	  replacement: "\\gamma",
	  options: "mA"
	},
	{
	  trigger: "d;",
	  replacement: "\\delta",
	  options: "mA"
	},
	{
	  trigger: "e;",
	  replacement: "\\epsilon",
	  options: "mA"
	},
	{
	  trigger: "z;",
	  replacement: "\\zeta",
	  options: "mA"
	},
	{
	  trigger: "h;",
	  replacement: "\\eta",
	  options: "mA"
	},
	{
	  trigger: "t;",
	  replacement: "\\theta",
	  options: "mA"
	},
	{
	  trigger: "i;",
	  replacement: "\\iota",
	  options: "mA"
	},
	{
	  trigger: "k;",
	  replacement: "\\kappa",
	  options: "mA"
	},
	{
	  trigger: "l;",
	  replacement: "\\lambda",
	  options: "mA"
	},
	{
	  trigger: "m;",
	  replacement: "\\mu",
	  options: "mA"
	},
	{
	  trigger: "n;",
	  replacement: "\\nu",
	  options: "mA"
	},
	{
	  trigger: "x;",
	  replacement: "\\xi",
	  options: "mA"
	},
	{
	  trigger: "p;",
	  replacement: "\\pi",
	  options: "mA"
	},
	{
	  trigger: "r;",
	  replacement: "\\rho",
	  options: "mA"
	},
	{
	  trigger: "s;",
	  replacement: "\\sigma",
	  options: "mA"
	},
	{
	  trigger: "t;",
	  replacement: "\\tau",
	  options: "mA"
	},
	{
	  trigger: "u;",
	  replacement: "\\upsilon",
	  options: "mA"
	},
	{
	  trigger: "f;",
	  replacement: "\\phi",
	  options: "mA"
	},
	{
	  trigger: "c;",
	  replacement: "\\chi",
	  options: "mA"
	},
	{
	  trigger: "y;",
	  replacement: "\\psi",
	  options: "mA"
	},
	{
	  trigger: "w;",
	  replacement: "\\omega",
	  options: "mA"
	},
	{
	  trigger: "A;",
	  replacement: "\\Alpha",
	  options: "mA"
	},
	{
	  trigger: "B;",
	  replacement: "\\Beta",
	  options: "mA"
	},
	{
	  trigger: "G;",
	  replacement: "\\Gamma",
	  options: "mA"
	},
	{
	  trigger: "D;",
	  replacement: "\\Delta",
	  options: "mA"
	},
	{
	  trigger: "E;",
	  replacement: "\\Epsilon",
	  options: "mA"
	},
	{
	  trigger: "Z;",
	  replacement: "\\Zeta",
	  options: "mA"
	},
	{
	  trigger: "H;",
	  replacement: "\\Eta",
	  options: "mA"
	},
	{
	  trigger: "T;",
	  replacement: "\\Theta",
	  options: "mA"
	},
	{
	  trigger: "I;",
	  replacement: "\\Iota",
	  options: "mA"
	},
	{
	  trigger: "K;",
	  replacement: "\\Kappa",
	  options: "mA"
	},
	{
	  trigger: "L;",
	  replacement: "\\Lambda",
	  options: "mA"
	},
	{
	  trigger: "M;",
	  replacement: "\\Mu",
	  options: "mA"
	},
	{
	  trigger: "N;",
	  replacement: "\\Nu",
	  options: "mA"
	},
	{
	  trigger: "X;",
	  replacement: "\\Xi",
	  options: "mA"
	},
	{
	  trigger: "P;",
	  replacement: "\\Pi",
	  options: "mA"
	},
	{
	  trigger: "R;",
	  replacement: "\\Rho",
	  options: "mA"
	},
	{
	  trigger: "S;",
	  replacement: "\\Sigma",
	  options: "mA"
	},
	{
	  trigger: "T;",
	  replacement: "\\Tau",
	  options: "mA"
	},
	{
	  trigger: "U;",
	  replacement: "\\Upsilon",
	  options: "mA"
	},
	{
	  trigger: "F;",
	  replacement: "\\Phi",
	  options: "mA"
	},
	{
	  trigger: "C;",
	  replacement: "\\Chi",
	  options: "mA"
	},
	{
	  trigger: "Y;",
	  replacement: "\\Psi",
	  options: "mA"
	},
	{
	  trigger: "W;",
	  replacement: "\\Omega",
	  options: "mA"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// Special snippet
  
	//Hom ---> \operatorname{Hom}
	//End ---> \operatorname{End}
	//Aut ---> \operatorname{Aut}
	//Gal ---> \operatorname{Gal}
	{
	  trigger: "Hom",
	  replacement: "\\operatorname{Hom}",
	  options: "mA"
	},
	{
	  trigger: "End",
	  replacement: "\\operatorname{End}",
	  options: "mA"
	},
	{
	  trigger: "Aut",
	  replacement: "\\operatorname{Aut}",
	  options: "mA"
	},
	{
	  trigger: "Gal",
	  replacement: "\\operatorname{Gal}",
	  options: "mA"
	},
  
	//oo ---> \infty
	{
	  trigger: "oo",
	  replacement: "\\infty",
	  options: "mA"
	},
  
	//ilim ---> \varinjlim
	//dlim ---> \varprojlim
	{
	  trigger: "dlim",
	  replacement: "\\varinjlim",
	  options: "mA"
	},
	{
	  trigger: "ilim",
	  replacement: "\\varprojlim",
	  options: "mA"
	},
  
	//>= ---> \ge
	//<= ---> \le
	{
	  trigger: ">=",
	  replacement: "\\ge",
	  options: "mA"
	},
	{
	  trigger: "<=",
	  replacement: "\\le",
	  options: "mA"
	},
  
	//p-adic ---> $p$-adic
	{
	  trigger: "p-adic",
	  replacement: "$p$-adic",
	  options: "tA"
	},
  
	//bD---> \textbf{Definition.}
	//bP---> \textbf{Proposition.}
	//bL---> \textbf{Lemma.}
	//bC---> \textbf{Corollary.}
	//bT---> \textbf{Theorem.}
	//bE---> \textbf{Example.}
	//bF---> \textbf{Fact.}
	{
	  trigger: "bD",
	  replacement: "**🐵Definition.**",
	  options: "tA"
	},
	{
	  trigger: "bP",
	  replacement: "**🐶Proposition.**",
	  options: "tA"
	},
	{
	  trigger: "bL",
	  replacement: "**🐱Lemma.**",
	  options: "tA"
	},
	{
	  trigger: "bC",
	  replacement: "**🐼Corollary.**",
	  options: "tA"
	},
	{
	  trigger: "bT",
	  replacement: "**🐷Theorem.**",
	  options: "tA"
	},
	{
	  trigger: "bE",
	  replacement: "**🐯Example.**",
	  options: "tA"
	},
	{
	  trigger: "bF",
	  replacement: "**🐇Fact.**",
	  options: "tA"
	},
  
	//QED
	{
	  trigger: "QED",
	  replacement: "■",
	  options: "tA"
	},
  
	// 空行
	{
	  trigger: "\\\\",
	  replacement: "<br>",
	  options: "wt"
	},
  
	//Spec ---> \operatorname{Spec}
	//Sch ---> \operatorname{Sch}
	//Proj ---> \operatorname{Proj}
	//GL ---> \operatorname{GL}
	//SL ---> \operatorname{SL}
	//PGL ---> \operatorname{PGL}
	//PSL ---> \operatorname{PSL}
	//Sp ---> \operatorname{Sp}
	{
	  trigger: "Spec",
	  replacement: "\\operatorname{Spec}",
	  options: "mA"
	},
	{
	  trigger: "Sch",
	  replacement: "\\operatorname{Sch}",
	  options: "mA"
	},
	{
	  trigger: "Proj",
	  replacement: "\\operatorname{Proj}",
	  options: "mA"
	},
	{
	  trigger: "GL",
	  replacement: "\\operatorname{GL}",
	  options: "mA"
	},
	{
	  trigger: "SL",
	  replacement: "\\operatorname{SL}",
	  options: "mA"
	},
	{
	  trigger: "PGL",
	  replacement: "\\operatorname{PGL}",
	  options: "mA"
	},
	{
	  trigger: "PSL",
	  replacement: "\\operatorname{PSL}",
	  options: "mA"
	},
	{
	  trigger: "Sp",
	  replacement: "\\operatorname{Sp}",
	  options: "m"
	},
  
	//sto ---> \stackrel
	{
	  trigger: "sto",
	  replacement: "\\stackrel{$0}{$1}",
	  options: "wmA"
	},
  
	//ra; ---> \rightarrow
	//Ra; ---> \Rightarrow
	//la; ---> \leftarrow
	//La; ---> \Leftarrow
	//lra; ---> \longrightarrow
	//Lra; ---> \Longrightarrow
	//lla; ---> \longleftarrow
	//Lla; ---> \Longleftarrow
	//lrla; ---> \longleftrightarrow
	//rla; ---> \leftrightarrow
	{
	  trigger: "ra;",
	  replacement: "\\rightarrow",
	  options: "mA"
	},
	{
	  trigger: "Ra;",
	  replacement: "\\Rightarrow",
	  options: "mA"
	},
	{
	  trigger: "la;",
	  replacement: "\\leftarrow",
	  options: "mA"
	},
	{
	  trigger: "La;",
	  replacement: "\\Leftarrow",
	  options: "mA"
	},
	{
	  trigger: "lra;",
	  replacement: "\\longrightarrow",
	  options: "mA"
	},
	{
	  trigger: "Lra;",
	  replacement: "\\Longrightarrow",
	  options: "mA"
	},
	{
	  trigger: "lla;",
	  replacement: "\\longleftarrow",
	  options: "mA"
	},
	{
	  trigger: "Lla;",
	  replacement: "\\Longleftarrow",
	  options: "mA"
	},
	{
	  trigger: "lrla;",
	  replacement: "\\longleftrightarrow",
	  options: "mA"
	},
	{
	  trigger: "rla;",
	  replacement: "\\leftrightarrow",
	  options: "mA"
	},
  
	//XX ---> \times
	//OX ---> \otimes
	{
	  trigger: "XX",
	  replacement: "\\times",
	  options: "mA"
	},
	{
	  trigger: "OX",
	  replacement: "\\otimes",
	  options: "mA"
	},
  
	//injective ---> \hookrightarrow
	//surjective ---> \twoheadrightarrow
	//bijective ---> \leftrightarrow
	{
	  trigger: "inj;",
	  replacement: "\\hookrightarrow",
	  options: "mA"
	},
	{
	  trigger: "suj;",
	  replacement: "\\twoheadrightarrow",
	  options: "mA"
	},
	{
	  trigger: "bij;",
	  replacement: "\\leftrightarrow",
	  options: "mA"
	},
  
	// Greek letters
	{
	  trigger: /([^\\])alpha/,
	  replacement: "[[0]]\\alpha",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])beta/,
	  replacement: "[[0]]\\beta",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])gamma/,
	  replacement: "[[0]]\\gamma",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])Gamma/,
	  replacement: "[[0]]\\Gamma",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])delta/,
	  replacement: "[[0]]\\delta",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])Delta/,
	  replacement: "[[0]]\\Delta",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])epsl/,
	  replacement: "[[0]]\\epsilon",
	  options: "rmA"
	}, //abb.
	{
	  trigger: /([^\\])vepsl/,
	  replacement: "[[0]]\\varepsilon",
	  options: "rmA",
	  priority: 1
	}, //abb.
	{
	  trigger: /([^\\])zeta/,
	  replacement: "[[0]]\\zeta",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])eta/,
	  replacement: "[[0]]\\eta",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])theta/,
	  replacement: "[[0]]\\theta",
	  options: "rmA",
	  priority: 1
	}, //conflict with eta
	{
	  trigger: /([^\\])Theta/,
	  replacement: "[[0]]\\Theta",
	  options: "rmA",
	  priority: 1
	}, //conflict with eta
	{
	  trigger: /([^\\])iota/,
	  replacement: "[[0]]\\iota",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])kappa/,
	  replacement: "[[0]]\\kappa",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])lmbd/,
	  replacement: "[[0]]\\lambda",
	  options: "rmA"
	}, //abb.
	{
	  trigger: /([^\\])Lmbd/,
	  replacement: "[[0]]\\Lambda",
	  options: "rmA"
	}, //abb.
	{
	  trigger: /([^\\])mu/,
	  replacement: "[[0]]\\mu",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])nu/,
	  replacement: "[[0]]\\nu",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])xi/,
	  replacement: "[[0]]\\xi",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])Xi/,
	  replacement: "[[0]]\\Xi",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])omic/,
	  replacement: "[[0]]\\omicron",
	  options: "rmA"
	}, //abb.
	{
	  trigger: /([^\\])pi/,
	  replacement: "[[0]]\\pi",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])Pi/,
	  replacement: "[[0]]\\Pi",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])rho/,
	  replacement: "[[0]]\\rho",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])sigma/,
	  replacement: "[[0]]\\sigma",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])Sigma/,
	  replacement: "[[0]]\\Sigma",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])tau/,
	  replacement: "[[0]]\\tau",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])upsl/,
	  replacement: "[[0]]\\upsilon",
	  options: "rmA"
	}, //abb.
	{
	  trigger: /([^\\])Upsl/,
	  replacement: "[[0]]\\Upsilon",
	  options: "rmA"
	}, //abb.
	{
	  trigger: /([^\\])phi/,
	  replacement: "[[0]]\\phi",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])Phi/,
	  replacement: "[[0]]\\Phi",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])vphi/,
	  replacement: "[[0]]\\varphi",
	  options: "rmA",
	  priority: 1
	}, //abb.
	{
	  trigger: /([^\\])chi/,
	  replacement: "[[0]]\\chi",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])psi/,
	  replacement: "[[0]]\\psi",
	  options: "rmA"
	},
	{
	  trigger: /([^\\])Psi/,
	  replacement: "[[0]]\\Psi",
	  options: "rmA",
	  priority: 1
	},
  
	// Other try
	{
	  trigger: "([^'])\\b((?![aAIie])[a-zA-Z])\\b([\\n\\s\\.,])",
	  replacement: "[[0]]$[[1]]$[[2]]",
	  options: "rtA",
	  description: "Automatically treat lone characters as math (except a, A, I)"
	},
  
	{
	  trigger: "([^\\\\])(${GREEK}|${SYMBOL})",
	  replacement: "[[0]]\\[[1]]",
	  options: "rmA",
	  description: "Add backslash before greek letters and symbols"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// Callouts
	//https://zhuanlan.zhihu.com/p/678900439
	//
	// left side callout
	{
	  trigger: "lc",
	  replacement: "> [!NOTE|aside-l]$1",
	  options: "wt"
	},
  
	// right side callout
	{
	  trigger: "rc",
	  replacement: "> [!NOTE|aside-r]$1",
	  options: "wt"
	},
  
	//Note callout
	{
	  trigger: "nc",
	  replacement: "> [!NOTE] Notes$1",
	  options: "wt"
	},
  
	//reference callout
	{
	  trigger: "ref",
	  replacement: "> [!info] Ref$1",
	  options: "wt"
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// The snippet for the Main conjuctucture
  
	// char ---> \text{char}
	{
	  trigger: "char",
	  replacement: "\\text{char}",
	  options: "mA"
	},
  
	//echi ---> \varepsilon_{\chi}
	{
	  trigger: "echi",
	  replacement: "\\varepsilon_{\\chi}",
	  options: "mA",
	  priority: 20
	},
  
	// ------------------------------------------------------------------------------------------------------------------------------
	// Z_p extension
  
	// the cyclotomic extension
	// F_p + table ---> \mathbb{Q}(\zeta_p)
	{
	  trigger: /F_{p(n(\+\d+)?)}/,
	  replacement: (match) => {
		const base = "\\mathbb{Q}\\(\\zeta_{p";
		const exponent = match[1] ? `^{${match[1]}}` : "";
		return `${base}${exponent}})`;
	  },
	  options: "m"
	},
  
	// .....................................................................................................................
	// Galois representation
	// .....................................................................................................................
  
	// Galois group GQS
	{
	  trigger: "GQS",
	  replacement: "G_{\\mathbb{Q},S}",
	  options: "mA"
	},
  
	// Frobenius element
	{
	  trigger: "Frob",
	  replacement: "\\text{Frob}",
	  options: "mA"
	}
  ]

[nape662]

My favourite often-used one for switching big and small letters at the beginning of the word by typing ## after the word:
{ trigger: /(\w+)##/, replacement: (match) => { let firstChar = match[1].charAt(0); return (firstChar === firstChar.toUpperCase() ? firstChar.toLowerCase() : firstChar.toUpperCase()) + match[1].slice(1); }, options: "trA" },

[j-finger]

Equations & Maths

These snippets only work while inside a LaTeX equation.

Equation Alignment

These snippets help align LaTeX equations by replacing = with &= and adding new line delineators.

// Equation Alignment
{trigger: "A", replacement: (sel) => {  // Align equations
     let processed = sel.replace(/=/g, "&="); // Replace with align-equals
     processed = processed.replace(/\n/g, " \\\\\n"); // Replace & delineate newlines 
     return `\\begin{align}\n${processed}\n\\end{align}`; // Wrap with align environment
   }, options: "mvA"},
{trigger: "==", replacement: "&=", options: "mA"}, // Align equals

• Usage:
  • Select the content of the equation to be aligned.
  • Press Shift+A to align the content.
• Implementation Behavior:
  • The selected text is processed by replacing every = with &=.
  • Newlines are replaced with \\ \n to properly align the equations in LaTeX.
  • The processed text is then wrapped within the \begin{align} and \end{align} environment to format it as aligned equations.

Equation Numbers

You can tag your equations with numbering using tag.

$$ \text{some equation} \tag{1} $$

{trigger: "tag", replacement: " \\tag{$0}", options:"mA"},

Units

To keep it brief, here is an example and a table summarizing the unit-related snippets.

{trigger: "mV", replacement: "\\space\\text{mV}", options: "mA"}, 

Inserts the LaTeX code for millivolts with the mV trigger.

• Usage:
  1. Type mV.

// Units
// Voltage
{trigger: "mV", replacement: "\\space\\text{mV}", options: "mA"},
{trigger: "Vol", replacement: "\\space\\text{V}", options: "mA"},
{trigger: "kV", replacement: "\\space\\text{kV}", options: "mA"},
{trigger: "VA", replacement: "\\space\\text{VA}", options: "mA"},
{trigger: "kVA", replacement: "\\space\\text{kVA}", options: "mA"},
{trigger: "MVA", replacement: "\\space\\text{MVA}", options: "mA"},
{trigger: "VAR", replacement: "\\space\\text{VAR}", options: "mA"},
{trigger: "kVAR", replacement: "\\space\\text{kVAR}", options: "mA"},
// Watts
{trigger: "mW", replacement: "\\space\\text{mW}", options: "mA"},
{trigger: "WATT", replacement: "\\space\\text{W}", options: "mA"},
{trigger: "kW", replacement: "\\space\\text{kW}", options: "mA"},
// Current
{trigger: "uA", replacement: "\\space\\mu\\text{A}", options: "mA"},
{trigger: "mA", replacement: "\\space\\text{mA}", options: "mA"},
{trigger: "Amp", replacement: "\\space\\text{A}", options: "mA"},
// Resistance
{trigger: "mOhm", replacement: "\\space\\text{m}\\ohm", options: "mA"},
{trigger: "Ohm", replacement: "\\ohm", options: "mA"},
{trigger: "kOhm", replacement: "\\space\\text{k}\\ohm", options: "mA"},
{trigger: "MOhm", replacement: "\\space\\text{M}\\ohm", options: "mA"},
// Misc
{trigger: "PU", replacement: "\\space\\text{p.u.}", options: "mA"},
{trigger: "PF", replacement: "\\space\\text{PF}", options: "mA"},
{trigger: "pfex", replacement: "\\cos(\\alpha-\\beta)", options: "mA"},
{trigger: "Hz", replacement: "\\space\\text{Hz}", options: "mA"},
{trigger: "dB", replacement: "\\space\\text{dB}", options: "mA"},
{trigger: "ST", replacement: "\\space\\text{ $0 }", options: "mA"}, // Space & Text for custom units

Trigger	Replacement	Description
mV	\\space\\text{mV}	Millivolts
Vol	\\space\\text{V}	Volts
kV	\\space\\text{kV}	Kilovolts
VA	\\space\\text{VA}	Volt-Amperes
kVA	\\space\\text{kVA}	Kilovolt-Amperes
MVA	\\space\\text{MVA}	Megavolt-Amperes
VAR	\\space\\text{VAR}	Volt-Ampere Reactive
kVAR	\\space\\text{kVAR}	Kilovolt-Ampere Reactive
mW	\\space\\text{mW}	Milliwatts
WATT	\\space\\text{W}	Watts
kW	\\space\\text{kW}	Kilowatts
uA	\\space\\mu\\text{A}	Microamperes
mA	\\space\\text{mA}	Milliamperes
Amp	\\space\\text{A}	Amperes
mOhm	\\space\\text{m}\\ohm	Milliohms
Ohm	\\ohm	Ohms
kOhm	\\space\\text{k}\\ohm	Kilohms
MOhm	\\space\\text{M}\\ohm	Megohms
PU	\\space\\text{p.u.}	Per unit
PF	\\space\\text{PF}	Power Factor
pfex	\\cos(\\alpha-\\beta)	Power Factor (example)
Hz	\\space\\text{Hz}	Hertz
dB	\\space\\text{dB}	Decibels
ST	\\space\\text{ $0 }	Space & Text

Operators

Useful operators for presentation

// Operators
{trigger: "ang", replacement: "\\angle", options: "mA"},
{trigger: "OR", replacement: "\\quad\\text{or}\\quad", options: "mA"}, // Wide OR
{trigger: "aND", replacement: "\\space\\&\\space", options: "mA"}, // Tight AND
{trigger: "AND", replacement: "\\quad\\&\\quad", options: "mA"}, // Wide AND

• Operators:
  • Angle (ang): Inserts the LaTeX code for an angle.
  • Wide OR (OR): Inserts a wide "or" text between \quad spaces.
  • Tight AND (aND): Inserts a tight & between \space spaces.
  • Wide AND (AND): Inserts a wide & between \quad spaces.

$$ \text{equation 1} \quad\text{or}\quad \text{equation 2} $$

$$ \text{equation 1} \space \text{and} \space \text{equation 2} $$

$$ \text{equation 1} \quad \text{and} \quad \text{equation 2} $$

Note: Ignore the lack of the ampersand, it works in Obsidian but isn't rendering properly on Gitub.

Text Editing

All of the following work during normal text editing, indicated by the t in options: "tA".

General Text Replacements

// Text Replacements
{trigger: "matlab", replacement: "MATLAB", options: "tA"}, // Correct to MATLAB
{trigger: "latex", replacement: "LaTeX", options: "tA"}, // Correct to LaTeX

TODO lines

{trigger: "todo", replacement: " %% TODO: $0 %%", options: "tA", priority: 2}, // insert TODO
{trigger: "J", replacement: " %% TODO: ${VISUAL} %%", options: "tA", priority: 1}, // TODO - Selected Text

• Usage
  • Either type todo and the cursor should jump into the TODO
  • Alternatively select the text for the TODO comment and hit Shift+J to wrap it in a comment

Callout Figures if you have them setup with CSS

{trigger: "F", replacement: "> [!figure] ${VISUAL}\n> **FIGURE ${0:figNumber}:** ${1:caption}", options: "tAv"}, // Figure

• Usage:
  • Select an Obsidian wikilink for an embedded image.
  • Press Shift+F to turn it into a figure callout.
  • The cursor will first move to input the figure number.
  • After entering the figure number, press Tab to move to the next entry to insert text for the caption.

Bonus 'Figure' CSS

.callout[data-callout="figure"] {
  --callout-color: 220, 220, 220;
  --callout-icon: none;

  .callout-content {
      font-size: 0.8em; 
      text-align: center;
      display: block !important;
      margin-left: auto !important;
      margin-right: auto !important;
      margin: auto auto !important;
   }
   .callout-title {
      font-size: 0.8em; 
      text-align: center;
      display: block !important;
      margin-left: auto !important;
      margin-right: auto !important;
      margin: auto auto !important;
   }
}

Repost Items

Inserting Maths Equations

Quick & easy LaTeX math equations.

{trigger: "$$", replacement: "\$$0\$", options: "tA"}, // Inline equation
{trigger: "$ $", replacement: "\$\$ $0 \$\$", options: "tA"}, // Standalone equation 

• Usage
  • Inline LaTeX equations can be generated by typing 2 dollar signs $$
  • Standalone LaTeX equations can be generated in the same manner but putting a space in-between $ $

Codeblocks

Various snippets to insert code blocks for programming languages with options for visual selection or direct cursor placement.

• Usage: MATLAB example
• Insert a MATLAB codeblock with ``m
• Alternatively to wrap the selected text in a MATLAB code block.
  1. Select the text you want to wrap in a MATLAB code block.
  2. Press M.

// Codeblocks       
// MATLAB
{trigger: "M", replacement: " ```matlab\n ${VISUAL} \n```", options: "tA"},
{trigger: "``m", replacement: " ```matlab\n $0 \n```", options: "tA"},
// Python
{trigger: "P", replacement: " ```python\n ${VISUAL} \n```", options: "tA"},
{trigger: "``p", replacement: " ```python\n $0 \n```", options: "tA"},
// powershell
{trigger: "S", replacement: " ```powershell\n ${VISUAL} \n```", options: "tA"},
{trigger: "``s", replacement: " ```powershell\n $0 \n```", options: "tA"},
// JSON
{trigger: "J", replacement: " ```json\n ${VISUAL} \n```", options: "tA"},
{trigger: "``j", replacement: " ```json\n $0 \n```", options: "tA"}, 

[YaoYYoung]

Description: Create $n \times m$ matrix quicklier.

Example:

• input: 54ff
• output: $5 \times 4$ matrix in square brackets []

    // Create n*m matrix quicklier 
    // (\d)(\d) --> row & column
    // (y|Y|f|F|h|H|d|D|n|N) --> brack style
    // lowercase <--> inline math $...$
    // uppercase <--> interline math $$...$$ 

    {trigger: /(\d)(\d)(y|Y|f|F|h|H|d|D|n|N)\3/, replacement: (match) => {
    const n = match[1];
    const m = match[2];
    const bracket = match[3];
    
    let arr = [];
    let bracketstr; // different bracket string means different LaTeX enviroment
    let output; 
    
    for (let j = 0; j < n; j++) { // Temporarily filled by 114514
        arr[j] = [];
        for (let i = 0; i < m; i++) {
            arr[j][i] = `\${${j * m + i}:114514}`; 
        }
    }
    
    switch(bracket) {
        case 'y': case 'Y': bracketstr = "pmatrix"; break; // 圆括号 yuan
        case 'f': case 'F': bracketstr = "bmatrix"; break; // 方括号 fang
        case 'h': case 'H': bracketstr = "Bmatrix"; break; // 花括号 hua
        case 'd': case 'D': bracketstr = "vmatrix"; break; // 单竖线 determinant
        case 'n': case 'N': bracketstr = "Vmatrix"; break; // 双竖线 norm
        default: bracketstr = "shit"; break; // 
    }
    
    if (bracket >= 'Z') { // lowercase <--> inline math $...$
        output = arr.map(el => el.join(" & ")).join("   \\\\   "); 
        output = `\\begin{${bracketstr}}   ${output}   \\end{${bracketstr}}\${1919810:}`;
    }
    else { // uppercase <--> interline math $$...$$ 
        output = arr.map(el => el.join("  &  ")).join("   \\\\ \n"); 
        output = `\\begin{${bracketstr}}\n${output}  \n\\end{${bracketstr}}\${1919810:}`;
    }
    
    return output;
    }, options: "rmA"},

[TheFibonacciEffect]

Most elaborate snippet I have seen to date. I didn't know that you can program inside of them. Very cool!

[YaoYYoung]

In fact, you can also append cases to the switch(bracket) block:

case 'c': case 'C': bracketstr = "cases"; break; // 🤔🥰 case (Actually, it works)

In addition, I think these triggers are sufficient for creating "table" in Markdown math enviroment. (I rarely use those tabular/... commands even in LaTeX articles.)

[firehuoyan]

对原来的优化，只有一个字母后面跟随数字才会被转换成角标。否则很多\times10之类的都会被误转换。
Optimization of the original rule: Only when a letter is followed by a number will it be converted into a subscript. Otherwise, many instances such as \times10 might get incorrectly transformed.
{"trigger": "(?<![A-Za-z])([A-Za-z])(\\d)","replacement": "[[0]]_{[[1]]}","options": "rmA","priority": -1},

对选中的改颜色，默认是红色。
Changing the color of selected text, defaulting to red。
{trigger: "R", replacement: "\\textcolor{ ${0:red} }{ ${VISUAL} }$1", options: "mA"},

两种callout的快速输入，支持输入+或-设置为默认展开或关闭。
Quick input for two types of callouts, supporting the addition of + or - to set them to default expand or collapse.
{trigger: "dy([+-]?)", replacement: "> [!abstract][[0]] ${0:Title} \n \> ${1:Contents}", options: "rt"},
{trigger: "note([+-]?)", replacement: "> [!note][[0]] ${0:Title} \n \> ${1:Contents}", options: "rt"},

[YaoYYoung]

1. If you want to apply red/orange to some math formula, you can select it and press 1/2;
2. If you want to remove the applied color (let's say red), you can select the entire brace content like {\color{red} ... } which was selected by default after you applied the color, and then press 1;
3. If you want to change the applied color (let's say red -> orange), you can select the same content and press 2

In my humble opinion, these two colors are sufficient for my requirements for math highlighting.

// 1-red
// 2-orange
{trigger: "1", replacement: (sel) =>{
	const color_new = "red"; 
	const color_old_1 = "orange";
	const color_prefix = /\\color{\b[^{\s{}]*\b}/g; 

	if (sel.match(color_prefix)) {
		if (sel.includes(color_old_1)) 
			return sel.replace(color_old_1, color_new); 
		sel = sel.replace(color_prefix, ""); 
		sel = sel.replace(/{\s+(.*)\s+}/g, "$1");
		return sel; 
	}
	else {
		return "{\\color{" + color_new + "} " + sel + " }"; 
	}
}, options: "mvA"}, 

{trigger: "2", replacement: (sel) =>{
	const color_new = "orange";
	const color_old_1 = "red"; 
	const color_prefix = /\\color{\b[^{\s{}]*\b}/g; 

	if (sel.match(color_prefix)) {
		if (sel.includes(color_old_1)) 
			return sel.replace(color_old_1, color_new); 
		sel = sel.replace(color_prefix, ""); 
		sel = sel.replace(/{\s+(.*)\s+}/g, "$1");
		return sel; 
	}
	else {
		return "{\\color{" + color_new + "} " + sel + " }"; 
	}
}, options: "mvA"}, 

[OlegSea]

Here are some of my snippets that I find cool:

Alignment related stuff

{trigger: "adm", replacement: "$$\n\\begin{flalign}\n$0&&\n\\end{flalign}\n$$", options: "tAw"}, // start a Display math block with left alignment
{trigger: "A", replacement: "\\begin{flalign}\n${VISUAL}&&\n\\end{flalign}", options: "mA"}, // align visual
{trigger: "flalign", replacement: "\\begin{flalign}\n$0\n\\end{flalign}", options: "mA"}, // just a flalign

Modes

{trigger: "M", replacement: "$${VISUAL}$", options: "tA"}, // change display mode for visual
{trigger: "D", replacement: "$$${VISUAL}$$", options: "tA"},

Tag related stuff

In our lectures, we often use LaTeX tags in order to reuse stuff, so I added snippets to quickly do that

// enter Display Math mode with a tag and a ^ thingy attached to it
{trigger: "tdm", replacement: "$$\n$1\n\\tag{$0}$$\n^$0", options: "tA"},
// add a tag (will replace "tag" in math mode with "\tag{type here}"
{trigger: "tag", replacement: "\\tag{$0}$1", options: "mA"},
// add an equivalent to a tag in text mode (will just type "(number)" and add a ^ thingy to it)
{trigger: "((\\d)+)tg", replacement: "$([[0]])$^[[0]]", options: "rA"},
// easily link tags (will create a link to a ^ thingy)
{trigger: "((\\d)+)lk", replacement: "\[\[#^[[0]]\]\]", options: "rA"},

Math operations

{trigger: "ulim", replacement: "\\overline{\\lim}_{ ${0:n} \\to ${1:\\infty} } $2", options: "mA"}, // upper limit
{trigger: "llim", replacement: "\\underline{\\lim}_{ ${0:n} \\to ${1:\\infty} } $2", options: "mA"}, // lower limit
{trigger: "nthr", replacement: "\\sqrt[${0:n}]{ $1 }$2", options: "mA"}, // nth root
{trigger: "nthd", replacement: "{$0}^{(${1:n})}", options: "mA"}, // nth derivative

Other symbols

{trigger: "ne\\xi sts", replacement: "\\ \\ \\nexists", options: "mA", priority: 1}, // does not exist
{trigger: "qed", replacement: "$\\blacksquare$", options: "t"}, // q.e.d., uses amsmath
{trigger: "bs", replacement: "\\ \\ ", options: "m"}, // big space lmao
{trigger: "<=>", replacement: "\\iff", options: "mA"}, // \iff
{trigger: "seq", replacement: "\\{ $0 \\}$1", options: "mA"}, // sequence

[FairyHmm]

Some useful snippets I use

Most of these snippets use regex as the trigger, and js as the replacement, returning tabstops, as I have no idea how to achieve what I want otherwise. Though, as I'm not terribly well versed in both regex and js, someone can definitely improve on these

Matrices

Create an n by m matrix, use tab to go to the next tabstop

{
    trigger: /(\d)(\d)([p|b|B|v|V]?)mat/,
    replacement: (match) => {
        const n = match[1], m = match[2], c = match[3];
        
        let arr = [];
        for (let j = 0; j < n; j++) {
            arr[j] = [];
            for (let i = 0; i < m; i++) {
                arr[j][i] = `\${${i + j * m}:${String.fromCharCode(97 + i + j * m)}}`;
            }
        }
        
        let output = arr.map((el) => el.join(" & ")).join(" \\\\\n");
        output = `\\begin{${c}matrix}\n${output} \n\\end{${c}matrix}`;
        return output;
    },
    options: "MA",
    description: "N x M matrix",
},

{
    trigger: /(\d)(\d)([p|b|B|v|V]?)mat/,
    replacement: (match) => {
        const n = match[1], m = match[2], c = match[3];
        
        let arr = [];
        for (let j = 0; j < n; j++) {
            arr[j] = [];
            for (let i = 0; i < m; i++) {
                arr[j][i] = `\${${i + j * m}:${String.fromCharCode(97 + i + j * m)}}`;
            }
        }
        
        let output = arr.map((el) => el.join(" & ")).join(" \\\\ ");
        output = `\\begin{${c}matrix} ${output} \\end{${c}matrix}`;
        return output;
    },
    options: "nA",
    description: "N x M matrix",
},

So when I write 33bmat, it will return

\begin{bmatrix}
a & b & c \\
d & e & f \\
g & h & i 
\end{bmatrix}

And 24mat will return

\begin{matrix}
a & b & c & d \\
e & f & g & h 
\end{matrix}

It has a few bugs, such as not supporting more than 26 elements (I could fix it, but decided not to because I don't usually see matrices bigger than 5 by 5, which is 25 elements)

Subscripts/Superscripts

{
    trigger: /\^([a-zA-Z0-9]{2,})/,
    replacement: (match) => { 
        return `\^{${match[1]}\$0}`;
    },
    options: "rmA",
},
{
    trigger: "_([a-zA-Z0-9]{2,})",
    replacement: (match) => { 
        return `_{${match[1]}\$0}`;
    },
    options: "rmA",
},

It allows single character after ^ or _, while automatically wraps curly braces around when I add another character (a^12 to a^{12})

{ trigger: "++", replacement: "^+", options: "mA" },
{ trigger: "--", replacement: "^-", options: "mA" },

Useful when working with limits

nth root

{
    trigger: "([0-9|n|m|k]{1,})sq",
    replacement: (match) => { 
        return `\\sqrt[${match[1]}]{ $0 }`;
    },
    options: "rmA",
},
{
    trigger: ";sq",
    replacement: (match) => { 
        return `\\sqrt[\$0]{ $1 }`;
    },
    options: "rmA",
},

32sq -> \sqrt[32]{ }, nsq -> \sqrt[n]{ }

Entering nth root with the default snippet is kinda clunky

Arrows

{ trigger: "->", replacement: "\\rightarrow", options: "mA" },
{ trigger: "<-", replacement: "\\leftarrow", options: "mA" },
{ trigger: "<->", replacement: "\\leftrightarrow ", options: "mA" },
{ trigger: "-^", replacement: "\\uparrow", options: "mA" },
{ trigger: "-v", replacement: "\\downarrow", options: "mA" },
{ trigger: "^-v", replacement: "\\updownarrow", options: "mA" },
{ trigger: "v-^", replacement: "\\updownarrow", options: "mA" },
{ trigger: "=>", replacement: "\\Rightarrow", options: "mA" },
{ trigger: "=<", replacement: "\\Leftarrow", options: "mA" },
{ trigger: "<=>", replacement: "\\Leftrightarrow", options: "mA" },
{ trigger: "\\leq>", replacement: "\\Leftrightarrow", options: "mA" },
{ trigger: "=^", replacement: "\\Uparrow", options: "mA" },
{ trigger: "=v", replacement: "\\Downarrow", options: "mA" },
{ trigger: "^=v", replacement: "\\Updownarrow", options: "mA" },
{ trigger: "v=^", replacement: "\\Updownarrow", options: "mA" },
{ trigger: "|->", replacement: "\\mapsto", options: "mA" },
{ trigger: "|-->", replacement: "\\longmapsto", options: "mA" },
{ trigger: "/>", replacement: "\\nearrow", options: "mA" },
//{trigger: "/^", replacement: "\\nearrow", options: "mA"},
{ trigger: "\\>", replacement: "\\searrow", options: "mA" },
//{trigger: "\\v", replacement: "\\searrow", options: "mA"},
{ trigger: "</", replacement: "\\swarrow", options: "mA" },
//{trigger: "v/", replacement: "\\swarrow", options: "mA"},
{ trigger: "<\\", replacement: "\\nwarrow", options: "mA" },
//{trigger: "^\\", replacement: "\\nwarrow", options: "mA"},

I don't use most of these, but might as well do everything in one go