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"}, 

[sahjaldu]

I've changed the figure snippet so that it checks whether "![[]]" is included in the snippet before if applies the replacement.

{
trigger: "F", replacement: (sel) => {
    let index = 0;
    for (let char of "![[]]") {
        index = sel.indexOf(char);
        if (index === -1) {
            return sel;
        }
        index += 1;
    }
    return "> [!figure] "+sel+"\n> **FIGURE ${0:figNumber}:** ${1:caption}";
},
 options: "tAv"
},

[LynetteCullens]

Units belong in a Physical Unit environment. That is what \pu is for. Using the correct syntax to place units will eliminate your need to add a space before expressing the unit. ex: \pu{12kg//mol} will render with a space and automatically convert to fraction.

[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

[Mistera91]

This is just the idea. For real life shortcuts (that I use), you can see one of my replies to this message (I’ll try to keep the reply up-to-date with what I use).

I made this JS + visual shortcut to call sympy :

{
    trigger: "s",
    replacement: (sel) => {
        return require('child_process').execSync(`python -c "

#import numpy as np
import sys
sys.set_int_max_str_digits(2**31-1)

# This is like running sympy.init_session(), but without the printed lines
from sympy import *
a, b, c, d, x, y, z, t = symbols('a b c d x y z t')
k, m, n, o, p, q, r, s = symbols('k m n o p q r s', integer=True)
f, g, h = symbols('f g h', cls=Function)
init_printing()

pl = lambda x: print(latex(x)) # Alias to print in LaTeX format

pl(${sel})
# Alternative versions
# pl(factor(${sel}))
# pl(expand(${sel}))
# pl(simplify(${sel}))
"`).toString().trim()
    },
    options: "v"
}

For example, you can type « a + a », then select this text and press the s key to obtain « 2 a ».
Another example is if you want to solve an equation, you can type « $solve(x**2 + x + 1)$ », select the text in-between the dollars, and you will have the solution of the equation.

This can also lead to more specific shortcuts like one to call sympy.factor() or sympy.expand() or sympy.symplify(), don’t hesitate to adapt this as you need it !

I also recommend to use the latex2sympy2 pip package, for obvious reasons.

[Mistera91]

The « v » option stands for « visual ». Basically it’s like when you select some text and press the opening parenthesis key, it surround the text with parenthesis. You can learn more about the visual option here.
If it doesn’t work for you, then you probably are missing some requirement, like python or sympy. You can open the developer console to debug this issue using Ctrl + Shift + I.

[Mistera91]

Quick update :
I spent a few hours with these and had some time to play around, and here is what I finally came up with :

Shortcuts

    // LaTeX to Python
    {
        trigger: "p",
        replacement: (sel) => {
            return require('child_process').execSync(`python -c "
#import numpy as np
import sys
sys.set_int_max_str_digits(2**31-1)
from latex2sympy2 import latex2sympy
from sympy import *
a, b, c, d, x, y, z, t, alpha, beta, gamma, delta, epsilon = symbols('a b c d x y z t alpha beta gamma delta epsilon')
k, m, n, o, p, q, r, s = symbols('k m n o p q r s', integer=True)
f, g, h = symbols('f g h', cls=Function)
init_printing()
pl = lambda x: print(latex(x))
print(latex2sympy('''${JSON.stringify(JSON.stringify(sel).slice(1, -1)).slice(1, -1)}'''))
"`).toString().trim()
        },
        options: "v"
    },
    // Sympy simplify
    {
        trigger: "s",
        replacement: (sel) => {
            return require('child_process').execSync(`python -c "
#import numpy as np
import sys
sys.set_int_max_str_digits(2**31-1)
from latex2sympy2 import latex2sympy
from sympy import *
a, b, c, d, x, y, z, t, alpha, beta, gamma, delta, epsilon = symbols('a b c d x y z t alpha beta gamma delta epsilon')
k, m, n, o, p, q, r, s = symbols('k m n o p q r s', integer=True)
f, g, h = symbols('f g h', cls=Function)
init_printing()
pl = lambda x: print(latex(x))
pl(simplify(latex2sympy('''${JSON.stringify(JSON.stringify(sel).slice(1, -1)).slice(1, -1)}''')))
"`).toString().trim()
        },
        options: "v"
    },
    // Sympy expand
    {
        trigger: "e",
        replacement: (sel) => {
            return require('child_process').execSync(`python -c "
#import numpy as np
import sys
sys.set_int_max_str_digits(2**31-1)
from latex2sympy2 import latex2sympy
from sympy import *
a, b, c, d, x, y, z, t, alpha, beta, gamma, delta, epsilon = symbols('a b c d x y z t alpha beta gamma delta epsilon')
k, m, n, o, p, q, r, s = symbols('k m n o p q r s', integer=True)
f, g, h = symbols('f g h', cls=Function)
init_printing()
pl = lambda x: print(latex(x))
pl(expand(latex2sympy('''${JSON.stringify(JSON.stringify(sel).slice(1, -1)).slice(1, -1)}''')))
"`).toString().trim()
        },
        options: "v"
    },
    // Sympy factor
    {
        trigger: "f",
        replacement: (sel) => {
            return require('child_process').execSync(`python -c "
#import numpy as np
import sys
sys.set_int_max_str_digits(2**31-1)
from latex2sympy2 import latex2sympy
from sympy import *
a, b, c, d, x, y, z, t, alpha, beta, gamma, delta, epsilon = symbols('a b c d x y z t alpha beta gamma delta epsilon')
k, m, n, o, p, q, r, s = symbols('k m n o p q r s', integer=True)
f, g, h = symbols('f g h', cls=Function)
init_printing()
pl = lambda x: print(latex(x))
pl(factor(latex2sympy('''${JSON.stringify(JSON.stringify(sel).slice(1, -1)).slice(1, -1)}''')))
"`).toString().trim()
        },
        options: "v"
    },
    // Python to LaTeX
    {
        trigger: "l",
        replacement: (sel) => {
            return require('child_process').execSync(`python -c "
#import numpy as np
import sys
sys.set_int_max_str_digits(2**31-1)
from latex2sympy2 import latex2sympy
from sympy import *
a, b, c, d, x, y, z, t, alpha, beta, gamma, delta, epsilon = symbols('a b c d x y z t alpha beta gamma delta epsilon')
k, m, n, o, p, q, r, s = symbols('k m n o p q r s', integer=True)
f, g, h = symbols('f g h', cls=Function)
init_printing()
pl = lambda x: print(latex(x))
pl(${sel})
"`).toString().trim()
        },
        options: "v"
    }

• The « p » key is used to convert some LaTeX code to a sympy expression
• The « s » key is used to simplify some LaTeX code using sympy (it does the conversion to sympy, then back again to LaTeX)
• The « e » key is used to expand some LaTeX code (for example, (a + b)(a - b) will become a^{2} - b^{2})
• The « f » key is used to factor some LaTeX code (the opposite of the last one)
• The « l » key is used to convert python expressions (usually sympy expressions, but it will be evaluated and then put inside sympy’s latex function (you can for example achieve the same result of the two previous shortcuts by converting your LaTeX formula into python using the « p » key, then surround it with the expand() or factor() function, and use the « l » key to evaluate everything)) into LaTeX

It may be hard to read and hard to accommodate to, but as usual, feel free to change them as you want.

[vasopatejdl]

Hey, man thanks for the great suggestion, but I can't get it to work. I have python, latex2sympy2, when I run the command in the terminal it works fine, but when it's run from a snippet it doensn't. I am wondering if you might have a plugin that allows you to run those scripts.

Command failed: python3.11 "
#import numpy as np
import sys
sys.set_int_max_str_digits(2**31-1)
from latex2sympy2 import latex2sympy
from sympy import *
a, b, c, d, x, y, z, t, alpha, beta, gamma, delta, epsilon = symbols('a b c d x y z t alpha beta gamma delta epsilon')
k, m, n, o, p, q, r, s = symbols('k m n o p q r s', integer=True)
f, g, h = symbols('f g h', cls=Function)
init_printing()
pl = lambda x: print(latex(x))
pl(simplify(latex2sympy('''a + b''')))
"
/bin/sh: line 12: python3.11: command not found

This is from the Obsidian console.

[Mistera91]

/bin/sh: line 12: python3.11: command not found

You might have to provide the absolute path of your python binary. I have no other extensions than Latex suite.

[vasopatejdl]

/bin/sh: line 12: python3.11: command not found

You might have to provide the absolute path of your python binary. I have no other extensions than Latex suite.

Yep, that fixed it, I recommend you look at this https://github.com/OrangeX4/Latex-Sympy-Calculator, if you want more inspo for snippets.

[YaoYYoung]

I couldn't notice that I had written a whole set of arrow snippets in math and text option seperately.

{trigger: "lla", replacement: "$\\longleftarrow$ ",  options: "tA"}, // <--
{trigger: "Lla", replacement: "$\\Longleftarrow$ ",  options: "tA"}, // <==
{trigger: "lra", replacement: "$\\longrightarrow$ ", options: "tA"}, // -->
{trigger: "Lra", replacement: "$\\Longrightarrow$ ", options: "tA"}, // ==>

{trigger: "<--", replacement: "$\\longleftarrow$ ",  options: "t"}, // <--
{trigger: "<==", replacement: "$\\Longleftarrow$ ",  options: "t"}, // <==
{trigger: "-->", replacement: "$\\longrightarrow$ ", options: "t"}, // -->
{trigger: "==>", replacement: "$\\Longrightarrow$ ", options: "t"}, // ==>

{trigger: "llra", replacement: "$\\longleftrightarrow$ ", options: "tA"}, // <-->
{trigger: "Llra", replacement: "$\\Longleftrightarrow$ ", options: "tA"}, // <==>
{trigger: "<-->", replacement: "$\\longleftrightarrow$ ", options: "t"},  // <-->
{trigger: "<==>", replacement: "$\\Longleftrightarrow$ ", options: "t"},  // <==>

{trigger: "(!|N|n)lla",  replacement: "$\\cancel{ \\longleftarrow }$ ",  options: "rtA"},     // ⛔<--
{trigger: "(!|N|n)Lla",  replacement: "$\\cancel{ \\Longleftarrow }$ ",  options: "rtA"},     // ⛔<==
{trigger: "(!|N|n)lra",  replacement: "$\\cancel{ \\longrightarrow }$ ", options: "rtA"},     // ⛔-->
{trigger: "(!|N|n)Lra",  replacement: "$\\cancel{ \\Longrightarrow }$ ", options: "rtA"},     // ⛔==>
{trigger: "(!|N|n)llra", replacement: "$\\cancel{ \\longleftrightarrow }$ ", options: "rtA"}, // ⛔<-->
{trigger: "(!|N|n)Llra", replacement: "$\\cancel{ \\Longleftrightarrow }$ ", options: "rtA"}, // ⛔<==>

{trigger: ";la", replacement: "\\leftarrow", options: "mA"},           //  ->
{trigger: "lla", replacement: "\\longleftarrow", options: "mA"},       // -->
{trigger: "Lla", replacement: "\\Longleftarrow", options: "mA"},       // ==>

{trigger: ";ra", replacement: "\\rightarrow", options: "mA"},          // <-
{trigger: "lra", replacement: "\\longrightarrow", options: "mA"},      // <--
{trigger: "Lra", replacement: "\\Longrightarrow", options: "mA"},      // <==

{trigger: ";lra", replacement: "\\leftrightarrow", options: "mA"},     // <->
{trigger: "llra", replacement: "\\longleftrightarrow", options: "mA"}, // <-->
{trigger: "Llra", replacement: "\\Longleftrightarrow", options: "mA"}, // <==>

{trigger: "(!|N|n)Lra", replacement: "\\cancel{ \\Longrightarrow } ", options: "rmA"},      // ⛔==>
{trigger: "(!|N|n)Lla", replacement: "\\cancel{ \\Longleftarrow } ", options: "rmA"},       // ⛔<==
{trigger: "(!|N|n)Llra", replacement: "\\cancel{ \\Longleftrightarrow } ", options: "rmA"}, // ⛔<==>

{trigger: "(!|N|n)lra", replacement: "\\cancel{ \\longrightarrow } ", options: "rmA"},      // ⛔-->
{trigger: "(!|N|n)lla", replacement: "\\cancel{ \\longleftarrow } ", options: "rmA"},       // ⛔<--
{trigger: "(!|N|n)llra", replacement: "\\cancel{ \\longleftrightarrow } ", options: "rmA"}, // ⛔<==>

These snippets are time-saving, concise and of high-efficiency, of which I can't help using arrows to substitue other frequently-used "conjuction-words" (so, because, and then, that's why, which is (not) equivalent/equal to...).

So, what kind of "wastes" time is that I have to change the direction and "double-single line" style of the existing arrow.

Preliminary and simple though, the following snippets can change the direction and "double-single line" style of selected arrow by only pressing 1-2 keys.

{trigger: "r", replacement: (sel) =>{
	if (sel.match("longright")) {sel = sel.replace("longright","Longright"); return sel; }
	if (sel.match("Longright")) {sel = sel.replace("Longright","longright"); return sel; }
	
	sel = sel.replace("Left","Right");
	sel = sel.replace("left","right");
	
	return sel; 
}, options: "mvA"}, 

{trigger: "l", replacement: (sel) =>{
	if (sel.match("longleft")) {sel = sel.replace("longleft","Longleft"); return sel; }
	if (sel.match("Longleft")) {sel = sel.replace("Longleft","longleft"); return sel; }
	
	sel = sel.replace("Right","Left");
	sel = sel.replace("right","left");
	
	return sel; 
}, options: "mvA"}, 

[YaoYYoung]

I simplified my math arrow snippets into these two, which do not include triggers in the t option such as --> ==>.

{trigger: /(!|N|n|c|C|x|X)*(L|l|;|u|d)(lr|l|r)a/, replacement: (match) => {
	let cancel = match[1]; 
	let style = match[2]; 
	let direction = match[3]; 
	let cancel_prefix; 
	let cancel_suffix; 

	switch (cancel) { 
		case "!": case "N": case "n": case "c": case "C": { 
			cancel_prefix = "$\\cancel{ "; 
			cancel_suffix = " }$ "; 
			break; 
		} 
		case "x": case "X": { 
			cancel_prefix = "$\\xcancel{ "; 
			cancel_suffix = " }$ "; 
			break; 
		} 
		default: { 
			cancel_prefix = "$"; 
			cancel_suffix = "$ "; 
		} 
	} 

	switch (direction) { 
		case "lr": { direction = "leftright"; break; } 
		case "l":  { direction = "left";      break; } 
		case "r":  { direction = "right";     break; } 
	} 

	switch (style) { 
		case "L": { style = "\\Long"; break; } 
		case "l": { style = "\\long"; break; } 
		case ";": { style = "\\"; break; } 
		case "u": { 
			if (direction == "right") {style = "\\ne"; direction = ""; } 
			if (direction == "left")  {style = "\\nw"; direction = ""; } 
			if (direction == "leftright")  style = "\\"; 
			break; 
		} 
		case "d": { 
			if (direction == "right") {style = "\\se"; direction = ""; } 
			if (direction == "left")  {style = "\\sw"; direction = ""; } 
			if (direction == "leftright")  style = "\\"; 
			break; 
		} 
	} 

	return cancel_prefix + style + direction + "arrow" + cancel_suffix; 

}, options: "rtA"}, 

{trigger: /(!|N|n|c|C|x|X)*(L|l|;|u|d)(lr|l|r)a/, replacement: (match) => {
	let cancel = match[1]; 
	let style = match[2]; 
	let direction = match[3]; 
	let cancel_prefix; 
	let cancel_suffix; 

	switch (cancel) { 
		case "!": case "N": case "n": case "c": case "C": { 
			cancel_prefix = "\\cancel{ "; 
			cancel_suffix = " }"; 
			break; 
		} 
		case "x": case "X": { 
			cancel_prefix = "\\xcancel{ "; 
			cancel_suffix = " }"; 
			break; 
		} 
		default: { 
			cancel_prefix = ""; 
			cancel_suffix = ""; 
		} 
	} 

	switch (direction) { 
		case "lr": { direction = "leftright"; break; } 
		case "l":  { direction = "left";      break; } 
		case "r":  { direction = "right";     break; } 
	} 

	switch (style) { 
		case "L": { style = "\\Long"; break; } 
		case "l": { style = "\\long"; break; } 
		case ";": { style = "\\"; break; } 
		case "u": { 
			if (direction == "right") {style = "\\ne"; direction = ""; } 
			if (direction == "left")  {style = "\\nw"; direction = ""; } 
			if (direction == "leftright")  style = "\\"; 
			break; 
		} 
		case "d": { 
			if (direction == "right") {style = "\\se"; direction = ""; } 
			if (direction == "left")  {style = "\\sw"; direction = ""; } 
			if (direction == "leftright")  style = "\\"; 
			break; 
		} 
	} 

	return cancel_prefix + style + direction + "arrow" + cancel_suffix; 

}, options: "rmA"}, 

[YaoYYoung]

Combining with Highlightr plugin, I wrote Visual-Highlight-Emoji.js to streamline the process of adding, changing and removing frequently-used highlights and emoji annotations.

https://gist.github.com/YaoYYoung/926e9152ac93857fda874050a9d9ee6e

But the issue in this file is that the constant values in similar function snippets are the same, causing snippet lines to expand unexpectedly, which I am working to resolve.

Here is a demo video:

emoji-highlight.mp4

[Inc44]

Giga Align Snippet: Because Regular Alignment is for Mortals

Behold, my magnum opus: the Giga Align Snippet. Why settle for basic alignment when you can have a snippet that over-engineers the process to the point of existential dread? This snippet doesn't just align equations—it aligns your soul (or at least tries to).

{
	trigger: "A",
	replacement: (sel) =>
	{
		const config = {
			operators:
			{
				basic: ['=', '>', '<'],
				latex: ['\\geq', '\\iff', '\\impliedby', '\\implies', '\\in', '\\leq', '\\neq'],
				special: ['\\int', '\\prod', '\\sum']
			},
			templates:
			{
				align: (content) => `$$\n\\begin{align}\n${content}\n\\end{align}\n$$`
			}
		};
		const utils = {
			getAllOperators()
			{
				return [...config.operators.basic, ...config.operators.latex];
			},
			createOperatorPattern()
			{
				const operators = this.getAllOperators()
					.map(op => op.replace(/\\/g, '\\\\'));
				return new RegExp(`(?:\\$\\$[^$]+\\$\\$|\\$[^$]+\\$)`, 'g');
			},
			isWithinSpecialOperator(str, pos)
			{
				return config.operators.special.some(op =>
				{
					const opIndex = str.lastIndexOf(op, pos);
					if (opIndex === -1) return false;
					let bracketCount = 0;
					for (let i = opIndex; i < str.length; i++)
					{
						if (str[i] === '{') bracketCount++;
						if (str[i] === '}') bracketCount--;
						if (bracketCount === 0 && i >= pos) return true;
					}
					return false;
				});
			},
			formatEquation(equation)
			{
				equation = equation.replace(/^\$\$?\s*|\s*\$\$?$/g, '');
				const lines = equation.split(/(?:\\\\)?\s*\n\s*|\s*\\\\\s*/);
				let result = lines.map(line =>
				{
					let processed = line.trim();
					let firstOp = null;
					let firstOpIndex = Infinity;
					for (const op of this.getAllOperators())
					{
						const index = processed.indexOf(op);
						if (index !== -1 && index < firstOpIndex)
						{
							firstOpIndex = index;
							firstOp = op;
						}
					}
					if (firstOp && !this.isWithinSpecialOperator(processed, firstOpIndex))
					{
						processed = processed.replace(firstOp, `&${firstOp}`);
					}
					return processed;
				});
				return result;
			},
		};
		const processEquations = (sel) =>
		{
			const pattern = utils.createOperatorPattern();
			const matches = sel.match(pattern);
			if (!matches) return null;
			const allEquations = matches.flatMap(eq => utils.formatEquation(eq));
			const formattedEquations = allEquations.filter(eq => eq.trim())
				.map((eq, index, arr) => `${eq}${index < arr.length - 1 ? ' \\\\' : ''}`)
				.join('\n');
			return config.templates.align(formattedEquations);
		};
		return processEquations(sel);
	},
	options: "tvA"
}

Features:

• Overkill operator handling because why just align $=$ when you can also align $\iff$, $\leq$, $\geq$, $\implies$, and every other operator you’ve never used in your life?
• It knows when you're inside a $\sum$, $\prod$, or $\int$ and politely refuses to mess with your brackets. Truly, a snippet with manners.
• A regex so convoluted, it might summon Cthulhu if you stare at it too long. But hey, it works (probably).

Usage:

1. Trigger it with "A" because, obviously, this snippet is the Alpha of all alignment snippets.
2. Feed it your chaotic LaTeX equations, and it will spit out beautifully aligned chaos.
3. Bask in the glory of your perfectly aligned equations while wondering if you’ve gone too far.

Disclaimer:

• May cause mild headaches, existential crises, or an uncontrollable urge to refactor.
• Not responsible for any LaTeX gods you may anger in the process.

Example:

Giga Mess
$x=4$
extra mess
$y=3$
$z=2$boi
$\iff \sum_{k=0}^{n} a_{i}$
$$\implies \prod_{i=1}^{\infty}$$
$\neq \int_{4}^{x=x^{2}} \log x , dx$baba
$\leq 1\geq$
AAAAA

Result:

$$ \begin{align} x&=4 \\ y&=3 \\ z&=2 \\ &\iff \sum_{k=0}^{n} a_{i} \\ &\implies \prod_{i=1}^{\infty} \\ &\neq \int_{4}^{x=x^{2}} \log x , dx \\ &\leq 1\geq \end{align} $$

[Inc44]

Ah, yes, my initial small snippet was edited in order to question my inability to leave well enough alone and finally align with my life choices (though poorly, I might add). This over-engineered mess forced me into an uncontrollable spiral of despair, culminating in a rewrite of the core replacement mechanism. Why? Because the original bugs were so catastrophic, they nearly made math itself extinct. But hey, at least now it supports multiline math. Progress, right? Or maybe just Stockholm syndrome. Either way, you're welcome.