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.

[Deede24]

Bit late but: (Note: There is an issue with space bar presses getting after \commands.)

    {
  trigger: /\\([a-zA-Z]+)\s/, // Regex to match LaTeX-style Greek commands like \alpha, \beta, etc.
  replacement: (match) => {
    const greekToUnicode = {
      alpha: '\u03B1',
      beta: '\u03B2',
      gamma: '\u03B3',
      Gamma: '\u0393',
      delta: '\u03B4',
      Delta: '\u0394',
      epsilon: '\u03B5',
      varepsilon: '\u03B5', // Alternate form
      zeta: '\u03B6',
      eta: '\u03B7',
      theta: '\u03B8',
      vartheta: '\u03D1', // Alternate form
      Theta: '\u0398',
      iota: '\u03B9',
      kappa: '\u03BA',
      lambda: '\u03BB',
      Lambda: '\u039B',
      mu: '\u03BC',
      nu: '\u03BD',
      xi: '\u03BE',
      omicron: '\u03BF',
      pi: '\u03C0',
      rho: '\u03C1',
      varrho: '\u03F1', // Alternate form
      sigma: '\u03C3',
      Sigma: '\u03A3',
      tau: '\u03C4',
      upsilon: '\u03C5',
      Upsilon: '\u03A5',
      phi: '\u03C6',
      varphi: '\u03D5', // Alternate form
      Phi: '\u03A6',
      chi: '\u03C7',
      psi: '\u03C8',
      omega: '\u03C9',
      Omega: '\u03A9',
    };

    const greekName = greekToUnicode[match[1]]; // Extract the matched Greek name
    return (greekName || match[0]) + " "; // Replace with Unicode or fallback to original text
  },
  options: "rA", // Regex + Auto-expand
},

[YaoYYoung]

Bit late but:

    {
  trigger: /\\?([a-zA-Z]+)\s/, // Regex to match LaTeX-style Greek commands like \alpha, \beta, etc.
  replacement: (match) => {
    const greekToUnicode = {
      alpha: '\u03B1',
      beta: '\u03B2',
      gamma: '\u03B3',
      Gamma: '\u0393',
      delta: '\u03B4',
      Delta: '\u0394',
      epsilon: '\u03B5',
      varepsilon: '\u03B5', // Alternate form
      zeta: '\u03B6',
      eta: '\u03B7',
      theta: '\u03B8',
      vartheta: '\u03D1', // Alternate form
      Theta: '\u0398',
      iota: '\u03B9',
      kappa: '\u03BA',
      lambda: '\u03BB',
      Lambda: '\u039B',
      mu: '\u03BC',
      nu: '\u03BD',
      xi: '\u03BE',
      omicron: '\u03BF',
      pi: '\u03C0',
      rho: '\u03C1',
      varrho: '\u03F1', // Alternate form
      sigma: '\u03C3',
      Sigma: '\u03A3',
      tau: '\u03C4',
      upsilon: '\u03C5',
      Upsilon: '\u03A5',
      phi: '\u03C6',
      varphi: '\u03D5', // Alternate form
      Phi: '\u03A6',
      chi: '\u03C7',
      psi: '\u03C8',
      omega: '\u03C9',
      Omega: '\u03A9',
    };

    const greekName = match[1]; // Extract the matched Greek name
    return (greekToUnicode[greekName] || match[0]) + " " ; // Replace with Unicode or fallback to original text
  },

It seems to miss the tail , options: "rmA"}, .

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

[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.

[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.

[Quantodeluz]

It erases everyhing when i press s
No errors on console
The simplify sippet:

    // Sympy simplify
    {
        trigger: "s",
        replacement: (sel) => {
            return require('child_process').execSync(`py -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"
    },```

[Mistera91]

It erases everyhing when i press s No errors on console The simplify sippet:

I have no idea how it could be doing this.
Is there an « s » after everything is erased or is there nothing ? Can you try to ensure the python is getting ran (for example, you can replace « import » by « imp.rt » so that an error will be shown in the obsidian console).

[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.

[GeoffClements]

Making square root a little more ergonomic (IMHO)

{
    trigger: "([2-9|n|m|k]?)sqr", replacement: (match) => {
        let order = match[1];

        if (order != "") order = `[${order}]`;
        return "\\sqrt" + order + "{$0}";
    },
    options: "rmA"
},

[mattyrot]

This in my humble opinion, is the peak of LaTeX (and maybe even society as a whole):

 {trigger: "\\sus", replacement: "ඞ", options: "mA"}

[xiyou1994]

What is ඞ mean?

[neonash7777]

What is ඞ mean?
Looks like the "Among Us" character, which is correlated with 'sus' - It's pretty clever and cute!

[Quantodeluz]

My logic operator snippets:

	{trigger: "ng", replacement: "\\neg", options: "mA"},
	{trigger: "nt", replacement: "\\lnot", options: "mA"},
	{trigger: "land", replacement: "\\wedge", options: "mA"},
	{trigger: "nand", replacement: "\\barwedge", options: "mA"},
	{trigger: "lor", replacement: "\\vee", options: "mA"},
	{trigger: "nor", replacement: "\\bar{\\vee}", options: "mA"},
	{trigger: "xor", replacement: "\\barvee", options: "mA"},
	{trigger: "xnor", replacement: "\\bar{\\veebar}", options: "mA"},```

[Quantodeluz]

Ok, this is it. I'm fed up of having to go to the config and scroll all the way to the place where that single snippet i'm testing is.
I reordered the default snippets into 10 tidy files.
No changes whatsoever, just organization (and replacing the tutorial comments bc let's be fair: you already know that)
LaTeX snippets.zip
I'm open to suggestions on the classification, bc i probably did some dumb choices when organizing all this stuff
Hope it helps you!

[LynetteCullens]

Question: Why are they .js files instead of .css files?

[Quantodeluz]

Hi, sorry for taking so long
It's becouse snippets must be able to use javascript abilities, like JS functions and regex
Becouse of that, they are stored as a list of JS objects.

[Amberg22]

Tables with TikzJax

For those using TikZJax to quickly create a table.

// Create an n*m table
// Example: !tikztable23 -> creates a 2*3 table
// Use Tab to go to next cell
// For different line lengths and cell sizes, change text width, text depth, and text height parameters

{trigger: /!tikztable(\d)(\d)/, replacement: (match) => {
    const cols = parseInt(match[1], 10);
    const rows = parseInt(match[2], 10);
    
    let matrixContent = [];
    for (let r = 0; r < rows; r++) {
        let rowCells = [];
        for (let c = 0; c < cols; c++) {
            rowCells.push(`\${${r * cols + c + 1}:x}`);
        }
        matrixContent.push(rowCells.join(" & "));
    }
    const matrixStr = matrixContent.join(" \\\\\n    ") + " \\\\";
    
    let horizontalLines = [];
    for (let r = 1; r < rows; r++) {
        horizontalLines.push(`\\draw ([xshift=-.5\\pgflinewidth]mat-${r}-1.south west) -- ([xshift=-.5\\pgflinewidth]mat-${r}-${cols}.south east);`);
    }
    
    let verticalLines = [];
    for (let c = 1; c < cols; c++) {
        verticalLines.push(`\\draw ([yshift=.5\\pgflinewidth]mat-1-${c}.north east) -- ([yshift=.5\\pgflinewidth]mat-${rows}-${c}.south east);`);
    }
    
    const code = `\\usetikzlibrary{matrix}

\\tikzset{ 
    table/.style={
        matrix of nodes,
        row sep=-\\pgflinewidth,
        column sep=-\\pgflinewidth,
        nodes={rectangle,text width=3em,align=center},
        text depth=1.25ex,
        text height=2.5ex,
        nodes in empty cells
    },
}

\\begin{document}

\\begin{tikzpicture}

\\matrix (mat) [table,
    %Change width for specific columns here
    %column 1/.style={nodes={text width=3em}},
    %column 2/.style={nodes={text width=20em}}
	]
    {
    ${matrixStr}
    };

${horizontalLines.join("\n")}
${verticalLines.join("\n")}

\\end{tikzpicture}

\\end{document}`;
    
    return "```tikz\n" + code + "\n```";
}, options: "rA"},

Costum colored underline and overbrace

Printing notes with colored underlines etc with the equation above colored white makes them impossible to read. These snippets are workarounds so that the default obsidian colored equation is untouched, resulting in readable PDFs.

Underline: mark eq and press Shift + W:

{trigger: "W", replacement: "\\underset{\\color{${0:red}} \\displaystyle ${1:x+y} }{ \\underset{\\color{${2:red}}\\rule{${3:1.4}cm}{0.5pt}}{${VISUAL}}}$4", options: "mA"},

Overbrace: mark eq and press Shift + Q:

{trigger: "Q", replacement: "\\overset{ \\color{orange} \\displaystyle \\overbrace{ \\phantom{\\rule{${0:1.4}cm}{0.5pt}} }^{^{\\displaystyle ${1:x}}} }{ ${VISUAL} }$2", options: "mA"},

Change the first argument of \rule{}{} to adjust length of the line/brace.

\mathbb and \mathcal

{trigger: /([A-Z])\1/, replacement: "\\mathbb{[[0]]}", options: "mA"},

{trigger: /\\mathbb{([A-Z])}\1/, replacement: "\\mathcal{[[0]]}", options: "mA"},

Pressing a capital letter, e.g. Q twice gives \mathbb{Q}, and pressing Q a third time gives \mathcal{Q}

[llakala]

I have a ton of custom snippets on my dotfiles repo, stored in their own files to be more distinct from the default presets. Some highlights:

Quotes

{trigger: "(?<=\n)\"", replacement: "\\text{$0 } $1", options: "mrA"}, // Text at the beginning of a line
{trigger: "\"", replacement: "\\text{ $0 } $1", options: "mA", priority: -1}, // Text that isn't at the beginning of a line

This lets me type something like this:

"My favorite fraction is <Tab> 1/3 "because I think it's neat <Tab>

And it becomes:

\text{My favorite fraction is } \dfrac{1}{3}\text{ because I think it's neat } 

The two different snippets means there's no leading space at the beginning of a line, thanks to regex.

Easy block letters

{ trigger: /([A-GI-KM-Z])\1/, replacement: "\\mathbb{[[0]]}", options: "mA" },

This means that if I type any two of the same capital letter in succession, it automatically uses mathbb for it. I exclude H and L, since those look better with mathcal, and I can make manual snippets for those. This isn't any better than just defining 24 different snippets, most of which you'd probably never use, but I found it neat.

Types of sets

In a similar vein to the last one, this means I can immediately say some type of set - like positive real numbers, or $R^2$ - and it gets superscripted immediately.

{ trigger: /\\mathbb{(\w)}([\+\-\d])/, replacement: "\\mathbb{[[0]]}^[[1]]", options: "mA" },

Multiple lines

I like using gather for my notes, since it means I don't have to manually align everything. This is how I start using it from text mode:

{trigger: "ml", replacement: "$$\n\\begin{gather}\n$0\n\\end{gather}\n$$$1", options: "tAw" },

Derivatives

This gives me automatic derivative fractions, when I write something like ddt, or dydt. The best thing is that it works with anything - so I could do dvdu, and it would still work perfectly.

{trigger: /dd([a-ce-z])/, replacement: "\\dfrac{d}{d[[0]]}\\left[ $0 \\right]$1", options: "mA"},
{trigger: /d([a-ce-z])d([a-ce-z])/, replacement: "\\dfrac{d[[0]]}{d[[1]]}$1", options: "mA"},

Nth root

Very simple one, but I find it super useful: it means 3rt puts me in a third root block.

{ trigger: /(\d)rt/, replacement: "\\sqrt[[[0]]]{$0} $1", options: "mA"}, // Nth root

While I'm here, I'll refer you to #359, which I cloned locally and use daily. I absolutely recommend it! And, if you want to see any of my other snippets, check the repo!

[YaoYYoung]

Copy Links Easier

I write weekly reports, which contain many website links.

Therefore, I need to easily copy and open (manipulate) these links in at least four formats:

• outlink
• [text](outlink)
• [[inlink]]
• [[inlink|alias]]

Here are snippets:

{trigger: "c", replacement: sel => {
    // if selected texts contain link, then pressing `c` will copy the link; 
    let out_link = /((?<!!)\[(.*?)\]\((.*?)\))/g;
    let inlink_1 = /\[\[([^\]]*?)\|([^\]]*?)\]\]/g;
    let inlink_2 = /(\[\[([^\]]*?)\]\])/g;
    let purelink = /((https?|ftp|file):\/\/[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#\/%=~_|])/g;
    if (sel.match(out_link)) { navigator.clipboard.writeText(String(sel.match(out_link))); return sel; }
    if (sel.match(inlink_1)) { navigator.clipboard.writeText(String(sel.match(inlink_1))); return sel; }
    if (sel.match(inlink_2)) { navigator.clipboard.writeText(String(sel.match(inlink_2))); return sel; }
    if (sel.match(purelink)) { navigator.clipboard.writeText(String(sel.match(purelink))); return sel; }
    // if not, then do nothing. 
    return sel; 
}, options: "vtA"}, 

{trigger: "e", replacement: sel => {
    if (sel = sel.replaceAll(/\$(\d.*?)\$/g, "\${{ $1 }}\$$")) ; // sensitive_math
    // if selected texts contain links, then pressing `e` will open these links; 
    let purelink = /((https?|ftp|file):\/\/[-A-Za-z0-9+&@#/%?=~_|!:,.;]+[-A-Za-z0-9+&@#\/%=~_|])/g;
    let pureLinks = sel.matchAll(purelink) || [];
    pureLinks.forEach(url => window.open(url[0])); // [0] <-> url
    // if not, then do nothing. 
    return sel; 
}, options: "v"},

[dtinhvo]

"smart" math block insertion:

• Recognizes indent level and retain it for the math block
  • If called on a list line, increase indent level by 1
• Recognizes callout block and retain it for the math block (put a > in front)
  • Does not support nested callouts, but feel free to add a while loop

    {trigger: "\\math", replacement: (sel) => {
        const editor = app.workspace.activeEditor.editor;
        const cursor = editor.getCursor();
        const currentLine = editor.getLine(cursor.line);

		const lines   = currentLine.split('\n');
		let indentStr = '';  
		lines.map(line => {
			// Match all leading groups of four spaces OR tabs
			const m = line.match(/^(( {4}|\t)+)/);
			if (m) {
				indentStr += m[0];            // append all matched indent characters
			}
			if (/^>/.test(line.trimStart())) {
				indentStr += '>';  // add one > to indentStr
			}
			if (/^-/.test(line.trimStart())) {
				indentStr += '\t';  // add one tab to indentStr
			}
			return line;                      // no change if no indent
		})

		let output = `\n${indentStr}$$\t\n${indentStr}$0 \n${indentStr}$$$1`;
        return output;
    }, options: "tA"},

[GuyAzene]

I made a snippet for automatic elementary row operations.
If you have a pmatrix like so:
\begin{pmatrix} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{pmatrix}
...you can directly after it perform the following operations.

---

Row Swap

• Syntax: rowswapi,j
• Represents: $R_i \leftrightarrow R_j$

Performing an operation like rowswap1,2 after the matrix and pressing Tab will automatically swap the rows.

Example:

Typing this:

\begin{pmatrix}
1 & 2 & 3 \\
4 & 5 & 6 \\
7 & 8 & 9
\end{pmatrix}rowswap1,2

$$\begin{pmatrix} 1 & 2 & 3 \\\ 4 & 5 & 6 \\\ 7 & 8 & 9 \end{pmatrix}rowswap1,2$$

...and pressing Tab results in:

\begin{pmatrix}
1 & 2 & 3 \\
4 & 5 & 6 \\
7 & 8 & 9
\end{pmatrix} 
\xrightarrow{R_{1} \leftrightarrow R_{2}}
\begin{pmatrix}
	4 & 5 & 6 \\
	1 & 2 & 3 \\
	7 & 8 & 9
\end{pmatrix}

$$\begin{pmatrix} 1 & 2 & 3 \\\ 4 & 5 & 6 \\\ 7 & 8 & 9 \end{pmatrix} \xrightarrow{R_{1} \leftrightarrow R_{2}} \begin{pmatrix} 4 & 5 & 6 \\\ 1 & 2 & 3 \\\ 7 & 8 & 9 \end{pmatrix}$$

---

Row Addition

• Syntax: rowaddi+/-k*j
• Represents: $R_i \to R_i \pm k \cdot R_j$

Performing an operation like rowadd3-2*1 after the matrix and pressing Tab will automatically calculate the result.

Example:

Typing this:

\begin{pmatrix}
1 & 2 & 3 \\
4 & 5 & 6 \\
7 & 8 & 9
\end{pmatrix}rowadd3-2*1

$$\begin{pmatrix} 1 & 2 & 3 \\\ 4 & 5 & 6 \\\ 7 & 8 & 9 \end{pmatrix}rowadd3-2*1$$

...and pressing Tab results in:

\begin{pmatrix}
1 & 2 & 3 \\
4 & 5 & 6 \\
7 & 8 & 9
\end{pmatrix} 
\xrightarrow{R_{3} \to R_{3} - 2R_{1}}
\begin{pmatrix}
	1 & 2 & 3 \\
	4 & 5 & 6 \\
	5 & 4 & 3
\end{pmatrix}

$$\begin{pmatrix} 1 & 2 & 3 \\\ 4 & 5 & 6 \\\ 7 & 8 & 9 \end{pmatrix} \xrightarrow{R_{3} \to R_{3} - 2R_{1}} \begin{pmatrix} 1 & 2 & 3 \\\ 4 & 5 & 6 \\\ 5 & 4 & 3 \end{pmatrix}$$

---

Row Multiplication

• Syntax: rowmulti*k
• Represents: $R_i \to k \cdot R_i$

Similarly, to multiply a row by a scalar, you can type rowmult1*10 after the matrix.

Example:

Typing this:

\begin{pmatrix}
1 & 2 & 3 \\
4 & 5 & 6 \\
7 & 8 & 9
\end{pmatrix}rowmult1*10

$$\begin{pmatrix} 1 & 2 & 3 \\\ 4 & 5 & 6 \\\ 7 & 8 & 9 \end{pmatrix}rowmult1*10$$

...and pressing Tab results in:

\begin{pmatrix}
1 & 2 & 3 \\
4 & 5 & 6 \\
7 & 8 & 9
\end{pmatrix} 
\xrightarrow{R_{1} \to 10R_{1}}
\begin{pmatrix}
	10 & 20 & 30 \\
	4 & 5 & 6 \\
	7 & 8 & 9
\end{pmatrix}

$$\begin{pmatrix} 1 & 2 & 3 \\\ 4 & 5 & 6 \\\ 7 & 8 & 9 \end{pmatrix} \xrightarrow{R_{1} \to 10R_{1}} \begin{pmatrix} 10 & 20 & 30 \\\ 4 & 5 & 6 \\\ 7 & 8 & 9 \end{pmatrix}$$

Handling Variables and Complex Expressions

The snippets are intelligent: if they encounter variables or complex LaTeX commands within the matrix, they will fall back to showing the formula instead of the calculated value.

• What it can do: It safely handles variables. If a cell contains an expression like x+3, it will wrap it in parentheses for subsequent operations, ensuring mathematical correctness (e.g., 2 \cdot (x+3)).

• What it cannot do: It does not perform algebraic simplification. For example, it will not simplify 0.5 \cdot (2 \cdot (x+3)) to x+3. It will correctly show the un-simplified formula, guaranteeing that no mathematical errors are introduced.

---

Snippet Code

Click to view the snippet code

{
    "trigger": /(\\begin{pmatrix}((?!\\end{pmatrix})[\s\S])*\\end{pmatrix})\s*rowswap(\d+)\s*,\s*(\d+)/,
    "replacement": function(match) {
        function parseMatrix(matrixString) {
            const content = matrixString.replace(/\\begin{pmatrix}|\\end{pmatrix}/g, '').trim();
            if (!content) return [];
            return content.split(/\\\\/g).map(row => row.trim().split('&').map(cell => cell.trim()));
        }
        function formatMatrix(matrixArray) {
            const body = matrixArray.map(row => row.join(' & ')).join(' \\\\\n\t');
            return `\\begin{pmatrix}\n\t${body}\n\\end{pmatrix}`;
        }

        const originalMatrixStr = match[1];
        const i_one_based = parseInt(match[3]);
        const j_one_based = parseInt(match[4]);
        const i = i_one_based - 1;
        const j = j_one_based - 1;

        const matrix = parseMatrix(originalMatrixStr);

        if (i >= 0 && j >= 0 && i < matrix.length && j < matrix.length) {
            [matrix[i], matrix[j]] = [matrix[j], matrix[i]];
        }

        const arrow = `\\xrightarrow{R_{${i_one_based}} \\leftrightarrow R_{${j_one_based}}}`;
        const newMatrix = formatMatrix(matrix);

        return `${originalMatrixStr} \n${arrow}\n${newMatrix}`;
    },
    "options": "rm",
    "description": "After a pmatrix, type rowswap(i),(j) to automatically perform the swap."
},
{
    "trigger": /(\\begin{pmatrix}((?!\\end{pmatrix})[\s\S])*\\end{pmatrix})\s*rowadd(\d+)\s*([+-])\s*(.+?)\s*\*\s*(\d+)/,
    "replacement": function(match) {
        function parseMatrix(matrixString) {
            const content = matrixString.replace(/\\begin{pmatrix}|\\end{pmatrix}/g, '').trim();
            if (!content) return [];
            return content.split(/\\\\/g).map(row => row.trim().split('&').map(cell => cell.trim()));
        }
        function formatMatrix(matrixArray) {
            const body = matrixArray.map(row => row.join(' & ')).join(' \\\\\n\t');
            return `\\begin{pmatrix}\n\t${body}\n\\end{pmatrix}`;
        }
        // Helper to check if a string is a simple number
        function parseNumber(str) {
            const s = str.trim();
            if (s !== '' && isFinite(s)) {
                return Number(s);
            }
            return NaN;
        }

        const originalMatrixStr = match[1];
        const i_one_based = parseInt(match[3]);
        const sign = match[4];
        const scalar = match[5].trim();
        const j_one_based = parseInt(match[6]);
        const i = i_one_based - 1;
        const j = j_one_based - 1;

        const matrix = parseMatrix(originalMatrixStr);

        if (i >= 0 && j >= 0 && i < matrix.length && j < matrix.length && i !== j) {
            const numScalar = parseNumber(scalar);

            matrix[i] = matrix[i].map((destCell, colIndex) => {
                const sourceCell = matrix[j][colIndex];
                const numDest = parseNumber(destCell);
                const numSource = parseNumber(sourceCell);

                // If all parts are numbers, calculate the result
                if (!isNaN(numDest) && !isNaN(numSource) && !isNaN(numScalar)) {
                    const result = (sign === '+') ? (numDest + numScalar * numSource) : (numDest - numScalar * numSource);
                    return result.toString();
                } else {
                    // Otherwise, build the string expression
                    if (sourceCell.trim() === '0') return destCell;
                    if (destCell.trim() === '0') {
                         const sourceDisplay = (sourceCell.includes('+') || sourceCell.includes('-')) ? `(${sourceCell})` : sourceCell;
                         return (sign === '+') ? `${scalar} \\cdot ${sourceDisplay}` : `-${scalar} \\cdot ${sourceDisplay}`;
                    }
                    const destDisplay = (destCell.includes('+') || destCell.includes('-')) ? `(${destCell})` : destCell;
                    const sourceDisplay = (sourceCell.includes('+') || sourceCell.includes('-')) ? `(${sourceCell})` : sourceCell;
                    return `${destDisplay} ${sign} ${scalar} \\cdot ${sourceDisplay}`;
                }
            });
        }
        
        const arrow = `\\xrightarrow{R_{${i_one_based}} \\to R_{${i_one_based}} ${sign} ${scalar}R_{${j_one_based}}}`;
        const newMatrix = formatMatrix(matrix);

        return `${originalMatrixStr} \n${arrow}\n${newMatrix}`;
    },
    "options": "rm",
    "description": "After a pmatrix, type rowadd(i)+k*(j) to automatically perform the addition."
},
{
    "trigger": /(\\begin{pmatrix}((?!\\end{pmatrix})[\s\S])*\\end{pmatrix})\s*rowmult(\d+)\s*\*\s*([^ \t\n\r]+)/,
    "replacement": function(match) {
        function parseMatrix(matrixString) {
            const content = matrixString.replace(/\\begin{pmatrix}|\\end{pmatrix}/g, '').trim();
            if (!content) return [];
            return content.split(/\\\\/g).map(row => row.trim().split('&').map(cell => cell.trim()));
        }
        function formatMatrix(matrixArray) {
            const body = matrixArray.map(row => row.join(' & ')).join(' \\\\\n\t');
            return `\\begin{pmatrix}\n\t${body}\n\\end{pmatrix}`;
        }
        // Helper to check if a string is a simple number
        function parseNumber(str) {
            const s = str.trim();
            if (s !== '' && isFinite(s)) {
                return Number(s);
            }
            return NaN;
        }

        const originalMatrixStr = match[1];
        const i_one_based = parseInt(match[3]);
        const scalar = match[4].trim();
        const i = i_one_based - 1;

        const matrix = parseMatrix(originalMatrixStr);

        if (i >= 0 && i < matrix.length) {
            const numScalar = parseNumber(scalar);

            matrix[i] = matrix[i].map(cell => {
                const numCell = parseNumber(cell);

                // If both parts are numbers, calculate the result
                if (!isNaN(numCell) && !isNaN(numScalar)) {
                    return (numCell * numScalar).toString();
                } else {
                    // Otherwise, build the string expression
                    if (cell.trim() === '0') return '0';
                    const cellDisplay = (cell.includes('+') || cell.includes('-')) ? `(${cell})` : cell;
                    return `${scalar} \\cdot ${cellDisplay}`;
                }
            });
        }

        const arrow = `\\xrightarrow{R_{${i_one_based}} \\to ${scalar}R_{${i_one_based}}}`;
        const newMatrix = formatMatrix(matrix);

        return `${originalMatrixStr} \n${arrow}\n${newMatrix}`;
    },
    "options": "rm",
    "description": "After a pmatrix, type rowmult(i)*k to automatically perform the multiplication."
}