├── README.md
├── for 0.2.4
    └── markdown.hsnips
└── for 0.2.7+
    ├── latex.hsnips
    └── markdown.hsnips


/README.md:
--------------------------------------------------------------------------------
1 | 
2 | ![5jfgfd](https://user-images.githubusercontent.com/80528249/148357887-7be814cd-0509-4144-8a9b-329f64b993c2.gif)
3 | 
4 | # Hsnips-Snippets
5 | 
6 | HyperSnips Snippets for markdown .
7 | 
8 | 


--------------------------------------------------------------------------------
/for 0.2.4/markdown.hsnips:
--------------------------------------------------------------------------------
   1 | global
   2 | 
   3 | // vscode api
   4 | 
   5 | const vscode = require("vscode");
   6 | var editor=vscode.window.activeTextEditor
   7 | var document=editor.document
   8 | let selectedText = "";
   9 | 
  10 | // selected text
  11 | 
  12 | vscode.window.onDidChangeTextEditorSelection((e) => {
  13 |     const newSelectedText = e.textEditor.document.getText(e.selections[0]);
  14 |     if (newSelectedText) {
  15 |         selectedText = newSelectedText;
  16 |     }
  17 | });
  18 | 
  19 | function VISUAL() {
  20 |     let sText=selectedText.replace(/\\\\/g,"\\\\\\ ").replace(/\}/g,"\\}");
  21 |     selectedText="";
  22 |     return sText;
  23 | }
  24 | 
  25 | // get ActiveTextEditor
  26 | 
  27 | vscode.window.onDidChangeActiveTextEditor((e) => {
  28 |     editor=vscode.window.activeTextEditor;
  29 |     document=editor.document
  30 | });
  31 | 
  32 | 
  33 | 
  34 | // transformation cycle
  35 | 
  36 | function cycle(arr,str){
  37 |     let count = 0 ;
  38 |     while (str!=arr[++count]&&count<arr.length);
  39 |     return arr[(count+1)%arr.length]
  40 | }
  41 | 
  42 | // environment
  43 | 
  44 | function math(context) {
  45 |     return context.scopes.some(s => s.includes("math"));
  46 | }
  47 | 
  48 | function inline_math(context){
  49 |     return context.scopes.some(s => s.includes("math.inline"));
  50 | }
  51 | 
  52 | function block_math(context){
  53 |     return context.scopes.some(s => s.includes("math.block")) | context.scopes.some(s => s.includes("math.display"));
  54 | }
  55 | 
  56 | 
  57 | function isAlignedEnvironment(editor) {
  58 |     let text = editor.document.getText(new vscode.Range(new vscode.Position(0, 0), editor.selection.start));
  59 |     const reg = /\\begin\{aligned\}[^\$]*?\\end\{aligned\}/g;
  60 |     text = text.replace(reg, '');
  61 |     return (text.indexOf('\\begin{aligned}') == -1)?false:true;
  62 | }
  63 | 
  64 | // generate matrix
  65 | 
  66 | function gen_matrix(nrow, ncol, index) {
  67 | 	let results = "\n";
  68 | 	let order = 1;
  69 | 	for (var i=0; i<nrow; i++){
  70 | 		results += '	';
  71 | 		for(var j = 0;j <ncol;j++){
  72 | 			results += "$" +(order ).toString() + ((j == ncol -1) ? /*((i != nrow-1) ? " \\\\\\" : "")*/ " \\\\\\" : " & ");
  73 | 			order ++;
  74 | 		}
  75 |         results += index ? "\n" : "";
  76 | 	}
  77 | 	return results;
  78 | }
  79 | 
  80 | 
  81 | 
  82 | endglobal
  83 | 
  84 | 
  85 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
  86 | # \\              markdown                                                \\
  87 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
  88 | 
  89 | 
  90 | # protect "oiint" "iiint" "asccos" "mathtt" "mathbb"
  91 | priority 99999999
  92 | context math(context)
  93 | snippet `(?<=(oii|iii|ascc|mathtt|mathbb))` "prevent" iA
  94 | 
  95 | endsnippet
  96 | 
  97 | # %% -> ★
  98 | context !math(context)
  99 | snippet %% "big star" A
 100 | $\color{red}\bigstar$ 
 101 | endsnippet
 102 | 
 103 | 
 104 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 105 | # \\                transform                                             \\
 106 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 107 | 
 108 | # use ";" to transform
 109 | 
 110 | # \frac \dfrac
 111 | 
 112 | context math(context)
 113 | snippet `(\\(frac|dfrac)\{.*\}\{.*\});` "frac change" iA
 114 | ``
 115 | var str=m[1].replace(/\\frac/g,"Ⱆ").replace(/\\dfrac/g,"Ⱉ").split('');
 116 | 
 117 | var depth=0;
 118 | var i=str.length-1;
 119 | var test =0;
 120 | 
 121 | while (i>=0) {
 122 |     if ( str[i] == '\}' ) depth ++;
 123 |     if ( str[i] == '\{' ) depth --;
 124 |     
 125 |     if ( test == 2 && !depth){
 126 |         if ( str[i] == 'Ⱆ'){ str[i] = 'Ⱉ';break;}
 127 |         if ( str[i] == 'Ⱉ'){ str[i] = 'Ⱆ';break;}
 128 |     }
 129 |     test += depth ? 0 : 1;
 130 |     i--;
 131 | }
 132 | 
 133 | rv=str.join('').replace(/Ⱆ/g,"\\frac").replace(/Ⱉ/g,"\\dfrac");
 134 | ``
 135 | endsnippet
 136 | 
 137 | # -> => --> ==> -> ==> 
 138 | 
 139 | context math(context)
 140 | snippet `(\\rightarrow|\\Rightarrow|\\longrightarrow|\\Longrightarrow|\\to|\\implies)(| );` "change ->" Ai
 141 | ``
 142 | let r=["\\rightarrow","\\Rightarrow","\\longrightarrow","\\Longrightarrow","\\to","\\implies"];
 143 | rv=cycle(r,m[1])+m[2];
 144 | ``
 145 | endsnippet
 146 | 
 147 | # <= <= <-- <== <==
 148 | 
 149 | context math(context)
 150 | snippet `(\\leftarrow|\\Leftarrow|\\longleftarrow|\\Longleftarrow|\\impliedby)(| );` "change <-" Ai
 151 | ``
 152 | let r=["\\leftarrow","\\Leftarrow","\\longleftarrow","\\Longleftarrow","\\impliedby"];
 153 | rv=cycle(r,m[1])+m[2];
 154 | ``
 155 | endsnippet
 156 | 
 157 | context math(context)
 158 | snippet `(\\leftrightarrow|\\Leftrightarrow|\\longleftrightarrow|\\Longleftrightarrow|\\iff)(| );` "<=>" iA
 159 | ``
 160 | let r=["\\leftrightarrow","\\Leftrightarrow","\\longleftrightarrow","\\Longleftrightarrow","\\iff"];
 161 | rv=cycle(r,m[1])+m[2];
 162 | ``
 163 | endsnippet
 164 | 
 165 | 
 166 | # ≤ ≤ ≦ ﹤
 167 | 
 168 | context math(context)
 169 | snippet `(\\le|\\leq|\\leqslant|<)(| );` "change <" Ai
 170 | ``
 171 | let r=["\\le","\\leq","\\leqslant","<"];
 172 | rv=cycle(r,m[1])+m[2];
 173 | ``
 174 | endsnippet
 175 | 
 176 | context math(context)
 177 | snippet `(\\re|\\req|\\reqslant|>)(| );` "change <" Ai
 178 | ``
 179 | let r=["\\le","\\leq","\\leqslant","<"];
 180 | rv=cycle(r,m[1])+m[2];
 181 | ``
 182 | endsnippet
 183 | 
 184 | # dots
 185 | 
 186 | context math(context)
 187 | snippet `\\(c|v|l|d)dots( |);` "dots" iA
 188 | \\``
 189 | let r=["c","v","l","d"];
 190 | rv=cycle(r,m[1]);
 191 | ``dots``rv=m[2]``
 192 | endsnippet
 193 | 
 194 | # var greek
 195 | 
 196 | context math(context)
 197 | snippet `(\\|\\var)(epsilon|theta|phi|pi|sigma|kappa)(| );` "greek change" iA
 198 | ``let r=["\\","\\var"];
 199 | rv=cycle(r,m[1])+m[2]+m[3];``
 200 | endsnippet
 201 | 
 202 | # = <-> ≡ 
 203 | 
 204 | context math(context)
 205 | snippet `(=|\\equiv|\\approx)(| );` "=" iA
 206 | ``let r=["=","\\equiv","\\approx"];
 207 | rv=cycle(r,m[1])+m[2]``
 208 | endsnippet
 209 | 
 210 | 
 211 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 212 | # \\                environment                                           \\
 213 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 214 | 
 215 | # align
 216 | 
 217 | # aligned environment with VISUAL
 218 | priority 300
 219 | context math(context)
 220 | snippet `Aln` "align" iA
 221 | \begin{aligned}
 222 |     ``rv = VISUAL();``$0
 223 | \end{aligned}
 224 | endsnippet
 225 | 
 226 | # replace content of current line
 227 | priority 200
 228 | context math(context)
 229 | snippet `aln` "Align" iA
 230 | \begin{aligned}
 231 |     ``
 232 |     let pos = editor.selection.active;
 233 |     let range = new vscode.Range(pos.line,0,pos.line,pos.character-2) //delete snippet "Aln"
 234 |     let text = document.getText(range);
 235 |     vscode.window.activeTextEditor.edit(editBuilder => {
 236 |         editBuilder.delete(document.lineAt(pos).range);
 237 |     });
 238 |     rv=text.replace("=","&=");
 239 |     `` $0
 240 | \end{aligned}
 241 | endsnippet
 242 | 
 243 | 
 244 | # for `aligned`
 245 | 
 246 | context isAlignedEnvironment(editor)
 247 | snippet `==` "&=" iA
 248 | &=
 249 | endsnippet
 250 | 
 251 | 
 252 | context isAlignedEnvironment(editor)
 253 | snippet ++ "&=" iA
 254 | &+
 255 | endsnippet
 256 | 
 257 | context isAlignedEnvironment(editor)
 258 | snippet `&==` "&=&" iA
 259 | &=&
 260 | endsnippet
 261 | 
 262 | # case/rcase
 263 | 
 264 | context math(context)
 265 | snippet `(?<!\{[a-zA-Z]*)(case|rcase)` "case" iA
 266 | \begin{``rv=m[1]``s}
 267 |     $1
 268 | \end{``rv=m[1]``s}$0
 269 | endsnippet
 270 | 
 271 | 
 272 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 273 | # \\                MATRIX                                                \\
 274 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 275 | 
 276 | # matrices
 277 | 
 278 | # bmat22->
 279 | # \begin{bmatrix}
 280 | #    | & | \\
 281 | #    | & | \\
 282 | # \end{bmatrix}
 283 | 
 284 | priority 2000
 285 | context block_math(context)
 286 | snippet `(bm|pm|m|vm)at([1-9])([1-9])` "matrix" iA
 287 | \begin{``rv = m[1]``atrix}``
 288 | 	rv = gen_matrix(m[2],m[3],1);
 289 | 	``\end{``rv = m[1]``atrix}$0
 290 | endsnippet
 291 | 
 292 | priority 2000000
 293 | context block_math(context)
 294 | snippet `rv([1-9])` "row vector" iA
 295 | \begin{bmatrix}``
 296 |     rv=gen_matrix(1,m[1],1);
 297 | ``\end{bmatrix}
 298 | endsnippet
 299 | 
 300 | priority 2000000
 301 | context block_math(context)
 302 | snippet `cv([1-9])` "row vector" iA
 303 | \begin{bmatrix}``
 304 |     rv=gen_matrix(m[1],1,1);
 305 | ``\end{bmatrix}
 306 | endsnippet
 307 | 
 308 | # inline matrices
 309 | 
 310 | priority 3000
 311 | context inline_math(context)
 312 | snippet `(bm|pm|m|vm)at([1-9])([1-9])` "matrix" iA
 313 | \begin{``rv = m[1]``atrix}``
 314 | rv = gen_matrix(m[2],m[3],0);
 315 | `` \end{``rv = m[1]``atrix}$0
 316 | endsnippet
 317 | 
 318 | priority 3000000
 319 | context inline_math(context)
 320 | snippet `rv([1-9])` "row vector" iA
 321 | \begin{bmatrix}``
 322 |     rv=gen_matrix(1,m[1],0);
 323 | `` \end{bmatrix}
 324 | endsnippet
 325 | 
 326 | priority 3000000
 327 | context inline_math(context)
 328 | snippet `cv([1-9])` "row vector" iA
 329 | \begin{bmatrix}``
 330 |     rv=gen_matrix(m[1],1,0);
 331 | `` \end{bmatrix}
 332 | endsnippet
 333 | 
 334 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 335 | # \\                dots                                                 \\
 336 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 337 | 
 338 | context math(context)
 339 | snippet ... "cdots" iA
 340 | \cdots
 341 | endsnippet
 342 | 
 343 | context math(context)
 344 | snippet ,,, "vdots" iA
 345 | \vdots
 346 | endsnippet
 347 | 
 348 | context math(context)
 349 | snippet ::: "ddots" iA
 350 | \ddots
 351 | endsnippet
 352 | 
 353 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 354 | # \\              script text                                           \\
 355 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 356 | 
 357 | # _{}
 358 | context math(context)
 359 | snippet `(?<!(math|\\))sc` "script main" iA
 360 | _{$1}$0
 361 | endsnippet
 362 | 
 363 | # _{1}
 364 | priority 10000
 365 | context math(context)
 366 | snippet `(?<=[A-Za-z])(?<!mat)(\d)` "auto subscript" iA
 367 | _``rv = m[1]``
 368 | endsnippet
 369 | 
 370 | # _{1}
 371 | priority 10000
 372 | context math(context)
 373 | snippet `(?<=\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega))[ ](\d)` "auto subscript" iA
 374 | _``rv = m[2]``
 375 | endsnippet
 376 | 
 377 | 
 378 | # _{a}
 379 | priority 1000
 380 | context math(context)
 381 | snippet `(?<=[A-Za-z])(aa|bb|cc|ii|jj|kk|ll|mm|nn|oo|pp|qq|ss|tt|uu|vv|ww|xx|yy|zz)` "script" iA
 382 | _``
 383 | var as=m[1];
 384 | var bs=as.charAt(0);
 385 | rv=bs
 386 | ``
 387 | endsnippet
 388 | 
 389 | # α_{a}
 390 | priority 1000
 391 | context math(context)
 392 | snippet `(?<=\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega))[ ](\d|aa|bb|cc|ii|jj|kk|mm|nn|tt|uu|vv|ww|xx|yy|zz)` "greek subscript" iA
 393 | _``var as=m[2];
 394 | var bs=as.charAt(0);
 395 | rv=bs``
 396 | endsnippet
 397 | 
 398 | # _{12}
 399 | context math(context)
 400 | snippet `(?<=[A-Za-z]_)([\d]+)` "auto subscript2" iA
 401 | {``rv = m[1]``$1}$0
 402 | endsnippet
 403 | 
 404 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 405 | # \\                square                                             \\
 406 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 407 | 
 408 | # ^{}
 409 | 
 410 | priority 1000
 411 | context math(context)
 412 | snippet `(?<!\\)pw` "^n" iA
 413 | ^{$1}$0
 414 | endsnippet
 415 | 
 416 | # ^2
 417 | 
 418 | context math(context)
 419 | snippet `(?<!\\)sr` "^2" iA
 420 | ^2 
 421 | endsnippet
 422 | 
 423 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 424 | # \\              fraction                                             \\
 425 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 426 | 
 427 | # 1/->\frac{1}{}
 428 | 
 429 | priority 10
 430 | context math(context)
 431 | snippet `((\d+)|(\d*)(\\)?([A-Za-z]+)((\^|_)(\{\d+\}|\d))*|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])/` "Fraction no ()" A
 432 | \frac{``rv = m[1]``}{$1}$0
 433 | endsnippet
 434 | 
 435 | context math(context)
 436 | snippet `^.*\)/` "Fraction with ()" A
 437 | ``
 438 |     let str = m[0];
 439 |     str = str.slice(0, -1);
 440 |     let lastIndex = str.length - 1;
 441 | 
 442 |     let depth = 0;
 443 |     let i = str.length - 1;
 444 | 
 445 |     while (true) {
 446 |         if (str[i] == ')') depth += 1;
 447 |         if (str[i] == '(') depth -= 1;
 448 |         if (depth == 0) break;
 449 |         i -= 1;
 450 |     }
 451 | 
 452 |     let results = str.slice(0, i) + "\\frac{" + str.slice(i+1, -1) + "}";
 453 |     results += "{$1}$0";
 454 |     rv = results;
 455 | ``
 456 | endsnippet
 457 | 
 458 | # //->\frac{}{}
 459 | 
 460 | priority 10
 461 | context math(context)
 462 | snippet // "Fraction" iA
 463 | \\frac{$1}{$2}$0
 464 | endsnippet
 465 | 
 466 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 467 | # \\\\                      sign                              \\\\\
 468 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 469 | 
 470 | ## integrate signs ∫ ##
 471 | 
 472 | # ∫
 473 | priority 1
 474 | context math(context)
 475 | snippet `(?<=[^s])(?<!\\)[iI]nt` "integration" iAM
 476 | \int
 477 | endsnippet
 478 | 
 479 | # ∫∫
 480 | priority 2
 481 | context math(context)
 482 | snippet `(\\|)iint` "iintegration" iA
 483 | \iint
 484 | endsnippet
 485 | 
 486 | # ∫∫∫
 487 | priority 100000
 488 | context math(context)
 489 | snippet `(\\|)iiint` "iiintegration" iA
 490 | \iiint
 491 | endsnippet
 492 | 
 493 | # ∮
 494 | priority 200000
 495 | context math(context)
 496 | snippet `(\\|)oint` "oint" iA
 497 | \oint
 498 | endsnippet
 499 | 
 500 | # ∯
 501 | priority 200000
 502 | context math(context)
 503 | snippet `(\\|)oiint` "oint" iA
 504 | \oiint
 505 | endsnippet
 506 | 
 507 | # ∰
 508 | priority 200000
 509 | context math(context)
 510 | snippet `(\\|)oiiint` "oint" iA
 511 | \oiiint
 512 | endsnippet
 513 | 
 514 | 
 515 | # ∫a -> ∫ a
 516 | context math(context)
 517 | snippet `(?<=(\\int|\\lim|\\sum))([a-ce-zA-CE-Z])` "space after int" iA
 518 |  ``rv=m[2]``
 519 | endsnippet
 520 | 
 521 | 
 522 | ## infinity ∞ ##
 523 | 
 524 | context math(context)
 525 | snippet `oo` "infinity" iA
 526 | \infty
 527 | endsnippet
 528 | 
 529 | context math(context)
 530 | snippet `\\inftyp` "+infty" iA
 531 | +\infty
 532 | endsnippet
 533 | 
 534 | context math(context)
 535 | snippet `\\inftym` "-infty" iA
 536 | -\infty
 537 | endsnippet
 538 | 
 539 | ## d/dt
 540 | 
 541 | context math(context)
 542 | snippet `DD` "diffraction" iA
 543 | \frac{\mathrm{d}$1}{\mathrm{d}$2}
 544 | endsnippet
 545 | 
 546 | context math(context)
 547 | snippet `PP` "diffraction" iA
 548 | \frac{\partial $1}{\partial $2}
 549 | endsnippet
 550 | 
 551 | ## Fourier Trans 1/(√2π) ∫
 552 | 
 553 | context math(context)
 554 | snippet \frt "fourier trans" iA
 555 | \frac{1}{sqrt{2\pi}}\int_{-\infty}^{+\infty}
 556 | endsnippet
 557 | 
 558 | ## function and operator ##
 559 | context math(context)
 560 | snippet `(?<!arc)(?<!\\)(sin|cos|tan|csc|sec|cot|ln|log|det|ker|max|min)` "function" iA
 561 | \``rv=m[1]`` 
 562 | endsnippet
 563 | 
 564 | context math(context)
 565 | snippet `(?<!\\)(lim|sum)` "lim" iA
 566 | \``rv=m[1]``
 567 | endsnippet
 568 | 
 569 | context math(context)
 570 | snippet `(?<!\\)arc(sin|cos|tan|csc|sec|cot)` "function" iA
 571 | \arc``rv=m[1]`` 
 572 | endsnippet
 573 | 
 574 | priority 20
 575 | context math(context)
 576 | snippet `(?<=\\(sin|cos|tan|csc|sec|cot))( )h` "function" iA
 577 | h 
 578 | endsnippet
 579 | 
 580 | context math(context)
 581 | snippet `(curl|div|grad)` "vec calculus" iA
 582 | \mathrm{``rv=m[1].charAt(0).toUpperCase()+m[1].substr(1)``.}
 583 | endsnippet
 584 | 
 585 | context math(context)
 586 | snippet `(?<!\\)exp` "exp" iA
 587 | \mathrm{e}^{$1}$0
 588 | endsnippet
 589 | 
 590 | context math(context)
 591 | snippet `(?<!\\)sq` "square" iA
 592 | \sqrt{$1}
 593 | endsnippet
 594 | 
 595 | context math(context)
 596 | snippet `(sum|int|bigcap|bigcup)d` "sum and int" iA
 597 | ``rv=m[1]``_{$1}^{$2}
 598 | endsnippet
 599 | 
 600 | context math(context)
 601 | snippet `(lim|limsup|liminf)d` "lim and limsup" iA
 602 | ``rv=m[1]``_{$1 \to $2}$0
 603 | endsnippet
 604 | 
 605 | context math(context)
 606 | snippet `\\(lim|limsup|sum|int|iint|iiint|oint|oiint|oiiint|bigcap|bigcup)D` "displaystyle" iA
 607 | \displaystyle \``rv=m[1]``
 608 | endsnippet
 609 | 
 610 | context math(context)
 611 | snippet `(\|\||abs)` "abs" iA
 612 | |$1|$0
 613 | endsnippet
 614 | 
 615 | ## Dirac Bracket <φ|ψ> ##
 616 | 
 617 | context math(context)
 618 | snippet `avg` "average" iA
 619 | \left< $1 \right> $0
 620 | endsnippet
 621 | 
 622 | context math(context)
 623 | snippet `[bB]ra` "Dirac bra" iA
 624 | \langle $1|$0
 625 | endsnippet
 626 | 
 627 | context math(context)
 628 | snippet `(?<=(\||\| ))ket` "dirac ket" iA
 629 | $1\rangle$0
 630 | endsnippet
 631 | 
 632 | context math(context)
 633 | snippet `(?<!(\||\| ))[kK]et` "Dirac bra" iA
 634 | |$1\rangle$0
 635 | endsnippet
 636 | 
 637 | ## signs ##
 638 | 
 639 | context math(context)&& !isAlignedEnvironment(editor)
 640 | snippet `==` "xlongequal" iA
 641 | \xlongequal{$1}$0
 642 | endsnippet
 643 | 
 644 | context math(context)
 645 | snippet `AA` "forall" iA
 646 | \forall 
 647 | endsnippet
 648 | 
 649 | context math(context)
 650 | snippet `EE` "exist" iA
 651 | \exist 
 652 | endsnippet
 653 | 
 654 | context math(context)
 655 | snippet `RR` "rset" iA
 656 | \mathbb{R}
 657 | endsnippet
 658 | 
 659 | context math(context)
 660 | snippet `ZZ` "integer set" iA
 661 | \mathbb{Z}
 662 | endsnippet
 663 | 
 664 | context math(context)
 665 | snippet `CC` "integer set" iA
 666 | \mathbb{C}
 667 | endsnippet
 668 | 
 669 | priority 20
 670 | context math(context)
 671 | snippet `OO` "cdot" iA
 672 | \cdot 
 673 | endsnippet
 674 | 
 675 | context math(context)
 676 | snippet `BB` "cdot" iA
 677 | \boxed{${1:``rv=selectedText;selectedText=""``}}$0
 678 | endsnippet
 679 | 
 680 | context math(context)
 681 | snippet `TT` "->" iA
 682 | \rightarrow 
 683 | endsnippet
 684 | 
 685 | context math(context)
 686 | snippet `GG` "==>" iA
 687 | \Longrightarrow
 688 | endsnippet
 689 | 
 690 | priority 10
 691 | context math(context)
 692 | snippet `@@` "at" iA
 693 | \big| _{$1}^{$2}$0
 694 | endsnippet
 695 | 
 696 | priority 20
 697 | context math(context)
 698 | snippet `#@` "at2" iA
 699 | \left. $1 \right|_{$2}$0
 700 | endsnippet
 701 | 
 702 | context math(context)
 703 | snippet `NN` "cap" iA
 704 | \cap 
 705 | endsnippet
 706 | 
 707 | context math(context)
 708 | snippet `UU` "cup" iA
 709 | \cup 
 710 | endsnippet
 711 | 
 712 | context math(context)
 713 | snippet `II` "in" iA
 714 | \in 
 715 | endsnippet
 716 | 
 717 | priority 20
 718 | context math(context)
 719 | snippet `XX` "times" iA
 720 | \times 
 721 | endsnippet
 722 | 
 723 | context math(context)
 724 | snippet `oxo` "otimes" iA
 725 | \otimes 
 726 | endsnippet
 727 | 
 728 | context math(context)
 729 | snippet `opo` "oplus" iA
 730 | \oplus 
 731 | endsnippet
 732 | 
 733 | context math(context)
 734 | snippet `oco` "oplus" iA
 735 | \propto 
 736 | endsnippet
 737 | 
 738 | # ▽
 739 | context math(context)
 740 | snippet `(\\|)(nbl)` "nabla" iA
 741 | \nabla 
 742 | endsnippet
 743 | 
 744 | context math(context)
 745 | snippet `(?<!\\)dag` "dagger" iA
 746 | ^\dagger
 747 | endsnippet
 748 | 
 749 | context math(context)
 750 | snippet `coj` "conjugate" iA
 751 | ^*
 752 | endsnippet
 753 | 
 754 | context math(context)
 755 | snippet `(\\|)ptl` "partial" iA
 756 | \partial 
 757 | endsnippet
 758 | 
 759 | context math(context)
 760 | snippet `inv` "inverse" iA
 761 | ^{-1}
 762 | endsnippet
 763 | 
 764 | context math(context)
 765 | snippet `trs` "trs" iA
 766 | ^T
 767 | endsnippet
 768 | 
 769 | context math(context)
 770 | snippet `~~` "sim" iA
 771 | \sim
 772 | endsnippet
 773 | 
 774 | ## ℝ ##
 775 | 
 776 | priority 2000000
 777 | context math(context)
 778 | snippet `(?<=\\mathbb\{R\})([mnkl\d])` "rset^n" iA
 779 | ^{``rv=m[1]``} 
 780 | endsnippet
 781 | 
 782 | priority 2000000
 783 | context math(context)
 784 | snippet `(?<=\\mathbb\{R\})\+` "rset_+" iA
 785 | _+
 786 | endsnippet
 787 | 
 788 | context math(context)
 789 | snippet `\!=` "not =" iA
 790 | \not =
 791 | endsnippet
 792 | 
 793 | context math(context)
 794 | snippet `(?<!\\)(txt|tst)` "text" iA
 795 | \text{$1}$0
 796 | endsnippet
 797 | 
 798 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 799 | # \\                prefix                                                \\
 800 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 801 | 
 802 | priority 1000
 803 | context math(context)
 804 | snippet `((\\?[a-zA-Z^h]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(bar|BAR)` "Bar" iA
 805 | \overline{``rv = m[1]``}
 806 | endsnippet
 807 | 
 808 | priority 2000
 809 | context math(context)
 810 | snippet `hbar` "hbar" iA
 811 | \hbar
 812 | endsnippet
 813 | 
 814 | context math(context)
 815 | snippet `((\\?[a-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(td|TD)` "tilde" iA
 816 | \widetilde{``rv = m[1]``}
 817 | endsnippet
 818 | 
 819 | priority 100
 820 | context math(context)
 821 | snippet `((\\?[a-ce-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(?<!math)(rm)` "tilde" iA
 822 | \mathrm{``rv = m[1]``}
 823 | endsnippet
 824 | 
 825 | context math(context)
 826 | snippet `@rm` "mathrm" iA
 827 | \mathrm{$1}$0
 828 | endsnippet
 829 | 
 830 | priority 200
 831 | context math(context)
 832 | snippet `(.?)drm` "dif" iA
 833 | ``rv=m[1]=="$"? "$" : m[1]+" "``\mathrm{d}
 834 | endsnippet
 835 | 
 836 | context math(context)
 837 | snippet `((\\?[a-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(hat|HAT)` "hat" iA
 838 | \hat{``rv = m[1]``}
 839 | endsnippet
 840 | 
 841 | context math(context)
 842 | snippet `(\\?[a-zA-Z]\w*)(?<![\\|s])(cr)` "hat" iA
 843 | \mathscr{``rv = m[1]``}
 844 | endsnippet
 845 | 
 846 | context math(context)
 847 | snippet `((\\?[a-hk-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(bav|BAV|base|BASE)` "base" iA
 848 | \hat{\boldsymbol{``rv = m[1]``}}
 849 | endsnippet
 850 | 
 851 | context math(context)
 852 | snippet `(i|j)(bav)` "ijbase" iA
 853 | \hat{\boldsymbol{\``rv=m[1]``math}}
 854 | endsnippet
 855 | 
 856 | context math(context)
 857 | snippet `((\\?[a-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(vec|VEC)` "vec" iA
 858 | \vec{``rv = m[1]``}
 859 | endsnippet
 860 | 
 861 | context math(context)
 862 | snippet `((\\?[a-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(bm)` "bm" iA
 863 | \boldsymbol{``rv = m[1]``}
 864 | endsnippet
 865 | 
 866 | context math(context)
 867 | snippet `((\\?[a-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(?<!math)(bf)` "bf" iA
 868 | \mathbf{``rv = m[1]``}
 869 | endsnippet
 870 | 
 871 | context math(context)
 872 | snippet `((\\?[a-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(?<!math)(cal)` "mathcal" iA
 873 | \mathcal{``rv = m[1]``}
 874 | endsnippet
 875 | 
 876 | priority 10
 877 | context math(context)
 878 | snippet `((\\?[a-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(dot)` "mathcal" iA
 879 | \dot{``rv = m[1]``}
 880 | endsnippet
 881 | 
 882 | priority 15
 883 | context math(context)
 884 | snippet `((\\?[a-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(ddot)` "mathcal" iA
 885 | \ddot{``rv = m[1]``}
 886 | endsnippet
 887 | 
 888 | priority 15
 889 | context math(context)
 890 | snippet `((\\?[a-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(vdot)` "mathcal" iA
 891 | \dot{\boldsymbol{``rv = m[1]``}}
 892 | endsnippet
 893 | 
 894 | priority 20
 895 | context math(context)
 896 | snippet `((\\?[a-zA-Z]\w*)|\\(mu|alpha|sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|xi|Pi|sigma|varsigma|Upsilon|Phi|Psi|Omega)[ |])(vddot)` "mathcal" iA
 897 | \ddot{\boldsymbol{``rv = m[1]``}}
 898 | endsnippet
 899 | 
 900 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 901 | # \\                letter                                                \\
 902 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 903 | 
 904 | priority 200000
 905 | context math(context)
 906 | snippet `(\\|)(mu|alpha|Sigma|varsigma|rho|beta|gamma|delta|zeta|eta|epsilon|varepsilon|theta|iota|kappa|vartheta|lambda|nu|pi|varpi|rho|tau|upsilon|phi|varphi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Pi|sigma|Upsilon|Phi|Psi|Omega)` "greek" iA
 907 | \``rv=m[2]`` 
 908 | endsnippet
 909 | 
 910 | context math(context)
 911 | snippet `ksi` "xi" iA
 912 | \xi 
 913 | endsnippet
 914 | 
 915 | context math(context)
 916 | snippet `gma` "gamma" iA
 917 | \gamma
 918 | endsnippet
 919 | 
 920 | context math(context)
 921 | snippet `Gma` "gamma" iA
 922 | \Gamma
 923 | endsnippet
 924 | 
 925 | context math(context)
 926 | snippet `dlt` "delta" iA
 927 | \delta 
 928 | endsnippet
 929 | 
 930 | context math(context)
 931 | snippet `(DA|Dlt)` "Delta" iA
 932 | \Delta 
 933 | endsnippet
 934 | 
 935 | priority 1000
 936 | context math(context)
 937 | snippet `(\\|)(var|)eps` "epsilon" iA
 938 | \``rv=m[2]``epsilon 
 939 | endsnippet
 940 | 
 941 | priority 1000
 942 | context math(context)
 943 | snippet `(\\|)ups` "upsilon" iA
 944 | \upsilon 
 945 | endsnippet
 946 | 
 947 | context math(context)
 948 | snippet `kpa` "kappa" iA
 949 | \kappa 
 950 | endsnippet
 951 | 
 952 | context math(context)
 953 | snippet `lbd` "lambda" iA
 954 | \lambda 
 955 | endsnippet
 956 | 
 957 | context math(context)
 958 | snippet `Lbd` "Lambda" iA
 959 | \Lambda 
 960 | endsnippet
 961 | 
 962 | context math(context)
 963 | snippet `omg` "omega" iA
 964 | \omega 
 965 | endsnippet
 966 | 
 967 | context math(context)
 968 | snippet `Omg` "Omega" iA
 969 | \Omega 
 970 | endsnippet
 971 | 
 972 | context math(context)
 973 | snippet `\\(epsilon|phi|pi|sigma|theta)(| )var` "var greek" iA
 974 | \var``rv=m[1]``
 975 | endsnippet
 976 | 
 977 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 978 | # \\                arrows                                                \\
 979 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
 980 | 
 981 | priority 10
 982 | context math(context)
 983 | snippet `(|\\)(r|R)arr` "-> & =>" iA
 984 | \``rv=m[2]``ightarrow
 985 | endsnippet
 986 | 
 987 | priority 10
 988 | context math(context)
 989 | snippet `(|\\)(l|L)arr` "-> & =>" iA
 990 | \``rv=m[2]``eftarrow
 991 | endsnippet
 992 | 
 993 | priority 10
 994 | context math(context)
 995 | snippet `(|\\)(u|U)arr` "-> & =>" iA
 996 | \``rv=m[2]``parrow
 997 | endsnippet
 998 | 
 999 | priority 10
1000 | context math(context)
1001 | snippet `(|\\)(d|D)arr` "-> & =>" iA
1002 | \``rv=m[2]``ownarrow
1003 | endsnippet
1004 | 
1005 | priority 20
1006 | context math(context)
1007 | snippet `(r|R)rarr` "-->" iA
1008 | \``rv=m[1]=="r"?"l":"L"``ongrightarrow 
1009 | endsnippet
1010 | 
1011 | priority 20
1012 | context math(context)
1013 | snippet `llarr` "<--" iA
1014 | \longleftarrow 
1015 | endsnippet
1016 | 
1017 | priority 30
1018 | context math(context)
1019 | snippet `lrarr` "<->" iA
1020 | \leftrightarrow 
1021 | endsnippet
1022 | 
1023 | priority 30
1024 | context math(context)
1025 | snippet `udarr` "<->" iA
1026 | \updownarrow 
1027 | endsnippet
1028 | 
1029 | context math(context)
1030 | snippet `FF` "<>" iA
1031 | \Leftrightarrow 
1032 | endsnippet
1033 | 
1034 | context math(context)
1035 | snippet `<>` "<>" iA
1036 | \Longleftrightarrow 
1037 | endsnippet
1038 | 
1039 | priority 10
1040 | context math(context)
1041 | snippet `>=` ">=" iA
1042 | \geq 
1043 | endsnippet
1044 | 
1045 | priority 10
1046 | context math(context)
1047 | snippet `<=` "<=" iA
1048 | \leq 
1049 | endsnippet
1050 | 
1051 | context math(context)
1052 | snippet `<<` "<<" iA
1053 | \ll 
1054 | endsnippet
1055 | 
1056 | context math(context)
1057 | snippet `>>` "<<" iA
1058 | \gg 
1059 | endsnippet
1060 | 
1061 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
1062 | # \\                colors                                                \\
1063 | # \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
1064 | 
1065 | context math(context)
1066 | snippet `\\(red|green|blue)` "useful color" iA
1067 | {\color{``rv=m[1]``}${1:``rv=VISUAL()``}}$0
1068 | endsnippet
1069 | 


--------------------------------------------------------------------------------
/for 0.2.7+/latex.hsnips:
--------------------------------------------------------------------------------
   1 | ##########################################
   2 | #                                        #
   3 | #    HyperSnips snippets for LaTeX       #
   4 | #                                        #
   5 | #       2022/01/06   @yf-zhao            #
   6 | #                                        #
   7 | #        For Hypersnips 0.2.7+           #
   8 | #                                        #
   9 | #                                        #
  10 | ##########################################
  11 | 
  12 | #### Index ####
  13 | 
  14 | # 0  Global Function
  15 | # 1  Special snippets
  16 | # 2  <null>
  17 | # 3  Math Notation
  18 | # 4  Greek letter
  19 | # 5  Matrices
  20 | # 6  Fraction
  21 | # 7  Superscript & subscript
  22 | # 8  prefix Mode
  23 | # 9  Unit Mode
  24 | # 10 Other Environment
  25 | # 11 Transform similar notations
  26 | # 12 for Special Courses
  27 | # 13 Other notations & commands
  28 | # 14 lint
  29 | # 15 Temp
  30 | # 16 Trash
  31 | 
  32 | 
  33 | 
  34 | #### Global JavaScript Function ####
  35 | 
  36 | global
  37 | 
  38 | // vscode api (necessary)
  39 | 
  40 |         const vscode = require("vscode");
  41 |         let editor=vscode.window.activeTextEditor
  42 |         let document=editor.document
  43 | 
  44 | 
  45 |         // get ActiveTextEditor
  46 | 
  47 |         vscode.window.onDidChangeActiveTextEditor((e) => {
  48 |             editor=vscode.window.activeTextEditor;
  49 |             document=editor.document
  50 |         });
  51 | 
  52 |         // show time in StatusBar
  53 | 
  54 |         setInterval(function(){myTimer()},1000);
  55 |         function myTimer(){
  56 |             vscode.window.setStatusBarMessage(new Date().toLocaleTimeString());
  57 |         }
  58 | 
  59 | // selected text : use ``rv=visual();`` to get selected text
  60 | 
  61 |     let selectedText = "";
  62 | 
  63 |     vscode.window.onDidChangeTextEditorSelection((e) => {
  64 |         const newSelectedText = e.textEditor.document.getText(e.selections[0]);
  65 |         if (newSelectedText) {
  66 |             selectedText = newSelectedText.replace(/\\/g,"\\\\");
  67 |         }
  68 |     });
  69 | 
  70 |     function visual(){
  71 |         const visualText = selectedText;
  72 |         selectedText = "";
  73 |         return visualText;
  74 |     }
  75 | 
  76 | // generate matrix : use ``rv = gen_matrix(snip, "p" , 2 , 3 , 1)`` to get a 2*3 display pmatrix
  77 |              //   snip : snip varible
  78 |              //   flag : string. 'p', 'b' , 'B' , 'v' , 'V' ,'' . default value = ''
  79 |              //   nrow : int.    row of matrix
  80 |              //   ncol : int.    column of matrix
  81 |              //   index: int.    '\n' or '' for last char of line.  1:'\n' ; 0: ''.
  82 | 
  83 |     function gen_matrix(snip,flag, nrow, ncol, index) {
  84 |         addPackage('amsmath')
  85 |     	let results = "\\\\begin{"+`${flag?flag:''}`+"matrix}";
  86 |     	let order = 1;
  87 |         let lf = index ? "\n" : "";
  88 |     	for (let i=0; i<nrow; i++){
  89 |             results += (lf + "  ");
  90 |     		for(let j = 0;j <ncol;j++){
  91 |     			results += `${snip.tabstop(order)}` + ((j == ncol -1) ?  " \\\\\\\\" : " & ");
  92 |     			order ++;
  93 |     		}
  94 |     	}
  95 |     	return results += (lf +"\\\\end{"+`${flag?flag:''}`+"matrix}");
  96 |     }
  97 | 
  98 | 
  99 | // transformation cycle
 100 | 
 101 |     function cycle(arr,str){
 102 |         let count = 0 ;
 103 |         while (str!=arr[++count] && count<arr.length);
 104 |         return arr[(count+1)%arr.length];
 105 |     }
 106 | 
 107 | // add package
 108 | 
 109 |     function addPackage(package){
 110 |         let range = new vscode.Range(new vscode.Position(0, 0), editor.selection.active)
 111 |         let text = editor.document.getText(range);
 112 |         if (text.indexOf(package)== -1){
 113 |             vscode.window.showInformationMessage(`未检测到 \'${package}\' 包引入，是否立即要引入此包？`, '是', '否').then(result => {
 114 | 	        if (result === '是') {
 115 |                     vscode.window.activeTextEditor.edit(editBuilder => {
 116 |                         if (editor.document.getText(range).indexOf(package) === -1)
 117 |                             editBuilder.insert(new vscode.Position(1, 0), `\\usepackage{${package}}\n`);
 118 |                     });
 119 | 	            }
 120 |             });
 121 |         }
 122 |     }
 123 | 
 124 | // Context definition
 125 | 
 126 |     // math
 127 | 
 128 |         function math(context) {
 129 |             return context.scopes.some(s => s.includes("math"));
 130 |         }
 131 | 
 132 |     // inline & block math
 133 | 
 134 |         function inline_math(context){
 135 |             return context.scopes.some(s => s.includes("math")) && !context.scopes.some(s => s.includes("math.block.environment"));
 136 |         }
 137 | 
 138 |         function block_math(context){
 139 |             return context.scopes.some(s => s.includes("math.block.environment")) ;
 140 |         }
 141 | 
 142 |     // {aligned} environment
 143 | 
 144 |         function isAlignedEnvironment(editor) {
 145 |             let text = editor.document.getText(new vscode.Range(new vscode.Position(0, 0), editor.selection.start));
 146 |             const reg = /\\begin\{aligned\}[^\$]*?\\end\{aligned\}/g;
 147 |             text = text.replace(reg, '');
 148 |             return (text.indexOf('\\begin{aligned}') == -1)?false:true;
 149 |         }
 150 | 
 151 | 
 152 |     // Unit Environment
 153 | 
 154 |         function isUnitMode(editor) {
 155 |             let pos = editor.selection.active;
 156 |             const reg = /\\mathrm\{\\,[^\$]*?\}/g;
 157 |             let text = editor.document.getText(new vscode.Range(pos.line,0,pos.line,pos.character)).replace(reg, '');
 158 |             return (text.indexOf('\\mathrm{\\,') != -1)
 159 |         }
 160 | 
 161 | // Dic
 162 | 
 163 |     // Greek Letter
 164 | 
 165 |     const greek  = {
 166 |             "a" : "\\alpha",
 167 |             "b" : "\\beta",
 168 |             "c" : "\\chi",
 169 |             "d" : "\\delta",
 170 |             "e" : "\\epsilon",
 171 |             "ve": "\\varepsilon",
 172 |             "f" : "\\phi",
 173 |             "vf" : "\\varphi",
 174 |             "g" : "\\gamma",
 175 |             "h" : "\\eta",
 176 |             "i" : "\\iota",
 177 |             "j" : "\\varphi",
 178 |             "k" : "\\kappa",
 179 |             "vk": "\\varkappa",
 180 |             "l" : "\\lambda",
 181 |             "m" : "\\mu",
 182 |             "n" : "\\nu",
 183 |             "o" : "\\omicron",
 184 |             "p" : "\\pi",
 185 |             "vp" : "\\varpi",
 186 |             "q" : "\\theta",
 187 |             "vq" : "\\vartheta",
 188 |             "r" : "\\rho",
 189 |             "s" : "\\sigma",
 190 |             "vs" : "\\varsigma",
 191 |             "t" : "\\tau",
 192 |             "u" : "\\upsilon",
 193 |             "v" : "\\varpi",
 194 |             "w" : "\\omega",
 195 |             "x" : "\\xi",
 196 |             "y" : "\\psi",
 197 |             "z" : "\\zeta",
 198 |             "A" : "\\Alpha",
 199 |             "B" : "\\Beta",
 200 |             "C" : "\\Chi",
 201 |             "D" : "\\Delta",
 202 |             "E" : "\\Epsilon",
 203 |             "F" : "\\Phi",
 204 |             "G" : "\\Gamma",
 205 |             "H" : "\\Eta",
 206 |             "I" : "\\Iota",
 207 |             "K" : "\\Kappa",
 208 |             "L" : "\\Lambda",
 209 |             "M" : "\\Mu",
 210 |             "N" : "\\Nu",
 211 |             "O" : "\\Omicron",
 212 |             "P" : "\\Pi",
 213 |             "Q" : "\\Theta",
 214 |             "R" : "\\Rho",
 215 |             "S" : "\\Sigma",
 216 |             "T" : "\\Tau",
 217 |             "U" : "\\Upsilon",
 218 |             "W" : "\\Omega",
 219 |             "X" : "\\Xi",
 220 |             "Y" : "\\Psi",
 221 |             "Z" : "\\Zeta"
 222 |         };
 223 | 
 224 |     // prefix
 225 | 
 226 |     const prefix = {
 227 |         "bar" : ["\\\\overline{"             ,"}"   ],
 228 |         "fn"  : ["\\\\overset{\\\\frown}{"   ,"}"   ],
 229 |         "td"  : ["\\\\widetilde{"            ,"}"   ],
 230 |         "rm"  : ["\\\\mathrm{"               ,"}"   ],
 231 |         "hat" : ["\\\\hat{"                  ,"}"   ],
 232 |         "cr"  : ["\\\\mathscr{"              ,"}"   ],
 233 |         "bav" : ["\\\\hat{\\\\boldsymbol{"   ,"}}"  ],
 234 |         "vec" : ["\\\\vec{"                  ,"}"   ],
 235 |         "bm"  : ["\\\\boldsymbol{"           ,"}"   ],
 236 |         "bf"  : ["\\\\mathbf{"               ,"}"   ],
 237 |         "cal" : ["\\\\mathcal{"              ,"}"   ],
 238 |         "dot"  : ["\\\\dot{"                  ,"}"   ],
 239 |         "vdot" : ["\\\\dot{\\\\boldsymbol{"   ,"}}"  ]
 240 |     }
 241 | 
 242 |     //  block
 243 | 
 244 | 
 245 |     const block = {
 246 |         "tm" : ["Thm"        ,"brown"  ,"▶",0],
 247 |         "tt" : ["Thm"        ,"brown"  ,"▶",1],
 248 |         "ex" : ["Ex"         ,"teal"   ,"▶",0],
 249 |         "pf" : ["Pf"         ,"green"  ,"▶",0],
 250 |         "pb" : ["Problem"    ,"teal"   ,"▶",0],
 251 |         "sn" : ["Sol"        ,"green"  ,"▶",0],
 252 |         "df" : ["Def"        ,"purple" ,"▶",0],
 253 |         "dd" : ["Def"        ,"purple" ,"▶",1],
 254 |         "st" : ["Step"       ,"orange" ,"▶",0],
 255 |         "md" : ["Method"     ,"brown"  ,"■",0],
 256 |         "cc" : ["Case"       ,"brown"  ,"●",0],
 257 |         "ds" : ["Discussion" ,"brown"  ,"■",0],
 258 |     }
 259 | 
 260 |     const arrow = {
 261 |         'r' : 'right',
 262 |         'R' : 'Right',
 263 |         'l' : 'left',
 264 |         'L' : 'Left',
 265 |         'lr':'leftright',
 266 |         'Lr':'Leftright',
 267 |         'u' : 'up',
 268 |         'U' : 'Up',
 269 |         'd' : 'down',
 270 |         'D': 'Down',
 271 |         'ud':'updown',
 272 |         'Ud':'Updown',
 273 |         'rr': 'longright',
 274 |         'll': 'longleft',
 275 |         'RR': 'Longright',
 276 |         'LL': 'Longleft',
 277 |         'se': 'se',
 278 |         'sw': 'sw',
 279 |         'ne': 'ne',
 280 |         'nw': 'nw'
 281 |     }
 282 | 
 283 | ///////////////////// trash  ////////////////////
 284 | 
 285 | 
 286 | // autoclosing environment
 287 | 
 288 | function autoclosing(){
 289 |     let pos=editor.selection.active;
 290 |     let text = document.getText(document.lineAt(pos).range).charAt(pos.character+1);
 291 |     let reg=/[;:.,=\}\]\)>\\` \n\t\$*\|\\]/g;
 292 |     return reg.test(text) || text==""
 293 | }
 294 | 
 295 | endglobal
 296 | 
 297 | 
 298 | 
 299 | 
 300 | ##########################################################
 301 | #                       Test                             #
 302 | ##########################################################
 303 | ################### Only for Test !!! ####################
 304 | 
 305 | ##########################################################
 306 | #                   special snippets                     #
 307 | ##########################################################
 308 | 
 309 | # protect "oiint" "iiint" "asccos" "mathtt" "mathbb"
 310 | priority 99999999
 311 | context math(context)
 312 | snippet `(?<=(oii|iii|ascc|mathtt|mathbb|hetan))` "prevent" iA
 313 | 
 314 | endsnippet
 315 | 
 316 | # \displaystyle in `inline-math`
 317 | 
 318 | context inline_math(context)
 319 | snippet `\$([^\$]*)DS` "Displaystyle" iA
 320 | ``rv=`$\\\\displaystyle${m[1]? " "+m[1] : ""}```
 321 | endsnippet
 322 | 
 323 | 
 324 | 
 325 | 
 326 | ##########################################################
 327 | #                     Math Notation                      #
 328 | ##########################################################
 329 | 
 330 | #### dots
 331 | #
 332 | # ... ⇨ \cdots
 333 | # ,,, ⇨ \vdots
 334 | # ... ⇨ \ddots
 335 | 
 336 | context math(context)
 337 | snippet `\.\.\.` "cdots" iA
 338 | ``rv='\\cdots '``
 339 | endsnippet
 340 | 
 341 | context math(context)
 342 | snippet `,,,` "vdots" iA
 343 | ``rv='\\vdots '``
 344 | endsnippet
 345 | 
 346 | context math(context)
 347 | snippet `:::` "ddots" iA
 348 | ``rv='\\ddots '``
 349 | endsnippet
 350 | 
 351 | #### integral  & Big Operators
 352 | #
 353 | # int   ⇨ \int   ║ ∫
 354 | # iint  ⇨ \iint  ║ ∫∫
 355 | # iiint ⇨ \iiint ║ ∫∫∫
 356 | # oint  ⇨ \oint  ║ ∮
 357 | # oiint ⇨ \oiint ║ ∯
 358 | 
 359 | priority 10
 360 | context math(context)
 361 | snippet `(?<=[^s])(?<!\\)[iI]nt` "int" iAM
 362 | \\int
 363 | endsnippet
 364 | 
 365 | priority 20
 366 | context math(context)
 367 | snippet `[\\]?iint` "iint" iA
 368 | \\iint
 369 | endsnippet
 370 | 
 371 | priority 100000
 372 | context math(context)
 373 | snippet `[\\]?iiint` "iiint" iA
 374 | \\iiint
 375 | endsnippet
 376 | 
 377 | priority 200000
 378 | context math(context)
 379 | snippet `(?<!\\)oint` "oint" iA
 380 | \\oint
 381 | endsnippet
 382 | 
 383 | priority 200000
 384 | context math(context)
 385 | snippet `[\\]?oiint` "oiint" iA
 386 | \\oiint
 387 | endsnippet
 388 | 
 389 | # lim      ⇨ \lim
 390 | # sum      ⇨ \sum
 391 | # intd     ⇨ int_{▮}^{▮}
 392 | # limd     ⇨ lim_{▮ \to ▮}
 393 | # \inta     ⇨ \int a
 394 | # \lim sup ⇨ \limsup
 395 | 
 396 | context math(context)
 397 | snippet `(?<!\\)(lim|sum)` "lim" iA
 398 | \\``rv=m[1]``
 399 | endsnippet
 400 | 
 401 | context math(context)
 402 | snippet `(lim|limsup|liminf)d` "lim and limsup" iA
 403 | ``rv=m[1]``_{$1 \\to $2}$0
 404 | endsnippet
 405 | 
 406 | context math(context)
 407 | snippet `(int|bigcap|bigcup|sum)d` "sum and int" iA
 408 | ``rv=m[1]``_{$1}^{$2}
 409 | endsnippet
 410 | 
 411 | context math(context)
 412 | snippet `(?<=\\lim)[ ]?(inf|sup)` "limsup&liminf" iA
 413 | ``rv=m[1]``
 414 | endsnippet
 415 | 
 416 | context math(context)
 417 | snippet `(int|\\lim|\\sum)([a-ce-zA-CE-Z])` "space after int" iA
 418 | ``rv=m[1]+" "+m[2]``
 419 | endsnippet
 420 | 
 421 | #### infinity
 422 | #
 423 | # oo      ⇨ \infty
 424 | # \inftyp ⇨ +\infty (oop ⇨ infty)
 425 | # \inftym ⇨ -\infty (oom ⇨ infty)
 426 | 
 427 | context math(context)
 428 | snippet `oo` "infinity" iA
 429 | \\infty
 430 | endsnippet
 431 | 
 432 | context math(context)
 433 | snippet `\\inftyp` "+infty" iA
 434 | +\\infty
 435 | endsnippet
 436 | 
 437 | context math(context)
 438 | snippet `\\inftym` "-infty" iA
 439 | -\\infty
 440 | endsnippet
 441 | 
 442 | #### derivative & partial derivative
 443 | #
 444 | # DD  ⇨ \frac{\mathrm{d}▮}{\mathrm{d}▮}  ║ 𝗱▮/𝗱▮
 445 | # PP  ⇨ \frac{\partial ▮}{\partial ▮}    ║ ∂▮/∂▮
 446 | # drm ⇨ \mathrm{\,d}                      ║  𝗱        ║ `priority 200` for ×⇨ \overline{h}
 447 | # ptl ⇨ \partial                          ║  ∂
 448 | 
 449 | context math(context)
 450 | snippet `DD` "diffraction" iA
 451 | \\frac{\\mathrm{d}$1}{\\mathrm{d}$2}
 452 | endsnippet
 453 | 
 454 | context math(context)
 455 | snippet `PP` "partial diffraction" iA
 456 | \\frac{\\partial $1}{\\partial $2}
 457 | endsnippet
 458 | 
 459 | priority 200
 460 | context math(context)
 461 | snippet `(\w)?drm` "dif" iA
 462 | ``rv=m[1]?(m[1]+" "):""``\\mathrm{\\,d}
 463 | endsnippet
 464 | 
 465 | context math(context)
 466 | snippet `ptl` "partial" iA
 467 | ``rv="\\partial "``
 468 | endsnippet
 469 | 
 470 | #### Arrows
 471 | #### use `arrow` dictionary
 472 | #
 473 | # ra; ⇨ \rightarrow
 474 | # ia; ⇨ \implies
 475 | # fa; ⇨ \iff
 476 | # to; ⇨ \to
 477 | 
 478 | priority 10
 479 | context math(context)
 480 | snippet `(r|R|l|L|lr|Lr|u|U|d|D|ud|Ud|rr|ll|RR|LL|se|sw|ne|nw)a;` "arrows" iA
 481 | ``rv="\\"+arrow[m[1]]+"arrow ";``
 482 | endsnippet
 483 | 
 484 | context math(context)
 485 | snippet `ia;` "implies" iA
 486 | ``rv='\\implies '``
 487 | endsnippet
 488 | 
 489 | context math(context)
 490 | snippet `fa;` "iff" iA
 491 | ``rv='\\iff '``
 492 | endsnippet
 493 | 
 494 | context math(context)
 495 | snippet `ta` "to" iA
 496 | ``rv='\\to '``
 497 | endsnippet
 498 | 
 499 | 
 500 | #### greater & less notations
 501 | #
 502 | # <= ⇨ \leq
 503 | # >= ⇨ \geq
 504 | # << ⇨ \ll
 505 | # >> ⇨ \gg
 506 | # >~ ⇨ \lesssim
 507 | # <~ ⇨ \gtrsim
 508 | 
 509 | context math(context)
 510 | snippet `>=` "≥" iA
 511 | ``rv='\\geq '``
 512 | endsnippet
 513 | 
 514 | context math(context)
 515 | snippet `<=` "≤" iA
 516 | ``rv='\\leq '``
 517 | endsnippet
 518 | 
 519 | context math(context)
 520 | snippet `<<` "≪" iA
 521 | ``rv='\\ll '``
 522 | endsnippet
 523 | 
 524 | context math(context)
 525 | snippet `>>` "≫" iA
 526 | ``rv='\\gg '``
 527 | endsnippet
 528 | 
 529 | context math(context)
 530 | snippet `<~` "≲" iA
 531 | ``rv='\\lesssim '``
 532 | endsnippet
 533 | 
 534 | context math(context)
 535 | snippet `>~` "≳" iA
 536 | ``rv='\\gtrsim '``
 537 | endsnippet
 538 | 
 539 | #### Square
 540 | #
 541 | # sq    ⇨ \sqrt{▮}
 542 | 
 543 | context math(context)
 544 | snippet `(?<!\\)sq` "square" iA
 545 | \\sqrt{$1}
 546 | endsnippet
 547 | 
 548 | #### set notations
 549 | #
 550 | # RR            ⇨ \mathbb{R}     ║  ℝ
 551 | # CC            ⇨ \mathbb{C}     ║  ℂ
 552 | # ZZ            ⇨ \mathbb{Z}     ║  ℤ
 553 | # \mathbb{R}+   ⇨ \mathbb{R}_+   (RR+ ⇨ ℝ⁺)
 554 | # \mathbb{R}n   ⇨ \mathbb{R}^n   (RRn ⇨ ℝⁿ)
 555 | # \mathbb{R}3   ⇨ \mathbb{R}^3   (RR3 ⇨ ℝ³)
 556 | 
 557 | context math(context)
 558 | snippet `RR|CC|ZZ` "sets" iA
 559 | \\mathbb{``rv=m[0].charAt(0)``}
 560 | endsnippet
 561 | 
 562 | priority 2000000
 563 | context math(context)
 564 | snippet `(\\mathbb\{R\})([mnkl\d])` "rset^n" iA
 565 | \\mathbb{R}^{``rv=m[2]``}
 566 | endsnippet
 567 | 
 568 | priority 2000000
 569 | context math(context)
 570 | snippet `(\\mathbb\{R\})\+` "rset_+" iA
 571 | \\mathbb{R}_+
 572 | endsnippet
 573 | 
 574 | 
 575 | #### Standard functions
 576 | #
 577 | # sin   ⇨ \sin
 578 | # \sin h ⇨ \sinh
 579 | # arcsin ⇨ \arcsin
 580 | # div    ⇨ \mathrm{Div.}
 581 | 
 582 | context math(context)
 583 | snippet `(?<!arc)(?<!\\)(sin|cos|tan|csc|sec|cot|ln|log|lg|det|ker|max|min)` "function" iA
 584 | \\``rv=m[1]+' '``
 585 | endsnippet
 586 | 
 587 | context math(context)
 588 | snippet `(?<!\\)arc(sin|cos|tan|csc|sec|cot)` "function" iA
 589 | \\arc``rv=m[1]+' '``
 590 | endsnippet
 591 | 
 592 | priority 20
 593 | context math(context)
 594 | snippet `(?<=\\(sin|cos|tan|csc|sec|cot))( )h` "function" iA
 595 | ``rv='h '``
 596 | endsnippet
 597 | 
 598 | context math(context)
 599 | snippet `curl|div|grad` "vec calculus" iA
 600 | \\mathrm{``rv=m[0].charAt(0).toUpperCase()+m[0].substr(1)``.}
 601 | endsnippet
 602 | 
 603 | 
 604 | #### Binary Operation & Relation Symbols
 605 | #
 606 | # == ⇨ \equiv   ║     ≡
 607 | # OO ⇨ \cdot    ║     ·
 608 | # ~~ ⇨ \sim     ║     ~
 609 | # NN ⇨ \cap     ║     ∩
 610 | # UU ⇨ \cup     ║     ∪
 611 | # II ⇨ \in      ║     ∈
 612 | # XX ⇨ \times   ║     ×
 613 | # opo ⇨ \oplus  ║     ⊕
 614 | # oxo ⇨ \otimes ║     ⊗
 615 | # omo ⇨ \ominus ║     ⊖
 616 | # oco ⇨ \propto ║     ∝
 617 | 
 618 | 
 619 | 
 620 | context math(context) && !isAlignedEnvironment(editor)
 621 | snippet `==` "xlongequal" iA
 622 | \\equiv``rv=' '``
 623 | endsnippet
 624 | 
 625 | context math(context)
 626 | snippet `OO` "cdot" iA
 627 | \\cdot``rv=' '``
 628 | endsnippet
 629 | 
 630 | context math(context)
 631 | snippet `~~` "sim" iA
 632 | \\sim``rv=' '``
 633 | endsnippet
 634 | 
 635 | context math(context)
 636 | snippet `NN` "cap" iA
 637 | \\cap``rv=' '``
 638 | endsnippet
 639 | 
 640 | context math(context)
 641 | snippet `UU` "cup" iA
 642 | \\cup``rv=' '``
 643 | endsnippet
 644 | 
 645 | context math(context)
 646 | snippet `II` "in" iA
 647 | \\in``rv=' '``
 648 | endsnippet
 649 | 
 650 | context math(context)
 651 | snippet `XX` "times" iA
 652 | \\times``rv=' '``
 653 | endsnippet
 654 | 
 655 | context math(context)
 656 | snippet `opo` "oplus" iA
 657 | \\oplus``rv=' '``
 658 | endsnippet
 659 | 
 660 | context math(context)
 661 | snippet `omo` "oplus" iA
 662 | \\ominus``rv=' '``
 663 | endsnippet
 664 | 
 665 | context math(context)
 666 | snippet `oxo` "otimes" iA
 667 | \\otimes``rv=' '``
 668 | endsnippet
 669 | 
 670 | context math(context)
 671 | snippet `oco` "oplus" iA
 672 | \\propto``rv=' '``
 673 | endsnippet
 674 | 
 675 | 
 676 | #### other operators and notations
 677 | #
 678 | # nbl ⇨ \nable          ║   ▽
 679 | # AA  ⇨ \forall         ║   ∀
 680 | # EE  ⇨ \exist          ║   ∃
 681 | # abs ⇨ \left|▮\right|
 682 | # ||  ⇨ \left|▮\right|
 683 | # VV  ⇨ \times 10^{▮}  ║   ×10▘
 684 | # !=  ⇨ \not =          ║   ≠
 685 | 
 686 | context math(context)
 687 | snippet `(\\?)(nbl)` "nabla" iA
 688 | ``rv='\\\\nabla '``
 689 | endsnippet
 690 | 
 691 | context math(context)
 692 | snippet `AA` "forall" iA
 693 | \\forall``rv=' '``
 694 | endsnippet
 695 | 
 696 | context math(context)
 697 | snippet `EE` "exist" iA
 698 | \\exist``rv=' '``
 699 | endsnippet
 700 | 
 701 | context math(context)
 702 | snippet `(\|\||abs)` "abs" iA
 703 | \\left|$1\\right|$0
 704 | endsnippet
 705 | 
 706 | context math(context)
 707 | snippet `(?<=(\$)?)VV` "*10^{}" iA
 708 | ``rv=m[1]?"":"\\\\times "``10^{$1}$0
 709 | endsnippet
 710 | 
 711 | context math(context)
 712 | snippet `\!=` "not =" iA
 713 | \\not =
 714 | endsnippet
 715 | 
 716 | 
 717 | 
 718 | 
 719 | #########################################################
 720 | #                      Greek letter                     #
 721 | #########################################################
 722 | 
 723 | #### Greek letter
 724 | #### use `greek` dictionary
 725 | #
 726 | # alpha ⇨ \alpha ║ α
 727 | # a;    ⇨ \alpha ║ α
 728 | 
 729 | context math(context)
 730 | snippet `[\\]?(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta)` "greek" iA
 731 | \\``rv=m[1]``
 732 | endsnippet
 733 | 
 734 | context math(context)
 735 | snippet `(?<![a-zA-Z])([a-zA-IK-UW-Z]|v[efkpqs]);` "greek" iA
 736 | ``rv=greek[m[1]];``
 737 | endsnippet
 738 | 
 739 | #### var perfix
 740 | #
 741 | # phivar ⇨ \varphi
 742 | 
 743 | context math(context)
 744 | snippet `\\(epsilon|phi|pi|sigma|theta|kappa)[ ]?var` "var greek" iA
 745 | \\var``rv=m[1]``
 746 | endsnippet
 747 | 
 748 | #### space after Greek letter
 749 | #
 750 | # \alphab ⇨ \alpha b
 751 | 
 752 | context math(context)
 753 | snippet `\\(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta)([a-zA-z])` "space after greek letter" iA
 754 | ``rv='\\\\'+m[1]+' '+m[2]``
 755 | endsnippet
 756 | 
 757 | 
 758 | 
 759 | 
 760 | #########################################################
 761 | #                         matrices                      #
 762 | #########################################################
 763 | 
 764 | #### blocked math
 765 | #
 766 | # bmat22 ⇨
 767 | #       \begin{bmatrix}
 768 | #          ▮ & ▮ \\
 769 | #          ▮ & ▮ \\
 770 | #       \end{bmatrix}
 771 | #
 772 | # cv2 ⇨
 773 | #       \begin{bmatrix}
 774 | #          ▮ \\
 775 | #          ▮ \\
 776 | #       \end{bmatrix}
 777 | #
 778 | # rv2 ⇨
 779 | #       \begin{bmatrix}
 780 | #          ▮ & ▮ \\
 781 | #       \end{bmatrix}
 782 | 
 783 | 
 784 | priority 2000
 785 | context block_math(context)
 786 | snippet `([bBpvV])?mat([1-9])([1-9])` "matrix" iA
 787 | ``rv = gen_matrix(snip,m[1],m[2],m[3],1);``
 788 | endsnippet
 789 | 
 790 | priority 2000000
 791 | context block_math(context)
 792 | snippet `([bp])?rv([1-9])` "row vector" iA
 793 | ``rv = gen_matrix(snip,m[1]?m[1]:"b",1,m[2],1);``
 794 | endsnippet
 795 | 
 796 | priority 2000000
 797 | context block_math(context)
 798 | snippet `([bp])?cv([1-9])` "column vector" iA
 799 | ``rv = gen_matrix(snip,m[1]?m[1]:"b",m[2],1,1);``
 800 | endsnippet
 801 | 
 802 | #### inline math
 803 | #
 804 | # bmat22 ⇨
 805 | #       \begin{bmatrix} ▮ & ▮ \\ ▮ & ▮ \\  \end{bmatrix}
 806 | #
 807 | # cv2 ⇨
 808 | #       \begin{bmatrix} ▮ \\ ▮ \\  \end{bmatrix}
 809 | #
 810 | # rv2 ⇨
 811 | #       \begin{bmatrix} ▮ & ▮ \\  \end{bmatrix}
 812 | 
 813 | priority 2000
 814 | context inline_math(context)
 815 | snippet `([bBpvV])?mat([1-9])([1-9])` "matrix" iA
 816 | ``rv = gen_matrix(snip,m[1],m[2],m[3],0);``
 817 | endsnippet
 818 | 
 819 | priority 2000000
 820 | context inline_math(context)
 821 | snippet `([bp])?rv([1-9])` "row vector" iA
 822 | ``rv = gen_matrix(snip,m[1]?m[1]:"b",1,m[2],0);``
 823 | endsnippet
 824 | 
 825 | priority 2000000
 826 | context inline_math(context)
 827 | snippet `([bp])?cv([1-9])` "column vector" iA
 828 | ``rv = gen_matrix(snip,m[1]?m[1]:"b",m[2],1,0);``
 829 | endsnippet
 830 | 
 831 | #########################################################
 832 | #                         fraction                      #
 833 | #########################################################
 834 | 
 835 | context math(context) && !isUnitMode(editor)
 836 | snippet `//` "Fraction" iA
 837 | \\frac{$1}{$2}$0
 838 | endsnippet
 839 | 
 840 | priority 10
 841 | context math(context) && !isUnitMode(editor)
 842 | snippet `((\d+)|(\d*)([A-Za-z]+|[a-zA-Z]?\\(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta))((\^|_)(\{\w+\}|\w)|')*)/` "Fraction " A
 843 | \\frac{``rv = m[1]``}{$1}$0
 844 | endsnippet
 845 | 
 846 | 
 847 | 
 848 | 
 849 | 
 850 | 
 851 | #########################################################
 852 | #                Superscript & Subscript                #
 853 | #########################################################
 854 | 
 855 | #### Superscript
 856 | #
 857 | # pw  ⇨ ^{▮}
 858 | # sr  ⇨ ^2
 859 | # 3;  ⇨ ^3
 860 | # _3; ⇨ ^3
 861 | # dag ⇨ ^\dagger
 862 | # coj ⇨ ^*
 863 | # inv ⇨ ^{-1}
 864 | # trs ⇨ ^T
 865 | # exp ⇨ \mathrm{e}^{▮}    ║      𝗲▘
 866 | 
 867 | context math(context)
 868 | snippet `(?<!\\)pw` "^n" iA
 869 | ^{$1}$0
 870 | endsnippet
 871 | 
 872 | context math(context)
 873 | snippet `(?<!\\)sr` "^2" iA
 874 | ^{2}
 875 | endsnippet
 876 | 
 877 | context math(context)
 878 | snippet `[_ ]?([\d]+);` "^\d" iA
 879 | ^{``rv=m[1]``}
 880 | endsnippet
 881 | 
 882 | context math(context)
 883 | snippet `_([a-z]);` "^m" iA
 884 | ^``rv=m[1]``
 885 | endsnippet
 886 | 
 887 | context math(context)
 888 | snippet `(?<!\\)dag` "dagger" iA
 889 | ^\\dagger``rv=' '``
 890 | endsnippet
 891 | 
 892 | context math(context)
 893 | snippet `coj` "conjugate" iA
 894 | ^*
 895 | endsnippet
 896 | 
 897 | context math(context)
 898 | snippet `inv` "inverse" iA
 899 | ^{-1}
 900 | endsnippet
 901 | 
 902 | context math(context)
 903 | snippet `trs` "trs" iA
 904 | ^T
 905 | endsnippet
 906 | 
 907 | context math(context)
 908 | snippet `(?<!\\)exp` "exp" iA
 909 | \mathrm{e}^{$1}$0
 910 | endsnippet
 911 | 
 912 | 
 913 | #### Subscript
 914 | #
 915 | # sc        ⇨ _{▮}
 916 | # rmm       ⇨ r_m
 917 | # \alpha mm ⇨ \alpha _m
 918 | # a1        ⇨ a_1
 919 | # a_12      ⇨ a_{12}
 920 | # a_1xx     ⇨ a_{1x}    |  ×⇨ a_1_x
 921 | # a_x1      ⇨ a_{x1}
 922 | # a_xyy     ⇨ a_{xy}
 923 | 
 924 | context math(context)
 925 | snippet `(?<!(math|\\))sc` "script main" iA
 926 | _{$1}$0
 927 | endsnippet
 928 | 
 929 | context math(context) && !isUnitMode(editor)
 930 | snippet `(?<!_)([A-Za-z][']*)(?<!mat)(\d|([a-z])\3{1})` "for a_1, a_x, \alpha_1" iA
 931 | ``rv = `${m[1]}_${m[2].charAt(0)}```
 932 | endsnippet
 933 | 
 934 | context math(context)
 935 | snippet `(?<!_)\\(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta)[']*[ ]?([a-z])\2{1}` "for \alpha_x" iA
 936 | ``rv=`\\\\${m[1]}_${m[2]}```
 937 | endsnippet
 938 | 
 939 | priority 100
 940 | context math(context)
 941 | snippet `(?<=_)(([\da-z]|\\(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta))\d)` "for a_{12}, a_{x1}, a_{\alpha1}" iA
 942 | {``rv = m[1]``}
 943 | endsnippet
 944 | 
 945 | context math(context)
 946 | snippet `(?<=_)([\da-z])([a-z])\2` "for a_{1i}, a_{ij}" iA
 947 | {``rv=m[1]+m[2] ``}
 948 | endsnippet
 949 | 
 950 | 
 951 | 
 952 | 
 953 | 
 954 | #########################################################
 955 | #                        prefix mode                    #
 956 | #########################################################
 957 | 
 958 | #### use `prefix` dictionary
 959 | 
 960 | context math(context)
 961 | snippet `((?<![_\^])\d+|((?<![_\^])\d*)([A-Za-z]+|\\(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta)[ ]?))(?<!\\)(bar|fn|td|rm|hat|cr|bav|vec|bm|bf|cal|dot|vdt)` "prefix mode" iA
 962 | ``
 963 | let testPrefix = prefix[m[m.length-1]];
 964 | rv = testPrefix[0] + m[1] + testPrefix[1];
 965 | ``
 966 | endsnippet
 967 | 
 968 | priority 100
 969 | context math(context)
 970 | snippet `((?<![_\^])\d+|(?:(?<![_\^])\d*)(?:[A-Za-z]+|\\(?:alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta)[ ]?)[']*)(((\^|_)(\{\w+\}|\w))+)(?<!\\)(bar|fn|td|rm|hat|cr|bav|vec|bm|bf|cal|dot|vdt)` "prefix mode" iA
 971 | ``
 972 | let testPrefix = prefix[m[m.length-1]];
 973 | rv = testPrefix[0] + m[1] + testPrefix[1]+m[2];
 974 | ``
 975 | endsnippet
 976 | 
 977 | 
 978 | 
 979 | #########################################################
 980 | #                        Unit Mode                      #
 981 | #########################################################
 982 | 
 983 | #### trigger 'unitMode'
 984 | #
 985 | # SS ⇨ \mathrm{\
 986 | 
 987 | context math(context)
 988 | snippet `SS` "Unit mode" iA
 989 | \\mathrm{\\,$1}$0
 990 | endsnippet
 991 | 
 992 | #### Only available in 'UnitMode'
 993 | 
 994 | # m3    ⇨ m^3
 995 | # m-    ⇨ m^{-▮}
 996 | # .     ⇨ \cdot
 997 | # cdg  ⇨ \degree C   ║ ℃
 998 | # J/kg. ⇨ J/(kg·▮)
 999 | 
1000 | context isUnitMode(editor)
1001 | snippet `(?<=[A-Za-z])(\d)` "^\d" iA
1002 | ^``rv=m[1]``
1003 | endsnippet
1004 | 
1005 | context isUnitMode(editor)
1006 | snippet `-` "^-" iA
1007 | ^{-$1}$0
1008 | endsnippet
1009 | 
1010 | priority 10
1011 | context isUnitMode(editor)
1012 | snippet . "·" iA
1013 | ``rv='\\\\cdot '``
1014 | endsnippet
1015 | 
1016 | priority 10
1017 | context isUnitMode(editor)
1018 | snippet `cdg` "℃" iA
1019 | \\degree C
1020 | endsnippet
1021 | 
1022 | priority 20
1023 | context isUnitMode(editor)
1024 | snippet `(?<=\\mathrm\{\\,(?!.*\\mathrm\{\\,)[^\$]*\/)([^\(]*?)\.` "\cdot" iA
1025 | (``rv=m[1]``\\cdot $1)$2
1026 | endsnippet
1027 | 
1028 | 
1029 | 
1030 | 
1031 | #########################################################
1032 | #                    Other  Environments                #
1033 | #########################################################
1034 | 
1035 | #### 'aligned' environment
1036 | #
1037 | # aln ⇨  \begin{aligned}
1038 | #              ▮
1039 | #         \end{aligned}
1040 | #
1041 | # baln ⇨ \begin{aligned}
1042 | #             &▮
1043 | #         \end{aligned}
1044 | #
1045 | # =ealn ⇨ \begin{aligned}
1046 | #              a&=▮
1047 | #          \end{aligned}
1048 | #
1049 | # Aln ⇨ \begin{aligned}
1050 | #             {visual}
1051 | #        \end{aligned}
1052 | #
1053 | # ==    ⇨   &=
1054 | 
1055 | priority 200
1056 | context block_math(context)
1057 | snippet `(.*(?<!b|e))([be]?)aln` "Align" iA
1058 | ``addPackage('amsmath');``\\begin{aligned}
1059 |     ``rv = ((m[2]=="b") ? "&":"") + ((m[2]=="e") ? m[1].replace("=","&=") : m[1]).replace(/\\/g,"\\\\");
1060 |     ``$0
1061 | \\end{aligned}
1062 | endsnippet
1063 | 
1064 | context isAlignedEnvironment(editor)
1065 | snippet `==` "&=" iA
1066 | &=
1067 | endsnippet
1068 | 
1069 | priority 300
1070 | context block_math(context)
1071 | snippet `Aln` "align" iA
1072 | \\begin{aligned}
1073 |     ``rv = visual();``$0
1074 | \\end{aligned}
1075 | endsnippet
1076 | 
1077 | #### `case` & `rcase` environment
1078 | 
1079 | context math(context)
1080 | snippet `(?<!\{[a-zA-Z]*)(case|rcase)` "case" iA
1081 | \\begin{``rv=m[1]``s}
1082 |     $1
1083 | \\end{``rv=m[1]``s}$0
1084 | endsnippet
1085 | 
1086 | #### `text`
1087 | 
1088 | context math(context)
1089 | snippet `(?<!\\)(txt|tst|text)` "text" iA
1090 | \\text{$1}$0
1091 | endsnippet
1092 | 
1093 | 
1094 | ##########################################################
1095 | #               transform similar notations              #
1096 | ##########################################################
1097 | 
1098 | #### Arrows (trigger: `;`)
1099 | #
1100 | # (→) ⇨ (⇒) ⇨ (⟶) ⇨ (⟹) ⇨ (→)(\to) ⇨ (⟹)(\implies)
1101 | # (←) ⇨ (⇐) ⇨ (⟵) ⇨ (⟸) ⇨ (⟸)(\impliedby)
1102 | # (↔) ⇨ (⇔) ⇨ (⟷) ⇨ (⟺) ⇨ (⟺)(\iff)
1103 | # (↓) ⇨ (⇓)
1104 | # (↑) ⇨ (⇑)
1105 | # (↕) ⇨ (⇕)
1106 | 
1107 | context math(context)
1108 | snippet `(\\rightarrow|\\Rightarrow|\\longrightarrow|\\Longrightarrow|\\to|\\implies)(| );` "⟹" Ai
1109 | ``
1110 | let r=["\\rightarrow","\\Rightarrow","\\longrightarrow","\\Longrightarrow","\\to","\\implies"];
1111 | rv=cycle(r,m[1])+m[2];
1112 | ``
1113 | endsnippet
1114 | 
1115 | context math(context)
1116 | snippet `(\\leftarrow|\\Leftarrow|\\longleftarrow|\\Longleftarrow|\\impliedby)(| );` "⟸" Ai
1117 | ``
1118 | let r=["\\leftarrow","\\Leftarrow","\\longleftarrow","\\Longleftarrow","\\impliedby"];
1119 | rv=cycle(r,m[1])+m[2];
1120 | ``
1121 | endsnippet
1122 | 
1123 | context math(context)
1124 | snippet `(\\leftrightarrow|\\Leftrightarrow|\\longleftrightarrow|\\Longleftrightarrow|\\iff)(| );` "⟺" iA
1125 | ``
1126 | let r=["\\leftrightarrow","\\Leftrightarrow","\\longleftrightarrow","\\Longleftrightarrow","\\iff"];
1127 | rv=cycle(r,m[1])+m[2];
1128 | ``
1129 | endsnippet
1130 | 
1131 | context math(context)
1132 | snippet `(\\downarrow|\\Downarrow)(| );` "⇓" iA
1133 | ``
1134 | let r=["\\downarrow","\\Downarrow"];
1135 | rv=cycle(r,m[1])+m[2];
1136 | ``
1137 | endsnippet
1138 | 
1139 | context math(context)
1140 | snippet `(\\uparrow|\\Uparrow)(| );` "⇑" iA
1141 | ``
1142 | let r=["\\uparrow","\\Uparrow"];
1143 | rv=cycle(r,m[1])+m[2];
1144 | ``
1145 | endsnippet
1146 | 
1147 | context math(context)
1148 | snippet `(\\updownarrow|\\Updownarrow)(| );` "⇕" iA
1149 | ``
1150 | let r=["\\updownarrow","\\Updownarrow"];
1151 | rv=cycle(r,m[1])+m[2];
1152 | ``
1153 | endsnippet
1154 | 
1155 | #### Var Greek letter (trigger : `;`)
1156 | #
1157 | # phi  ⇨  varphi
1158 | 
1159 | context math(context)
1160 | snippet `(\\|\\var)(epsilon|theta|phi|pi|sigma|kappa)(| );` "greek change" iA
1161 | ``let r=["\\","\\var"];
1162 | rv=cycle(r,m[1])+m[2]+m[3];``
1163 | endsnippet
1164 | 
1165 | #### fraction (trigger : `;`)
1166 | #
1167 | # frac{1}{2} ⇔ dfrac{1}{2}
1168 | 
1169 | context math(context)
1170 | snippet `((\\frac|\\dfrac)\{.*\}\{.*\});` "frac change" iA
1171 | ``
1172 | 
1173 |     var str=m[1].replace(/\\frac/g,"Ⱆ").replace(/\\dfrac/g,"Ⱉ").split('');
1174 | 
1175 |     var depth =0;
1176 |     var i=str.length-1;
1177 |     var test =0;
1178 | 
1179 |     while (i>=0) {
1180 |         depth += ( str[i] == '\}' ) ;
1181 |         depth -= ( str[i] == '\{' ) ;
1182 | 
1183 |         if ( test == 2 && !depth){
1184 |             if ( str[i] == 'Ⱆ'){ str[i] = 'Ⱉ';break;}
1185 |             if ( str[i] == 'Ⱉ'){ str[i] = 'Ⱆ';break;}
1186 |         }
1187 |         test += !!!depth;
1188 |         i--;
1189 |     }
1190 | 
1191 |     rv= (i==-1)?m[1]:str.join('').replace(/Ⱆ/g,"\\\\frac").replace(/Ⱉ/g,"\\\\dfrac");
1192 | ``
1193 | endsnippet
1194 | 
1195 | #### bracket
1196 | #
1197 | # () ⇔ \left(\right)     (trigger : `;`)
1198 | # [] ⇔ \left[\right]     (trigger : `;`)
1199 | # () ⇔ []                (trigger : `:`)
1200 | 
1201 | context math(context)
1202 | snippet `([^\$]*(\)|\])):` "()⇔[]*" iA
1203 | ``
1204 | var str=m[1];
1205 | var bra = ["(","["];
1206 | var ket = [")","]"];
1207 | 
1208 | var testIndex = (m[2]=="]");
1209 | 
1210 | var i=str.length-1;
1211 | str=str.split('');
1212 | 
1213 | str[i] = ket[+!testIndex];
1214 | var depth = 1;
1215 | while (i>=0) {
1216 |         depth += (str[i] == ket[+testIndex] )  ;
1217 |         depth -= (str[i] == bra[+testIndex])  ;
1218 | 
1219 |         if(!depth){
1220 |             str[i]=bra[+!testIndex];
1221 |             break;
1222 |         }
1223 |     i--;
1224 |     }
1225 | rv=str.join('');
1226 | 
1227 | ``
1228 | endsnippet
1229 | 
1230 | 
1231 | context math(context)
1232 | snippet `([^\$]*(\)|\\right\)|\]|\\right\]|\\\}|\\right\\\}));` "()⇔\left(\right)" iA
1233 | ``
1234 |     var str=m[1];
1235 | 
1236 |     switch(m[2]){
1237 |         case ")" || "\\right)":
1238 |             var bracket=["\\left(","\\right)","(",")"];
1239 |             var testBracket = [/\\left\(/g,/\\right\)/g,/\(/g,/\)/g];
1240 |             break;
1241 |         case "]" || "\\right]":
1242 |             var bracket=["\\left[","\\right]","[","]"];
1243 |             var testBracket = [/\\left\[/g,/\\right\]/g,/\[/g,/\]/g];
1244 |             break;
1245 |         case "\\\}" || "\\right\\\}":
1246 |             var bracket=["\\left\\\{","\\right\\\\\}","\\\{","\\\\\}"];
1247 |             var testBracket = [/\\left\\\{/g,/\\right\\\}/g,/\\\{/g,/\\\}/g];
1248 |             break;
1249 |         default:
1250 |             break;
1251 |     }
1252 |     var rep=["ᑡ","ᑑ","ᐹ","ᐴ"];
1253 | 
1254 |     var i=0;
1255 |     while (i<bracket.length) {
1256 |         str=str.replace(testBracket[i],rep[i]);
1257 |         i++;
1258 |     }
1259 | 
1260 |     i=str.length-1;
1261 |     str=str.split('');
1262 |     str[i]=(str[i]=='ᐴ'?'ᑑ':'ᐴ')
1263 |     var depth=0;
1264 |     while (i>=0) {
1265 |           depth += (str[i] == 'ᑑ' || str[i] =='ᐴ' ) ;
1266 |           depth -= (str[i] == 'ᐹ' || str[i] =='ᑡ')  ;
1267 | 
1268 |           if(!depth){
1269 |             var test =str[i]
1270 |             str[i] =( test=='ᐹ' ? 'ᑡ': 'ᐹ')
1271 |                 break;
1272 |           }
1273 |         i--;
1274 |       }
1275 | 
1276 |     str=str.join('');
1277 |     i=rep.length;
1278 |     while (--i>=0) str=str.replace(new RegExp(rep[i],'g'),bracket[i]);
1279 |     rv=str;
1280 | ``
1281 | endsnippet
1282 | 
1283 | # \dot{}   ⇔   \ddot{}
1284 | 
1285 | # <Null>
1286 | 
1287 | 
1288 | 
1289 | 
1290 | 
1291 | 
1292 | #########################################################
1293 | #                for Specific Courses                   #
1294 | #########################################################
1295 | 
1296 | #### Thermodynamics
1297 | #
1298 | # HH   ⇨ \left(\frac{\partial ▮}{\partial ▮}\right)_{▮}
1299 | #                                   ║   (∂▮/∂▮)▄
1300 | # cvv  ⇨ c_V
1301 | # cvm  ⇨ c_{Vm}
1302 | # cpv  ⇨ c_{pm}
1303 | 
1304 | context math(context)
1305 | snippet `HH` "diffraction" iA
1306 | \\left(\\frac{\\partial $1}{\\partial $2}\\right)_{$3}$0
1307 | endsnippet
1308 | 
1309 | priority 100000
1310 | context math(context)
1311 | snippet `cvv` "for c_v" iA
1312 | c_V
1313 | endsnippet
1314 | 
1315 | priority 100000
1316 | context math(context)
1317 | snippet `cvm` "for c_{Vm}" iA
1318 | c_{Vm}
1319 | endsnippet
1320 | 
1321 | priority 100000
1322 | context math(context)
1323 | snippet `cpm` "for c_{Vm}" iA
1324 | c_{pm}
1325 | endsnippet
1326 | 
1327 | #### Quantum Mechanics
1328 | #
1329 | # hbar ⇨ \hbar              ║   ℏ            ║ `priority 200` for ×⇨ \overline{h}
1330 | # avg  ⇨ \left< ▮ \right>  ║   <▮>
1331 | # bra  ⇨ \langle ▮|        ║   <▮|
1332 | # ket  ⇨ |▮\rangle         ║   |▮>
1333 | # |ket ⇨ ▮ \rangle         ║    ▮>
1334 | # frt  ⇨ \frac{1}{sqrt{2\pi}}\int_{-\infty}^{+\infty}
1335 | #                           ║  1/√(2π) ∫_∞^∞
1336 | 
1337 | 
1338 | priority 200
1339 | context math(context)
1340 | snippet `hbar` "hbar" iA
1341 | \\hbar
1342 | endsnippet
1343 | 
1344 | context math(context)
1345 | snippet `avg` "average" iA
1346 | \\left< $1 \\right>$0
1347 | endsnippet
1348 | 
1349 | context math(context)
1350 | snippet `[bB]ra` "Dirac bra" iA
1351 | \\langle $1|$0
1352 | endsnippet
1353 | 
1354 | context math(context)
1355 | snippet `(?<=\|[ ]?)ket` "dirac ket" iA
1356 | $1\\rangle$0
1357 | endsnippet
1358 | 
1359 | context math(context)
1360 | snippet `(?<!\|[ ]?)[kK]et` "Dirac bra" iA
1361 | |$1\\rangle$0
1362 | endsnippet
1363 | 
1364 | context math(context)
1365 | snippet `\\frt` "fourier trans" iA
1366 | \\frac{1}{sqrt{2\\pi}}\\int_{-\\infty}^{+\\infty}
1367 | endsnippet
1368 | 
1369 | 
1370 | #### Mathematical methods for physics
1371 | #
1372 | # bsj ⇨ \mathrm{\,J}_{▮\nu}                 ║ Jᵥ
1373 | # jbs ⇨ \mathrm{\,J}_{▮\nu}                 ║ Jᵥ
1374 | # ldp ⇨ \mathrm{\,P}_{▮l}                   ║ Pₗ
1375 | # grn ⇨ G(\boldsymbol{▮};\boldsymbol{▮})   ║ G(▮;▮)
1376 | 
1377 | context math(context)
1378 | snippet `bs(j|k|i|n|h)` "Bessel" iA
1379 | \\mathrm{\\,``rv=m[1].toUpperCase()``}_{${1:\\nu}}$0
1380 | endsnippet
1381 | 
1382 | context math(context)
1383 | snippet `(j|k|i|n|h)bs` "Bessel" iA
1384 | \\mathrm{\\,``rv=m[1].toUpperCase()``}_{${1:\\nu}}$0
1385 | endsnippet
1386 | 
1387 | context math(context)
1388 | snippet `ldp` "LegendreP" iA
1389 | \\mathrm{\\,P}_{${1:l}}^{$2}$0
1390 | endsnippet
1391 | 
1392 | context math(context)
1393 | snippet `grn` "Green" iA
1394 | G(\\boldsymbol{${1:r}};\\boldsymbol{${2:r'}})
1395 | endsnippet
1396 | 
1397 | 
1398 | 
1399 | #########################################################
1400 | #               other notations & commands              #
1401 | #########################################################
1402 | 
1403 | 
1404 | #   QQ     ⇨ ▢        [qed block (with css, don't use in LaTeX)]
1405 | #   %%     ⇨ ★
1406 | #   ？？？ ⇨ ==???==   ['???' with markdown highlight syntax]
1407 | #   BB     ⇨  \boxed{▮}
1408 | #   @@     ⇨  \left.  \right|_{}
1409 | 
1410 | context !math(context)
1411 | snippet `QQ` "qed" iA
1412 | ``addPackage("amssymb");``\hfill $\square$ $1\par
1413 | endsnippet
1414 | 
1415 | context !math(context)
1416 | snippet %% "big star" A
1417 | $\\color{red}\\bigstar$
1418 | endsnippet
1419 | 
1420 | context math(context)
1421 | snippet `BB` "cdot" iA
1422 | \\boxed{$1}$0
1423 | endsnippet
1424 | 
1425 | context math(context)
1426 | snippet `([^$]*)@@` "at" iA
1427 | ``
1428 | let text = m[1]
1429 | 
1430 | let depth=0;
1431 | let i=text.length;
1432 | 
1433 | while (i>=0) {
1434 |     i--;
1435 |     if (text[i] == '}'|| text[i] == ')' || text[i] ==']' ) depth++;
1436 |     if (text[i] == '{'|| text[i] == '(' || text[i] =='[' ) depth--;
1437 |     if ((text[i] == '+'|| text[i] == '=' || text[i] == '-' || text[i]=='&'|| text[i]==',')&& depth==0 || depth <0) break;
1438 | }
1439 | 
1440 | rv=`${text.slice(0,i+1)}\\\\left.${text.slice(i+1,text.length)}\\\\right|_{${snip.tabstop(1)}}^{${snip.tabstop(2)}}`
1441 | 
1442 | ``
1443 | endsnippet
1444 | 
1445 | #### color
1446 | 
1447 | # \red· --> {\color{red}▮}
1448 | # \red; --> {\color{red}${visual}}
1449 | 
1450 | context math(context)
1451 | snippet `\\(red|green|blue) ` "useful color" iA
1452 | {\\color{``rv=m[1]``}$1}
1453 | endsnippet
1454 | 
1455 | context math(context)
1456 | snippet `\\(red|green|blue);` "useful color" iA
1457 | {\\color{``rv=m[1]``}``rv=visual()``}
1458 | endsnippet
1459 | 
1460 | 
1461 | ########################################################
1462 | #                     lint                             #
1463 | ########################################################
1464 | 
1465 | ####
1466 | #
1467 | # {}  ⇨   ' '
1468 | # +!  ⇨   +1
1469 | # +@  ⇨   +2
1470 | # 、、⇨   \\
1471 | # 》  ⇨   >
1472 | 
1473 | context math(context)
1474 | snippet `(|_|\^)(?<!\\frac)\{\}([^\$]+)` "delete ^{}" iA
1475 | ``rv=m[2].replace(/\\/g,"\\\\")``
1476 | endsnippet
1477 | 
1478 | context math(context)
1479 | snippet `\+!` "+1" iA
1480 | +1
1481 | endsnippet
1482 | 
1483 | context math(context)
1484 | snippet `\+@` "+2" iA
1485 | +2
1486 | endsnippet
1487 | 
1488 | 
1489 | context math(context)
1490 | snippet `、、` "render \\" iA
1491 | \\\\
1492 | endsnippet
1493 | 
1494 | snippet `([ ]*)》 ` "quote" iAM
1495 | ``rv=(document.getText(document.lineAt(editor.selection.active).range).replace(m[0],"")=="")? (m[1]+'> ') :m[0]``
1496 | endsnippet
1497 | 
1498 | ########################################################
1499 | #                     Temp                             #
1500 | ########################################################
1501 | 
1502 | #### autoclose bracket
1503 | #
1504 | # (  ⇨ ()
1505 | # [  ⇨ []
1506 | # {  ⇨ {}
1507 | # \{ ⇨ \{\}
1508 | 
1509 | context autoclosing()
1510 | snippet `(?<!\\left)\(` "bracket" iAM
1511 | ($1)$0
1512 | endsnippet
1513 | 
1514 | context autoclosing()
1515 | snippet `(?<!\\left)\[` "bracket" iA
1516 | [$1]$0
1517 | endsnippet
1518 | 
1519 | priority 100
1520 | context autoclosing()
1521 | snippet `\{` "bracket" iA
1522 | {$1}$0
1523 | endsnippet
1524 | 
1525 | 
1526 | priority 100
1527 | context autoclosing() && math(context)
1528 | snippet `\\\[` "bracket" iA
1529 | \\[$1\\]$0
1530 | endsnippet
1531 | 
1532 | priority 100
1533 | context autoclosing() && math(context)
1534 | snippet `\\\(` "bracket" iA
1535 | \\($1\\)$0
1536 | endsnippet
1537 | 
1538 | priority 10000
1539 | context autoclosing() && math(context)
1540 | snippet `(?<!\\left)\\\{` "bracket" iA
1541 | \\{$1\\}$0
1542 | endsnippet
1543 | 
1544 | 
1545 | ########################################################
1546 | #                    Trash                             #
1547 | ########################################################
1548 | 
1549 | 
1550 | # ## special Greek letters
1551 | #
1552 | # # ksi ⇨ \xi
1553 | # # gma ⇨ \gamma
1554 | # # Gma ⇨ \Gamma
1555 | # # dlt ⇨ \delta
1556 | # # tha ⇨ \theta
1557 | # # Tha ⇨ \Theta
1558 | # # Da  ⇨ \Delta
1559 | # # Dlt ⇨ \Delta
1560 | #
1561 | # context math(context)
1562 | # snippet `ksi` "xi" iA
1563 | # \\xi
1564 | # endsnippet
1565 | #
1566 | # context math(context)
1567 | # snippet `gma` "gamma" iA
1568 | # \\gamma
1569 | # endsnippet
1570 | #
1571 | # context math(context)
1572 | # snippet `Gma` "Gamma" iA
1573 | # \\Gamma
1574 | # endsnippet
1575 | #
1576 | # context math(context)
1577 | # snippet `dlt` "delta" iA
1578 | # \\delta
1579 | # endsnippet
1580 | #
1581 | # context math(context)
1582 | # snippet `tha` "theta" iA
1583 | # \\theta
1584 | # endsnippet
1585 | #
1586 | # context math(context)
1587 | # snippet `Tha` "Theta" iA
1588 | # \\Theta
1589 | # endsnippet
1590 | #
1591 | # context math(context)
1592 | # snippet `DA|Dlt` "Delta" iA
1593 | # \\Delta
1594 | # endsnippet
1595 | #
1596 | # # eps    ⇨ \epsilon
1597 | # # vareps ⇨ \varepsilon
1598 | # # ups    ⇨ \varupsilon
1599 | # # kpa    ⇨ \kappa
1600 | # # lbd    ⇨ \lambda
1601 | # # Lbd    ⇨ \Lambda
1602 | # # nv     ⇨ \nu
1603 | # # mu     ⇨ \mu
1604 | # # omg    ⇨ \omega
1605 | # # Omg    ⇨ \Omega
1606 | #
1607 | #
1608 | # priority 1000
1609 | # context math(context)
1610 | # snippet `[\\]?(var|)eps` "epsilon" iA
1611 | # \\``rv=m[1]``epsilon
1612 | # endsnippet
1613 | #
1614 | # priority 1000
1615 | # context math(context)
1616 | # snippet `[\\]?ups` "upsilon" iA
1617 | # \\upsilon
1618 | # endsnippet
1619 | #
1620 | # context math(context)
1621 | # snippet `kpa` "kappa" iA
1622 | # \\kappa
1623 | # endsnippet
1624 | #
1625 | # context math(context)
1626 | # snippet `lbd` "lambda" iA
1627 | # \\lambda
1628 | # endsnippet
1629 | #
1630 | # context math(context)
1631 | # snippet `Lbd` "Lambda" iA
1632 | # \\Lambda
1633 | # endsnippet
1634 | #
1635 | # context math(context)
1636 | # snippet `nv` "nu" iA
1637 | # \\nu
1638 | # endsnippet
1639 | #
1640 | # context math(context)
1641 | # snippet `mv` "nu" iA
1642 | # \\mu
1643 | # endsnippet
1644 | #
1645 | # context math(context)
1646 | # snippet `omg` "omega" iA
1647 | # \\omega
1648 | # endsnippet
1649 | #
1650 | # context math(context)
1651 | # snippet `Omg` "Omega" iA
1652 | # \\Omega
1653 | # endsnippet


--------------------------------------------------------------------------------
/for 0.2.7+/markdown.hsnips:
--------------------------------------------------------------------------------
   1 | ##########################################
   2 | #                                        #
   3 | #    HyperSnips snippets for markdown    #
   4 | #                                        #
   5 | #       2022/01/06   @yf-zhao            #
   6 | #                                        #
   7 | #        For Hypersnips 0.2.7+           #
   8 | #                                        #
   9 | #                                        #
  10 | ##########################################
  11 | 
  12 | #### Index ####
  13 | 
  14 | # 0  Global Function
  15 | # 1  Special snippets
  16 | # 2  block & environment
  17 | # 3  Math Notation
  18 | # 4  Greek letter
  19 | # 5  Matrices
  20 | # 6  Fraction
  21 | # 7  Superscript & subscript
  22 | # 8  prefix Mode
  23 | # 9  Unit Mode
  24 | # 10 Other Environment
  25 | # 11 Transform similar notations
  26 | # 12 for Special Courses
  27 | # 13 Other notations & commands
  28 | # 14 lint
  29 | # 15 Temp
  30 | # 16 Trash
  31 | 
  32 | 
  33 | 
  34 | #### Global JavaScript Function ####
  35 | 
  36 | global
  37 | 
  38 | // vscode api (necessary)
  39 | 
  40 |         const vscode = require("vscode");
  41 |         let editor=vscode.window.activeTextEditor
  42 |         let document=editor.document
  43 | 
  44 | 
  45 |         // get ActiveTextEditor
  46 | 
  47 |         vscode.window.onDidChangeActiveTextEditor((e) => {
  48 |             editor=vscode.window.activeTextEditor;
  49 |             document=editor.document
  50 |         });
  51 | 
  52 |         // show time in StatusBar
  53 | 
  54 |         setInterval(function(){myTimer()},1000);
  55 |         function myTimer(){
  56 |             vscode.window.setStatusBarMessage(new Date().toLocaleTimeString());
  57 |         }
  58 | 
  59 | // selected text : use ``rv=visual();`` to get selected text
  60 | 
  61 |     let selectedText = "";
  62 | 
  63 |     vscode.window.onDidChangeTextEditorSelection((e) => {
  64 |         const newSelectedText = e.textEditor.document.getText(e.selections[0]);
  65 |         if (newSelectedText) {
  66 |             selectedText = newSelectedText.replace(/\\/g,"\\\\");
  67 |         }
  68 |     });
  69 | 
  70 |     function visual(){
  71 |         const visualText = selectedText;
  72 |         selectedText = "";
  73 |         return visualText;
  74 |     }
  75 | 
  76 | // generate matrix : use ``rv = gen_matrix(snip, "p" , 2 , 3 , 1)`` to get a 2*3 display pmatrix
  77 |              //   snip : snip varible
  78 |              //   flag : string. 'p', 'b' , 'B' , 'v' , 'V' ,'' . default value = ''
  79 |              //   nrow : int.    row of matrix
  80 |              //   ncol : int.    column of matrix
  81 |              //   index: int.    '\n' or '' for last char of line.  1:'\n' ; 0: ''.
  82 | 
  83 |     function gen_matrix(snip,flag, nrow, ncol, index) {
  84 |     	let results = "\\\\begin{"+`${flag?flag:''}`+"matrix}";
  85 |     	let order = 1;
  86 |         let lf = index ? "\n" : "";
  87 |     	for (let i=0; i<nrow; i++){
  88 |             results += (lf + "  ");
  89 |     		for(let j = 0;j <ncol;j++){
  90 |     			results += `${snip.tabstop(order)}` + ((j == ncol -1) ?  " \\\\\\\\" : " & ");
  91 |     			order ++;
  92 |     		}
  93 |     	}
  94 |     	return results += (lf +"\\\\end{"+`${flag?flag:''}`+"matrix}");
  95 |     }
  96 | 
  97 | 
  98 | // transformation cycle
  99 | 
 100 |     function cycle(arr,str){
 101 |         let count = 0 ;
 102 |         while (str!=arr[++count] && count<arr.length);
 103 |         return arr[(count+1)%arr.length];
 104 |     }
 105 | 
 106 | 
 107 | 
 108 | // Context definition
 109 | 
 110 |     // math
 111 | 
 112 |         function math(context) {
 113 |             return context.scopes.some(s => s.includes("math"));
 114 |         }
 115 | 
 116 |     // inline & block math
 117 | 
 118 |         function inline_math(context){
 119 |             return context.scopes.some(s => s.includes("math.inline"));
 120 |         }
 121 | 
 122 |         function block_math(context){
 123 |             return context.scopes.some(s => s.includes("math.block")) || context.scopes.some(s => s.includes("math.display"));
 124 |         }
 125 | 
 126 |     // {aligned} environment
 127 | 
 128 |         function isAlignedEnvironment(editor) {
 129 |             let text = editor.document.getText(new vscode.Range(new vscode.Position(0, 0), editor.selection.start));
 130 |             const reg = /\\begin\{aligned\}[^\$]*?\\end\{aligned\}/g;
 131 |             text = text.replace(reg, '');
 132 |             return (text.indexOf('\\begin{aligned}') == -1)?false:true;
 133 |         }
 134 | 
 135 | 
 136 |     // Unit Environment
 137 | 
 138 |         function isUnitMode(editor) {
 139 |             let pos = editor.selection.active;
 140 |             const reg = /\\mathrm\{\\,[^\$]*?\}/g;
 141 |             let text = editor.document.getText(new vscode.Range(pos.line,0,pos.line,pos.character)).replace(reg, '');
 142 |             return (text.indexOf('\\mathrm{\\,') != -1)
 143 |         }
 144 | 
 145 | // Dic
 146 | 
 147 |     // Greek Letter
 148 | 
 149 |     const greek  = {
 150 |             "a" : "\\alpha",
 151 |             "b" : "\\beta",
 152 |             "c" : "\\chi",
 153 |             "d" : "\\delta",
 154 |             "e" : "\\epsilon",
 155 |             "ve": "\\varepsilon",
 156 |             "f" : "\\phi",
 157 |             "vf" : "\\varphi",
 158 |             "g" : "\\gamma",
 159 |             "h" : "\\eta",
 160 |             "i" : "\\iota",
 161 |             "j" : "\\varphi",
 162 |             "k" : "\\kappa",
 163 |             "vk": "\\varkappa",
 164 |             "l" : "\\lambda",
 165 |             "m" : "\\mu",
 166 |             "n" : "\\nu",
 167 |             "o" : "\\omicron",
 168 |             "p" : "\\pi",
 169 |             "vp" : "\\varpi",
 170 |             "q" : "\\theta",
 171 |             "vq" : "\\vartheta",
 172 |             "r" : "\\rho",
 173 |             "s" : "\\sigma",
 174 |             "vs" : "\\varsigma",
 175 |             "t" : "\\tau",
 176 |             "u" : "\\upsilon",
 177 |             "v" : "\\varpi",
 178 |             "w" : "\\omega",
 179 |             "x" : "\\xi",
 180 |             "y" : "\\psi",
 181 |             "z" : "\\zeta",
 182 |             "A" : "\\Alpha",
 183 |             "B" : "\\Beta",
 184 |             "C" : "\\Chi",
 185 |             "D" : "\\Delta",
 186 |             "E" : "\\Epsilon",
 187 |             "F" : "\\Phi",
 188 |             "G" : "\\Gamma",
 189 |             "H" : "\\Eta",
 190 |             "I" : "\\Iota",
 191 |             "K" : "\\Kappa",
 192 |             "L" : "\\Lambda",
 193 |             "M" : "\\Mu",
 194 |             "N" : "\\Nu",
 195 |             "O" : "\\Omicron",
 196 |             "P" : "\\Pi",
 197 |             "Q" : "\\Theta",
 198 |             "R" : "\\Rho",
 199 |             "S" : "\\Sigma",
 200 |             "T" : "\\Tau",
 201 |             "U" : "\\Upsilon",
 202 |             "W" : "\\Omega",
 203 |             "X" : "\\Xi",
 204 |             "Y" : "\\Psi",
 205 |             "Z" : "\\Zeta"
 206 |         };
 207 | 
 208 |     // prefix
 209 | 
 210 |     const prefix = {
 211 |         "bar" : ["\\\\overline{"             ,"}"   ],
 212 |         "fn"  : ["\\\\overset{\\\\frown}{"   ,"}"   ],
 213 |         "td"  : ["\\\\widetilde{"            ,"}"   ],
 214 |         "rm"  : ["\\\\mathrm{"               ,"}"   ],
 215 |         "hat" : ["\\\\hat{"                  ,"}"   ],
 216 |         "cr"  : ["\\\\mathscr{"              ,"}"   ],
 217 |         "bav" : ["\\\\hat{\\\\boldsymbol{"   ,"}}"  ],
 218 |         "vec" : ["\\\\vec{"                  ,"}"   ],
 219 |         "bm"  : ["\\\\boldsymbol{"           ,"}"   ],
 220 |         "bf"  : ["\\\\mathbf{"               ,"}"   ],
 221 |         "cal" : ["\\\\mathcal{"              ,"}"   ],
 222 |         "dot"  : ["\\\\dot{"                  ,"}"   ],
 223 |         "vdot" : ["\\\\dot{\\\\boldsymbol{"   ,"}}"  ]
 224 |     }
 225 | 
 226 |     //  block
 227 | 
 228 | 
 229 |     const block = {
 230 |         "tm" : ["Thm"        ,"brown"  ,"▶",0],
 231 |         "tt" : ["Thm"        ,"brown"  ,"▶",1],
 232 |         "ex" : ["Ex"         ,"teal"   ,"▶",0],
 233 |         "pf" : ["Pf"         ,"green"  ,"▶",0],
 234 |         "pb" : ["Problem"    ,"teal"   ,"▶",0],
 235 |         "sn" : ["Sol"        ,"green"  ,"▶",0],
 236 |         "df" : ["Def"        ,"purple" ,"▶",0],
 237 |         "dd" : ["Def"        ,"purple" ,"▶",1],
 238 |         "st" : ["Step"       ,"orange" ,"▶",0],
 239 |         "md" : ["Method"     ,"brown"  ,"■",0],
 240 |         "cc" : ["Case"       ,"brown"  ,"●",0],
 241 |         "ds" : ["Discussion" ,"brown"  ,"■",0],
 242 |     }
 243 | 
 244 |     const arrow = {
 245 |         'r' : 'right',
 246 |         'R' : 'Right',
 247 |         'l' : 'left',
 248 |         'L' : 'Left',
 249 |         'lr':'leftright',
 250 |         'Lr':'Leftright',
 251 |         'u' : 'up',
 252 |         'U' : 'Up',
 253 |         'd' : 'down',
 254 |         'D': 'Down',
 255 |         'ud':'updown',
 256 |         'Ud':'Updown',
 257 |         'rr': 'longright',
 258 |         'll': 'longleft',
 259 |         'RR': 'Longright',
 260 |         'LL': 'Longleft',
 261 |         'se': 'se',
 262 |         'sw': 'sw',
 263 |         'ne': 'ne',
 264 |         'nw': 'nw'
 265 |     }
 266 | 
 267 | 
 268 | ///////////////////// trash  ////////////////////
 269 | 
 270 | // autoclosing environment
 271 | 
 272 | function autoclosing(){
 273 |     let pos=editor.selection.active;
 274 |     let text = document.getText(document.lineAt(pos).range).charAt(pos.character+1);
 275 |     let reg=/[;:.,=\}\]\)>\\` \n\t\$*\|\\]/g;
 276 |     return reg.test(text) || text==""
 277 | }
 278 | 
 279 | endglobal
 280 | 
 281 | 
 282 | 
 283 | 
 284 | ##########################################################
 285 | #                       Test                             #
 286 | ##########################################################
 287 | ################### Only for Test !!! ####################
 288 | 
 289 | ##########################################################
 290 | #                   special snippets                     #
 291 | ##########################################################
 292 | 
 293 | # protect "oiint" "iiint" "asccos" "mathtt" "mathbb"
 294 | priority 99999999
 295 | context math(context)
 296 | snippet `(?<=(oii|iii|ascc|mathtt|mathbb|hetan))` "prevent" iA
 297 | 
 298 | endsnippet
 299 | 
 300 | # \displaystyle in `inline-math`
 301 | 
 302 | context inline_math(context)
 303 | snippet `\$([^\$]*)DS` "Displaystyle" iA
 304 | ``rv=`$\\\\displaystyle${m[1]? " "+m[1] : ""}```
 305 | endsnippet
 306 | 
 307 | 
 308 | ##########################################################
 309 | #            block & environment  (Theorem,etc.)         #
 310 | ##########################################################
 311 | 
 312 | # vtm ⇨ (▶Thm.)
 313 | # vdt ⇨ <details>▮</details>
 314 | #
 315 | # use `block` dictionary
 316 | 
 317 | context !math(context)
 318 | snippet `v(tm|tt|ex|pf|pb|sn|df|dd|st|md|ds|cc)` "block & environment" iA
 319 | ``
 320 | let res = block[m[1]];
 321 | rv=`$\{\\\\color{${res[1]}}\\\\mathbf{${res[2]}\\\\ ${res[0]} .${snip.tabstop(1)}}}$ ${res[3]?`(**${snip.tabstop(2)}**) `:""}`;
 322 | ``
 323 | endsnippet
 324 | 
 325 | 
 326 | context !math(context)
 327 | snippet `vdt` "detail" wA
 328 | <details>
 329 | <summary>
 330 | 
 331 | $1
 332 | 
 333 | </summary>
 334 | 
 335 | $2
 336 | 
 337 | </details>
 338 | $0
 339 | endsnippet
 340 | 
 341 | 
 342 | 
 343 | 
 344 | ##########################################################
 345 | #                     Math Notation                      #
 346 | ##########################################################
 347 | 
 348 | #### dots
 349 | #
 350 | # ... ⇨ \cdots
 351 | # ,,, ⇨ \vdots
 352 | # ... ⇨ \ddots
 353 | 
 354 | context math(context)
 355 | snippet `\.\.\.` "cdots" iA
 356 | ``rv='\\cdots '``
 357 | endsnippet
 358 | 
 359 | context math(context)
 360 | snippet `,,,` "vdots" iA
 361 | ``rv='\\vdots '``
 362 | endsnippet
 363 | 
 364 | context math(context)
 365 | snippet `:::` "ddots" iA
 366 | ``rv='\\ddots '``
 367 | endsnippet
 368 | 
 369 | #### integral  & Big Operators
 370 | #
 371 | # int   ⇨ \int   ║ ∫
 372 | # iint  ⇨ \iint  ║ ∫∫
 373 | # iiint ⇨ \iiint ║ ∫∫∫
 374 | # oint  ⇨ \oint  ║ ∮
 375 | # oiint ⇨ \oiint ║ ∯
 376 | 
 377 | priority 10
 378 | context math(context)
 379 | snippet `(?<=[^s])(?<!\\)[iI]nt` "int" iAM
 380 | \\int
 381 | endsnippet
 382 | 
 383 | priority 20
 384 | context math(context)
 385 | snippet `[\\]?iint` "iint" iA
 386 | \\iint
 387 | endsnippet
 388 | 
 389 | priority 100000
 390 | context math(context)
 391 | snippet `[\\]?iiint` "iiint" iA
 392 | \\iiint
 393 | endsnippet
 394 | 
 395 | priority 200000
 396 | context math(context)
 397 | snippet `(?<!\\)oint` "oint" iA
 398 | \\oint
 399 | endsnippet
 400 | 
 401 | priority 200000
 402 | context math(context)
 403 | snippet `[\\]?oiint` "oiint" iA
 404 | \\oiint
 405 | endsnippet
 406 | 
 407 | # lim      ⇨ \lim
 408 | # sum      ⇨ \sum
 409 | # intd     ⇨ int_{▮}^{▮}
 410 | # limd     ⇨ lim_{▮ \to ▮}
 411 | # \inta     ⇨ \int a
 412 | # \lim sup ⇨ \limsup
 413 | 
 414 | context math(context)
 415 | snippet `(?<!\\)(lim|sum)` "lim" iA
 416 | \\``rv=m[1]``
 417 | endsnippet
 418 | 
 419 | context math(context)
 420 | snippet `(lim|limsup|liminf)d` "lim and limsup" iA
 421 | ``rv=m[1]``_{$1 \\to $2}$0
 422 | endsnippet
 423 | 
 424 | context math(context)
 425 | snippet `(int|bigcap|bigcup|sum)d` "sum and int" iA
 426 | ``rv=m[1]``_{$1}^{$2}
 427 | endsnippet
 428 | 
 429 | context math(context)
 430 | snippet `(?<=\\lim)[ ]?(inf|sup)` "limsup&liminf" iA
 431 | ``rv=m[1]``
 432 | endsnippet
 433 | 
 434 | context math(context)
 435 | snippet `(int|\\lim|\\sum)([a-ce-zA-CE-Z])` "space after int" iA
 436 | ``rv=m[1]+" "+m[2]``
 437 | endsnippet
 438 | 
 439 | #### infinity
 440 | #
 441 | # oo      ⇨ \infty
 442 | # \inftyp ⇨ +\infty (oop ⇨ infty)
 443 | # \inftym ⇨ -\infty (oom ⇨ infty)
 444 | 
 445 | context math(context)
 446 | snippet `oo` "infinity" iA
 447 | \\infty
 448 | endsnippet
 449 | 
 450 | context math(context)
 451 | snippet `\\inftyp` "+infty" iA
 452 | +\\infty
 453 | endsnippet
 454 | 
 455 | context math(context)
 456 | snippet `\\inftym` "-infty" iA
 457 | -\\infty
 458 | endsnippet
 459 | 
 460 | #### derivative & partial derivative
 461 | #
 462 | # DD  ⇨ \frac{\mathrm{d}▮}{\mathrm{d}▮}  ║ 𝗱▮/𝗱▮
 463 | # PP  ⇨ \frac{\partial ▮}{\partial ▮}    ║ ∂▮/∂▮
 464 | # drm ⇨ \mathrm{\,d}                      ║  𝗱        ║ `priority 200` for ×⇨ \overline{h}
 465 | # ptl ⇨ \partial                          ║  ∂
 466 | 
 467 | context math(context)
 468 | snippet `DD` "diffraction" iA
 469 | \\frac{\\mathrm{d}$1}{\\mathrm{d}$2}
 470 | endsnippet
 471 | 
 472 | context math(context)
 473 | snippet `PP` "partial diffraction" iA
 474 | \\frac{\\partial $1}{\\partial $2}
 475 | endsnippet
 476 | 
 477 | priority 200
 478 | context math(context)
 479 | snippet `(\w)?drm` "dif" iA
 480 | ``rv=m[1]?(m[1]+" "):""``\\mathrm{\\,d}
 481 | endsnippet
 482 | 
 483 | context math(context)
 484 | snippet `ptl` "partial" iA
 485 | ``rv="\\partial "``
 486 | endsnippet
 487 | 
 488 | #### Arrows
 489 | #### use `arrow` dictionary
 490 | #
 491 | # ra; ⇨ \rightarrow
 492 | # ia; ⇨ \implies
 493 | # fa; ⇨ \iff
 494 | # to; ⇨ \to
 495 | 
 496 | priority 10
 497 | context math(context)
 498 | snippet `(r|R|l|L|lr|Lr|u|U|d|D|ud|Ud|rr|ll|RR|LL|se|sw|ne|nw)a;` "arrows" iA
 499 | ``rv="\\"+arrow[m[1]]+"arrow ";``
 500 | endsnippet
 501 | 
 502 | context math(context)
 503 | snippet `ia;` "implies" iA
 504 | ``rv='\\implies '``
 505 | endsnippet
 506 | 
 507 | context math(context)
 508 | snippet `fa;` "iff" iA
 509 | ``rv='\\iff '``
 510 | endsnippet
 511 | 
 512 | context math(context)
 513 | snippet `ta` "to" iA
 514 | ``rv='\\to '``
 515 | endsnippet
 516 | 
 517 | 
 518 | #### greater & less notations
 519 | #
 520 | # <= ⇨ \leq
 521 | # >= ⇨ \geq
 522 | # << ⇨ \ll
 523 | # >> ⇨ \gg
 524 | # >~ ⇨ \lesssim
 525 | # <~ ⇨ \gtrsim
 526 | 
 527 | context math(context)
 528 | snippet `>=` "≥" iA
 529 | ``rv='\\geq '``
 530 | endsnippet
 531 | 
 532 | context math(context)
 533 | snippet `<=` "≤" iA
 534 | ``rv='\\leq '``
 535 | endsnippet
 536 | 
 537 | context math(context)
 538 | snippet `<<` "≪" iA
 539 | ``rv='\\ll '``
 540 | endsnippet
 541 | 
 542 | context math(context)
 543 | snippet `>>` "≫" iA
 544 | ``rv='\\gg '``
 545 | endsnippet
 546 | 
 547 | context math(context)
 548 | snippet `<~` "≲" iA
 549 | ``rv='\\lesssim '``
 550 | endsnippet
 551 | 
 552 | context math(context)
 553 | snippet `>~` "≳" iA
 554 | ``rv='\\gtrsim '``
 555 | endsnippet
 556 | 
 557 | #### Square
 558 | #
 559 | # sq    ⇨ \sqrt{▮}
 560 | 
 561 | context math(context)
 562 | snippet `(?<!\\)sq` "square" iA
 563 | \\sqrt{$1}
 564 | endsnippet
 565 | 
 566 | #### set notations
 567 | #
 568 | # RR            ⇨ \mathbb{R}     ║  ℝ
 569 | # CC            ⇨ \mathbb{C}     ║  ℂ
 570 | # ZZ            ⇨ \mathbb{Z}     ║  ℤ
 571 | # \mathbb{R}+   ⇨ \mathbb{R}_+   (RR+ ⇨ ℝ⁺)
 572 | # \mathbb{R}n   ⇨ \mathbb{R}^n   (RRn ⇨ ℝⁿ)
 573 | # \mathbb{R}3   ⇨ \mathbb{R}^3   (RR3 ⇨ ℝ³)
 574 | 
 575 | context math(context)
 576 | snippet `RR|CC|ZZ` "sets" iA
 577 | \\mathbb{``rv=m[0].charAt(0)``}
 578 | endsnippet
 579 | 
 580 | priority 2000000
 581 | context math(context)
 582 | snippet `(\\mathbb\{R\})([mnkl\d])` "rset^n" iA
 583 | \\mathbb{R}^{``rv=m[2]``}
 584 | endsnippet
 585 | 
 586 | priority 2000000
 587 | context math(context)
 588 | snippet `(\\mathbb\{R\})\+` "rset_+" iA
 589 | \\mathbb{R}_+
 590 | endsnippet
 591 | 
 592 | 
 593 | #### Standard functions
 594 | #
 595 | # sin   ⇨ \sin
 596 | # \sin h ⇨ \sinh
 597 | # arcsin ⇨ \arcsin
 598 | # div    ⇨ \mathrm{Div.}
 599 | 
 600 | context math(context)
 601 | snippet `(?<!arc)(?<!\\)(sin|cos|tan|csc|sec|cot|ln|log|lg|det|ker|max|min)` "function" iA
 602 | \\``rv=m[1]+' '``
 603 | endsnippet
 604 | 
 605 | context math(context)
 606 | snippet `(?<!\\)arc(sin|cos|tan|csc|sec|cot)` "function" iA
 607 | \\arc``rv=m[1]+' '``
 608 | endsnippet
 609 | 
 610 | priority 20
 611 | context math(context)
 612 | snippet `(?<=\\(sin|cos|tan|csc|sec|cot))( )h` "function" iA
 613 | ``rv='h '``
 614 | endsnippet
 615 | 
 616 | context math(context)
 617 | snippet `curl|div|grad` "vec calculus" iA
 618 | \\mathrm{``rv=m[0].charAt(0).toUpperCase()+m[0].substr(1)``.}
 619 | endsnippet
 620 | 
 621 | 
 622 | #### Binary Operation & Relation Symbols
 623 | #
 624 | # == ⇨ \equiv   ║     ≡
 625 | # OO ⇨ \cdot    ║     ·
 626 | # ~~ ⇨ \sim     ║     ~
 627 | # NN ⇨ \cap     ║     ∩
 628 | # UU ⇨ \cup     ║     ∪
 629 | # II ⇨ \in      ║     ∈
 630 | # XX ⇨ \times   ║     ×
 631 | # opo ⇨ \oplus  ║     ⊕
 632 | # oxo ⇨ \otimes ║     ⊗
 633 | # omo ⇨ \ominus ║     ⊖
 634 | # oco ⇨ \propto ║     ∝
 635 | 
 636 | 
 637 | 
 638 | context math(context) && !isAlignedEnvironment(editor)
 639 | snippet `==` "xlongequal" iA
 640 | \\equiv``rv=' '``
 641 | endsnippet
 642 | 
 643 | context math(context)
 644 | snippet `OO` "cdot" iA
 645 | \\cdot``rv=' '``
 646 | endsnippet
 647 | 
 648 | context math(context)
 649 | snippet `~~` "sim" iA
 650 | \\sim``rv=' '``
 651 | endsnippet
 652 | 
 653 | context math(context)
 654 | snippet `NN` "cap" iA
 655 | \\cap``rv=' '``
 656 | endsnippet
 657 | 
 658 | context math(context)
 659 | snippet `UU` "cup" iA
 660 | \\cup``rv=' '``
 661 | endsnippet
 662 | 
 663 | context math(context)
 664 | snippet `II` "in" iA
 665 | \\in``rv=' '``
 666 | endsnippet
 667 | 
 668 | context math(context)
 669 | snippet `XX` "times" iA
 670 | \\times``rv=' '``
 671 | endsnippet
 672 | 
 673 | context math(context)
 674 | snippet `opo` "oplus" iA
 675 | \\oplus``rv=' '``
 676 | endsnippet
 677 | 
 678 | context math(context)
 679 | snippet `omo` "oplus" iA
 680 | \\ominus``rv=' '``
 681 | endsnippet
 682 | 
 683 | context math(context)
 684 | snippet `oxo` "otimes" iA
 685 | \\otimes``rv=' '``
 686 | endsnippet
 687 | 
 688 | context math(context)
 689 | snippet `oco` "oplus" iA
 690 | \\propto``rv=' '``
 691 | endsnippet
 692 | 
 693 | 
 694 | #### other operators and notations
 695 | #
 696 | # nbl ⇨ \nable          ║   ▽
 697 | # AA  ⇨ \forall         ║   ∀
 698 | # EE  ⇨ \exist          ║   ∃
 699 | # abs ⇨ \left|▮\right|
 700 | # ||  ⇨ \left|▮\right|
 701 | # VV  ⇨ \times 10^{▮}  ║   ×10▘
 702 | # !=  ⇨ \not =          ║   ≠
 703 | 
 704 | context math(context)
 705 | snippet `(\\?)(nbl)` "nabla" iA
 706 | ``rv='\\\\nabla '``
 707 | endsnippet
 708 | 
 709 | context math(context)
 710 | snippet `AA` "forall" iA
 711 | \\forall``rv=' '``
 712 | endsnippet
 713 | 
 714 | context math(context)
 715 | snippet `EE` "exist" iA
 716 | \\exist``rv=' '``
 717 | endsnippet
 718 | 
 719 | context math(context)
 720 | snippet `(\|\||abs)` "abs" iA
 721 | \\left|$1\\right|$0
 722 | endsnippet
 723 | 
 724 | context math(context)
 725 | snippet `(?<=(\$)?)VV` "*10^{}" iA
 726 | ``rv=m[1]?"":"\\\\times "``10^{$1}$0
 727 | endsnippet
 728 | 
 729 | context math(context)
 730 | snippet `\!=` "not =" iA
 731 | \\not =
 732 | endsnippet
 733 | 
 734 | 
 735 | 
 736 | 
 737 | #########################################################
 738 | #                      Greek letter                     #
 739 | #########################################################
 740 | 
 741 | #### Greek letter
 742 | #### use `greek` dictionary
 743 | #
 744 | # alpha ⇨ \alpha ║ α
 745 | # a;    ⇨ \alpha ║ α
 746 | 
 747 | context math(context)
 748 | snippet `[\\]?(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta)` "greek" iA
 749 | \\``rv=m[1]``
 750 | endsnippet
 751 | 
 752 | context math(context)
 753 | snippet `(?<![a-zA-Z])([a-zA-IK-UW-Z]|v[efkpqs]);` "greek" iA
 754 | ``rv=greek[m[1]];``
 755 | endsnippet
 756 | 
 757 | #### special Greek letters
 758 | 
 759 | # ksi ⇨ \xi
 760 | # gma ⇨ \gamma
 761 | # Gma ⇨ \Gamma
 762 | # dlt ⇨ \delta
 763 | # tha ⇨ \theta
 764 | # Tha ⇨ \Theta
 765 | # Da  ⇨ \Delta
 766 | # Dlt ⇨ \Delta
 767 | 
 768 | context math(context)
 769 | snippet `ksi` "xi" iA
 770 | \\xi
 771 | endsnippet
 772 | 
 773 | context math(context)
 774 | snippet `gma` "gamma" iA
 775 | \\gamma
 776 | endsnippet
 777 | 
 778 | context math(context)
 779 | snippet `Gma` "Gamma" iA
 780 | \\Gamma
 781 | endsnippet
 782 | 
 783 | context math(context)
 784 | snippet `dlt` "delta" iA
 785 | \\delta
 786 | endsnippet
 787 | 
 788 | context math(context)
 789 | snippet `tha` "theta" iA
 790 | \\theta
 791 | endsnippet
 792 | 
 793 | context math(context)
 794 | snippet `Tha` "Theta" iA
 795 | \\Theta
 796 | endsnippet
 797 | 
 798 | context math(context)
 799 | snippet `DA|Dlt` "Delta" iA
 800 | \\Delta
 801 | endsnippet
 802 | 
 803 | # eps    ⇨ \epsilon
 804 | # vareps ⇨ \varepsilon
 805 | # ups    ⇨ \varupsilon
 806 | # kpa    ⇨ \kappa
 807 | # lbd    ⇨ \lambda
 808 | # Lbd    ⇨ \Lambda
 809 | # nv     ⇨ \nu
 810 | # mu     ⇨ \mu
 811 | # omg    ⇨ \omega
 812 | # Omg    ⇨ \Omega
 813 | 
 814 | 
 815 | priority 1000
 816 | context math(context)
 817 | snippet `[\\]?(var|)eps` "epsilon" iA
 818 | \\``rv=m[1]``epsilon
 819 | endsnippet
 820 | 
 821 | priority 1000
 822 | context math(context)
 823 | snippet `[\\]?ups` "upsilon" iA
 824 | \\upsilon
 825 | endsnippet
 826 | 
 827 | context math(context)
 828 | snippet `kpa` "kappa" iA
 829 | \\kappa
 830 | endsnippet
 831 | 
 832 | context math(context)
 833 | snippet `lbd` "lambda" iA
 834 | \\lambda
 835 | endsnippet
 836 | 
 837 | context math(context)
 838 | snippet `Lbd` "Lambda" iA
 839 | \\Lambda
 840 | endsnippet
 841 | 
 842 | context math(context)
 843 | snippet `nv` "nu" iA
 844 | \\nu
 845 | endsnippet
 846 | 
 847 | context math(context)
 848 | snippet `mv` "nu" iA
 849 | \\mu
 850 | endsnippet
 851 | 
 852 | context math(context)
 853 | snippet `omg` "omega" iA
 854 | \\omega
 855 | endsnippet
 856 | 
 857 | context math(context)
 858 | snippet `Omg` "Omega" iA
 859 | \\Omega
 860 | endsnippet
 861 | 
 862 | #### var perfix
 863 | #
 864 | # phivar ⇨ \varphi
 865 | 
 866 | context math(context)
 867 | snippet `\\(epsilon|phi|pi|sigma|theta|kappa)[ ]?var` "var greek" iA
 868 | \\var``rv=m[1]``
 869 | endsnippet
 870 | 
 871 | #### space after Greek letter
 872 | #
 873 | # \alphab ⇨ \alpha b
 874 | 
 875 | context math(context)
 876 | snippet `\\(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta)([a-zA-z])` "space after greek letter" iA
 877 | ``rv='\\\\'+m[1]+' '+m[2]``
 878 | endsnippet
 879 | 
 880 | 
 881 | 
 882 | 
 883 | #########################################################
 884 | #                         matrices                      #
 885 | #########################################################
 886 | 
 887 | #### blocked math
 888 | #
 889 | # bmat22 ⇨
 890 | #       \begin{bmatrix}
 891 | #          ▮ & ▮ \\
 892 | #          ▮ & ▮ \\
 893 | #       \end{bmatrix}
 894 | #
 895 | # cv2 ⇨
 896 | #       \begin{bmatrix}
 897 | #          ▮ \\
 898 | #          ▮ \\
 899 | #       \end{bmatrix}
 900 | #
 901 | # rv2 ⇨
 902 | #       \begin{bmatrix}
 903 | #          ▮ & ▮ \\
 904 | #       \end{bmatrix}
 905 | 
 906 | 
 907 | priority 2000
 908 | context block_math(context)
 909 | snippet `([bBpvV])?mat([1-9])([1-9])` "matrix" iA
 910 | ``rv = gen_matrix(snip,m[1],m[2],m[3],1);``
 911 | endsnippet
 912 | 
 913 | priority 2000000
 914 | context block_math(context)
 915 | snippet `([bp])?rv([1-9])` "row vector" iA
 916 | ``rv = gen_matrix(snip,m[1]?m[1]:"b",1,m[2],1);``
 917 | endsnippet
 918 | 
 919 | priority 2000000
 920 | context block_math(context)
 921 | snippet `([bp])?cv([1-9])` "column vector" iA
 922 | ``rv = gen_matrix(snip,m[1]?m[1]:"b",m[2],1,1);``
 923 | endsnippet
 924 | 
 925 | #### inline math
 926 | #
 927 | # bmat22 ⇨
 928 | #       \begin{bmatrix} ▮ & ▮ \\ ▮ & ▮ \\  \end{bmatrix}
 929 | #
 930 | # cv2 ⇨
 931 | #       \begin{bmatrix} ▮ \\ ▮ \\  \end{bmatrix}
 932 | #
 933 | # rv2 ⇨
 934 | #       \begin{bmatrix} ▮ & ▮ \\  \end{bmatrix}
 935 | 
 936 | priority 2000
 937 | context inline_math(context)
 938 | snippet `([bBpvV])?mat([1-9])([1-9])` "matrix" iA
 939 | ``rv = gen_matrix(snip,m[1],m[2],m[3],0);``
 940 | endsnippet
 941 | 
 942 | priority 2000000
 943 | context inline_math(context)
 944 | snippet `([bp])?rv([1-9])` "row vector" iA
 945 | ``rv = gen_matrix(snip,m[1]?m[1]:"b",1,m[2],0);``
 946 | endsnippet
 947 | 
 948 | priority 2000000
 949 | context inline_math(context)
 950 | snippet `([bp])?cv([1-9])` "column vector" iA
 951 | ``rv = gen_matrix(snip,m[1]?m[1]:"b",m[2],1,0);``
 952 | endsnippet
 953 | 
 954 | #########################################################
 955 | #                         fraction                      #
 956 | #########################################################
 957 | 
 958 | context math(context) && !isUnitMode(editor)
 959 | snippet `//` "Fraction" iA
 960 | \\frac{$1}{$2}$0
 961 | endsnippet
 962 | 
 963 | priority 10
 964 | context math(context) && !isUnitMode(editor)
 965 | snippet `((\d+)|(\d*)([A-Za-z]+|[a-zA-Z]?\\(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta))((\^|_)(\{\w+\}|\w)|')*)/` "Fraction " A
 966 | \\frac{``rv = m[1]``}{$1}$0
 967 | endsnippet
 968 | 
 969 | 
 970 | 
 971 | 
 972 | 
 973 | 
 974 | #########################################################
 975 | #                Superscript & Subscript                #
 976 | #########################################################
 977 | 
 978 | #### Superscript
 979 | #
 980 | # pw  ⇨ ^{▮}
 981 | # sr  ⇨ ^2
 982 | # 3;  ⇨ ^3
 983 | # _3; ⇨ ^3
 984 | # dag ⇨ ^\dagger
 985 | # coj ⇨ ^*
 986 | # inv ⇨ ^{-1}
 987 | # trs ⇨ ^T
 988 | # exp ⇨ \mathrm{e}^{▮}    ║      𝗲▘
 989 | 
 990 | context math(context)
 991 | snippet `(?<!\\)pw` "^n" iA
 992 | ^{$1}$0
 993 | endsnippet
 994 | 
 995 | context math(context)
 996 | snippet `(?<!\\)sr` "^2" iA
 997 | ^{2}
 998 | endsnippet
 999 | 
1000 | context math(context)
1001 | snippet `[_ ]?([\d]+);` "^\d" iA
1002 | ^{``rv=m[1]``}
1003 | endsnippet
1004 | 
1005 | context math(context)
1006 | snippet `_([a-z]);` "^m" iA
1007 | ^``rv=m[1]``
1008 | endsnippet
1009 | 
1010 | context math(context)
1011 | snippet `(?<!\\)dag` "dagger" iA
1012 | ^\\dagger``rv=' '``
1013 | endsnippet
1014 | 
1015 | context math(context)
1016 | snippet `coj` "conjugate" iA
1017 | ^*
1018 | endsnippet
1019 | 
1020 | context math(context)
1021 | snippet `inv` "inverse" iA
1022 | ^{-1}
1023 | endsnippet
1024 | 
1025 | context math(context)
1026 | snippet `trs` "trs" iA
1027 | ^T
1028 | endsnippet
1029 | 
1030 | context math(context)
1031 | snippet `(?<!\\)exp` "exp" iA
1032 | \mathrm{e}^{$1}$0
1033 | endsnippet
1034 | 
1035 | 
1036 | #### Subscript
1037 | #
1038 | # sc        ⇨ _{▮}
1039 | # rmm       ⇨ r_m
1040 | # \alpha mm ⇨ \alpha _m
1041 | # a1        ⇨ a_1
1042 | # a_12      ⇨ a_{12}
1043 | # a_1xx     ⇨ a_{1x}    |  ×⇨ a_1_x
1044 | # a_x1      ⇨ a_{x1}
1045 | # a_xyy     ⇨ a_{xy}
1046 | 
1047 | context math(context)
1048 | snippet `(?<!(math|\\))sc` "script main" iA
1049 | _{$1}$0
1050 | endsnippet
1051 | 
1052 | context math(context) && !isUnitMode(editor)
1053 | snippet `(?<!_)([A-Za-z][']*)(?<!mat)(\d|([a-z])\3{1})` "for a_1, a_x, \alpha_1" iA
1054 | ``rv = `${m[1]}_${m[2].charAt(0)}```
1055 | endsnippet
1056 | 
1057 | context math(context)
1058 | snippet `(?<!_)\\(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta)[']*[ ]?([a-z])\2{1}` "for \alpha_x" iA
1059 | ``rv=`\\\\${m[1]}_${m[2]}```
1060 | endsnippet
1061 | 
1062 | priority 100
1063 | context math(context)
1064 | snippet `(?<=_)(([\da-z]|\\(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta))\d)` "for a_{12}, a_{x1}, a_{\alpha1}" iA
1065 | {``rv = m[1]``}
1066 | endsnippet
1067 | 
1068 | context math(context)
1069 | snippet `(?<=_)([\da-z])([a-z])\2` "for a_{1i}, a_{ij}" iA
1070 | {``rv=`${m[1]}${m[2]}` ``}
1071 | endsnippet
1072 | 
1073 | 
1074 | 
1075 | 
1076 | 
1077 | #########################################################
1078 | #                        prefix mode                    #
1079 | #########################################################
1080 | 
1081 | #### use `prefix` dictionary
1082 | 
1083 | context math(context)
1084 | snippet `((?<![_\^])\d+|((?<![_\^])\d*)([A-Za-z]+|\\(alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta)[ ]?))(?<!\\)(bar|fn|td|rm|hat|cr|bav|vec|bm|bf|cal|dot|vdt)` "prefix mode" iA
1085 | ``
1086 | let testPrefix = prefix[m[m.length-1]];
1087 | rv = testPrefix[0] + m[1] + testPrefix[1];
1088 | ``
1089 | endsnippet
1090 | 
1091 | priority 100
1092 | context math(context)
1093 | snippet `((?<![_\^])\d+|(?:(?<![_\^])\d*)(?:[A-Za-z]+|\\(?:alpha|beta|chi|delta|epsilon|varepsilon|phi|varphi|gamma|eta|iota|kappa|varkappa|lambda|mu|nu|omicron|pi|varpi|theta|vartheta|rho|sigma|varsigma|tau|upsilon|omega|xi|psi|zeta|Alpha|Beta|Chi|Delta|Epsilon|Phi|Gamma|Eta|Iota|Kappa|Lambda|Mu|Nu|Omicron|Pi|Theta|Rho|Sigma|Tau|Upsilon|Omega|Xi|Psi|Zeta)[ ]?)[']*)(((\^|_)(\{\w+\}|\w))+)(?<!\\)(bar|fn|td|rm|hat|cr|bav|vec|bm|bf|cal|dot|vdt)` "prefix mode" iA
1094 | ``
1095 | let testPrefix = prefix[m[m.length-1]];
1096 | rv = testPrefix[0] + m[1] + testPrefix[1]+m[2];
1097 | ``
1098 | endsnippet
1099 | 
1100 | 
1101 | 
1102 | #########################################################
1103 | #                        Unit Mode                      #
1104 | #########################################################
1105 | 
1106 | #### trigger 'unitMode'
1107 | #
1108 | # SS ⇨ \mathrm{\
1109 | 
1110 | context math(context)
1111 | snippet `SS` "Unit mode" iA
1112 | \\mathrm{\\,$1}$0
1113 | endsnippet
1114 | 
1115 | #### Only available in 'UnitMode'
1116 | 
1117 | # m3    ⇨ m^3
1118 | # m-    ⇨ m^{-▮}
1119 | # .     ⇨ \cdot
1120 | # cdg  ⇨ \degree C   ║ ℃
1121 | # J/kg. ⇨ J/(kg·▮)
1122 | 
1123 | context isUnitMode(editor)
1124 | snippet `(?<=[A-Za-z])(\d)` "^\d" iA
1125 | ^``rv=m[1]``
1126 | endsnippet
1127 | 
1128 | context isUnitMode(editor)
1129 | snippet `-` "^-" iA
1130 | ^{-$1}$0
1131 | endsnippet
1132 | 
1133 | priority 10
1134 | context isUnitMode(editor)
1135 | snippet . "·" iA
1136 | ``rv='\\\\cdot '``
1137 | endsnippet
1138 | 
1139 | priority 10
1140 | context isUnitMode(editor)
1141 | snippet `cdg` "℃" iA
1142 | \\degree C
1143 | endsnippet
1144 | 
1145 | priority 20
1146 | context isUnitMode(editor)
1147 | snippet `(?<=\\mathrm\{\\,(?!.*\\mathrm\{\\,)[^\$]*\/)([^\(]*?)\.` "\cdot" iA
1148 | (``rv=m[1]``\\cdot $1)$2
1149 | endsnippet
1150 | 
1151 | 
1152 | 
1153 | 
1154 | #########################################################
1155 | #                    Other  Environments                #
1156 | #########################################################
1157 | 
1158 | #### 'aligned' environment
1159 | #
1160 | # aln ⇨  \begin{aligned}
1161 | #              ▮
1162 | #         \end{aligned}
1163 | #
1164 | # baln ⇨ \begin{aligned}
1165 | #             &▮
1166 | #         \end{aligned}
1167 | #
1168 | # =ealn ⇨ \begin{aligned}
1169 | #              a&=▮
1170 | #          \end{aligned}
1171 | #
1172 | # Aln ⇨ \begin{aligned}
1173 | #             {visual}
1174 | #        \end{aligned}
1175 | #
1176 | # ==    ⇨   &=
1177 | 
1178 | priority 200
1179 | context block_math(context)
1180 | snippet `(.*(?<!b|e))([be]?)aln` "Align" iA
1181 | \\begin{aligned}
1182 |     ``rv = ((m[2]=="b") ? "&":"") + ((m[2]=="e") ? m[1].replace("=","&=") : m[1]).replace(/\\/g,"\\\\");
1183 |     ``$0
1184 | \\end{aligned}
1185 | endsnippet
1186 | 
1187 | context isAlignedEnvironment(editor)
1188 | snippet `==` "&=" iA
1189 | &=
1190 | endsnippet
1191 | 
1192 | priority 300
1193 | context block_math(context)
1194 | snippet `Aln` "align" iA
1195 | \\begin{aligned}
1196 |     ``rv = visual();``$0
1197 | \\end{aligned}
1198 | endsnippet
1199 | 
1200 | #### `case` & `rcase` environment
1201 | 
1202 | context math(context)
1203 | snippet `(?<!\{[a-zA-Z]*)(case|rcase)` "case" iA
1204 | \\begin{``rv=m[1]``s}
1205 |     $1
1206 | \\end{``rv=m[1]``s}$0
1207 | endsnippet
1208 | 
1209 | #### `text`
1210 | 
1211 | context math(context)
1212 | snippet `(?<!\\)(txt|tst|text)` "text" iA
1213 | \\text{$1}$0
1214 | endsnippet
1215 | 
1216 | 
1217 | 
1218 | 
1219 | 
1220 | ##########################################################
1221 | #               transform similar notations              #
1222 | ##########################################################
1223 | 
1224 | #### Arrows (trigger: `;`)
1225 | #
1226 | # (→) ⇨ (⇒) ⇨ (⟶) ⇨ (⟹) ⇨ (→)(\to) ⇨ (⟹)(\implies)
1227 | # (←) ⇨ (⇐) ⇨ (⟵) ⇨ (⟸) ⇨ (⟸)(\impliedby)
1228 | # (↔) ⇨ (⇔) ⇨ (⟷) ⇨ (⟺) ⇨ (⟺)(\iff)
1229 | # (↓) ⇨ (⇓)
1230 | # (↑) ⇨ (⇑)
1231 | # (↕) ⇨ (⇕)
1232 | 
1233 | context math(context)
1234 | snippet `(\\rightarrow|\\Rightarrow|\\longrightarrow|\\Longrightarrow|\\to|\\implies)(| );` "⟹" Ai
1235 | ``
1236 | let r=["\\rightarrow","\\Rightarrow","\\longrightarrow","\\Longrightarrow","\\to","\\implies"];
1237 | rv=cycle(r,m[1])+m[2];
1238 | ``
1239 | endsnippet
1240 | 
1241 | context math(context)
1242 | snippet `(\\leftarrow|\\Leftarrow|\\longleftarrow|\\Longleftarrow|\\impliedby)(| );` "⟸" Ai
1243 | ``
1244 | let r=["\\leftarrow","\\Leftarrow","\\longleftarrow","\\Longleftarrow","\\impliedby"];
1245 | rv=cycle(r,m[1])+m[2];
1246 | ``
1247 | endsnippet
1248 | 
1249 | context math(context)
1250 | snippet `(\\leftrightarrow|\\Leftrightarrow|\\longleftrightarrow|\\Longleftrightarrow|\\iff)(| );` "⟺" iA
1251 | ``
1252 | let r=["\\leftrightarrow","\\Leftrightarrow","\\longleftrightarrow","\\Longleftrightarrow","\\iff"];
1253 | rv=cycle(r,m[1])+m[2];
1254 | ``
1255 | endsnippet
1256 | 
1257 | context math(context)
1258 | snippet `(\\downarrow|\\Downarrow)(| );` "⇓" iA
1259 | ``
1260 | let r=["\\downarrow","\\Downarrow"];
1261 | rv=cycle(r,m[1])+m[2];
1262 | ``
1263 | endsnippet
1264 | 
1265 | context math(context)
1266 | snippet `(\\uparrow|\\Uparrow)(| );` "⇑" iA
1267 | ``
1268 | let r=["\\uparrow","\\Uparrow"];
1269 | rv=cycle(r,m[1])+m[2];
1270 | ``
1271 | endsnippet
1272 | 
1273 | context math(context)
1274 | snippet `(\\updownarrow|\\Updownarrow)(| );` "⇕" iA
1275 | ``
1276 | let r=["\\updownarrow","\\Updownarrow"];
1277 | rv=cycle(r,m[1])+m[2];
1278 | ``
1279 | endsnippet
1280 | 
1281 | #### Var Greek letter (trigger : `;`)
1282 | #
1283 | # phi  ⇨  varphi
1284 | 
1285 | context math(context)
1286 | snippet `(\\|\\var)(epsilon|theta|phi|pi|sigma|kappa)(| );` "greek change" iA
1287 | ``let r=["\\","\\var"];
1288 | rv=cycle(r,m[1])+m[2]+m[3];``
1289 | endsnippet
1290 | 
1291 | #### fraction (trigger : `;`)
1292 | #
1293 | # frac{1}{2} ⇔ dfrac{1}{2}
1294 | 
1295 | context math(context)
1296 | snippet `((\\frac|\\dfrac)\{.*\}\{.*\});` "frac change" iA
1297 | ``
1298 | 
1299 |     var str=m[1].replace(/\\frac/g,"Ⱆ").replace(/\\dfrac/g,"Ⱉ").split('');
1300 | 
1301 |     var depth =0;
1302 |     var i=str.length-1;
1303 |     var test =0;
1304 | 
1305 |     while (i>=0) {
1306 |         depth += ( str[i] == '\}' ) ;
1307 |         depth -= ( str[i] == '\{' ) ;
1308 | 
1309 |         if ( test == 2 && !depth){
1310 |             if ( str[i] == 'Ⱆ'){ str[i] = 'Ⱉ';break;}
1311 |             if ( str[i] == 'Ⱉ'){ str[i] = 'Ⱆ';break;}
1312 |         }
1313 |         test += !!!depth;
1314 |         i--;
1315 |     }
1316 | 
1317 |     rv= (i==-1)?m[1]:str.join('').replace(/Ⱆ/g,"\\\\frac").replace(/Ⱉ/g,"\\\\dfrac");
1318 | ``
1319 | endsnippet
1320 | 
1321 | #### bracket
1322 | #
1323 | # () ⇔ \left(\right)     (trigger : `;`)
1324 | # [] ⇔ \left[\right]     (trigger : `;`)
1325 | # () ⇔ []                (trigger : `:`)
1326 | 
1327 | context math(context)
1328 | snippet `([^\$]*(\)|\])):` "()⇔[]*" iA
1329 | ``
1330 | var str=m[1];
1331 | var bra = ["(","["];
1332 | var ket = [")","]"];
1333 | 
1334 | var testIndex = (m[2]=="]");
1335 | 
1336 | var i=str.length-1;
1337 | str=str.split('');
1338 | 
1339 | str[i] = ket[+!testIndex];
1340 | var depth = 1;
1341 | while (i>=0) {
1342 |         depth += (str[i] == ket[+testIndex] )  ;
1343 |         depth -= (str[i] == bra[+testIndex])  ;
1344 | 
1345 |         if(!depth){
1346 |             str[i]=bra[+!testIndex];
1347 |             break;
1348 |         }
1349 |     i--;
1350 |     }
1351 | rv=str.join('');
1352 | 
1353 | ``
1354 | endsnippet
1355 | 
1356 | 
1357 | context math(context)
1358 | snippet `([^\$]*(\)|\\right\)|\]|\\right\]|\\\}|\\right\\\}));` "()⇔\left(\right)" iA
1359 | ``
1360 |     var str=m[1];
1361 | 
1362 |     switch(m[2]){
1363 |         case ")" || "\\right)":
1364 |             var bracket=["\\left(","\\right)","(",")"];
1365 |             var testBracket = [/\\left\(/g,/\\right\)/g,/\(/g,/\)/g];
1366 |             break;
1367 |         case "]" || "\\right]":
1368 |             var bracket=["\\left[","\\right]","[","]"];
1369 |             var testBracket = [/\\left\[/g,/\\right\]/g,/\[/g,/\]/g];
1370 |             break;
1371 |         case "\\\}" || "\\right\\\}":
1372 |             var bracket=["\\left\\\{","\\right\\\\\}","\\\{","\\\\\}"];
1373 |             var testBracket = [/\\left\\\{/g,/\\right\\\}/g,/\\\{/g,/\\\}/g];
1374 |             break;
1375 |         default:
1376 |             break;
1377 |     }
1378 |     var rep=["ᑡ","ᑑ","ᐹ","ᐴ"];
1379 | 
1380 |     var i=0;
1381 |     while (i<bracket.length) {
1382 |         str=str.replace(testBracket[i],rep[i]);
1383 |         i++;
1384 |     }
1385 | 
1386 |     i=str.length-1;
1387 |     str=str.split('');
1388 |     str[i]=(str[i]=='ᐴ'?'ᑑ':'ᐴ')
1389 |     var depth=0;
1390 |     while (i>=0) {
1391 |           depth += (str[i] == 'ᑑ' || str[i] =='ᐴ' ) ;
1392 |           depth -= (str[i] == 'ᐹ' || str[i] =='ᑡ')  ;
1393 | 
1394 |           if(!depth){
1395 |             var test =str[i]
1396 |             str[i] =( test=='ᐹ' ? 'ᑡ': 'ᐹ')
1397 |                 break;
1398 |           }
1399 |         i--;
1400 |       }
1401 | 
1402 |     str=str.join('');
1403 |     i=rep.length;
1404 |     while (--i>=0) str=str.replace(new RegExp(rep[i],'g'),bracket[i]);
1405 |     rv=str;
1406 | ``
1407 | endsnippet
1408 | 
1409 | # \dot{}   ⇔   \ddot{}
1410 | 
1411 | # <Null>
1412 | 
1413 | 
1414 | 
1415 | 
1416 | 
1417 | 
1418 | #########################################################
1419 | #                for Specific Courses                   #
1420 | #########################################################
1421 | 
1422 | #### Thermodynamics
1423 | #
1424 | # HH   ⇨ \left(\frac{\partial ▮}{\partial ▮}\right)_{▮}
1425 | #                                   ║   (∂▮/∂▮)▄
1426 | # cvv  ⇨ c_V
1427 | # cvm  ⇨ c_{Vm}
1428 | # cpv  ⇨ c_{pm}
1429 | 
1430 | context math(context)
1431 | snippet `HH` "diffraction" iA
1432 | \\left(\\frac{\\partial $1}{\\partial $2}\\right)_{$3}$0
1433 | endsnippet
1434 | 
1435 | priority 100000
1436 | context math(context)
1437 | snippet `cvv` "for c_v" iA
1438 | c_V
1439 | endsnippet
1440 | 
1441 | priority 100000
1442 | context math(context)
1443 | snippet `cvm` "for c_{Vm}" iA
1444 | c_{Vm}
1445 | endsnippet
1446 | 
1447 | priority 100000
1448 | context math(context)
1449 | snippet `cpm` "for c_{Vm}" iA
1450 | c_{pm}
1451 | endsnippet
1452 | 
1453 | #### Quantum Mechanics
1454 | #
1455 | # hbar ⇨ \hbar              ║   ℏ            ║ `priority 200` for ×⇨ \overline{h}
1456 | # avg  ⇨ \left< ▮ \right>  ║   <▮>
1457 | # bra  ⇨ \langle ▮|        ║   <▮|
1458 | # ket  ⇨ |▮\rangle         ║   |▮>
1459 | # |ket ⇨ ▮ \rangle         ║    ▮>
1460 | # frt  ⇨ \frac{1}{sqrt{2\pi}}\int_{-\infty}^{+\infty}
1461 | #                           ║  1/√(2π) ∫_∞^∞
1462 | 
1463 | 
1464 | priority 200
1465 | context math(context)
1466 | snippet `hbar` "hbar" iA
1467 | \\hbar
1468 | endsnippet
1469 | 
1470 | context math(context)
1471 | snippet `avg` "average" iA
1472 | \\left< $1 \\right>$0
1473 | endsnippet
1474 | 
1475 | context math(context)
1476 | snippet `[bB]ra` "Dirac bra" iA
1477 | \\langle $1|$0
1478 | endsnippet
1479 | 
1480 | context math(context)
1481 | snippet `(?<=\|[ ]?)ket` "dirac ket" iA
1482 | $1\\rangle$0
1483 | endsnippet
1484 | 
1485 | context math(context)
1486 | snippet `(?<!\|[ ]?)[kK]et` "Dirac bra" iA
1487 | |$1\\rangle$0
1488 | endsnippet
1489 | 
1490 | context math(context)
1491 | snippet `\\frt` "fourier trans" iA
1492 | \\frac{1}{sqrt{2\\pi}}\\int_{-\\infty}^{+\\infty}
1493 | endsnippet
1494 | 
1495 | 
1496 | #### Mathematical methods for physics
1497 | #
1498 | # bsj ⇨ \mathrm{\,J}_{▮\nu}                 ║ Jᵥ
1499 | # jbs ⇨ \mathrm{\,J}_{▮\nu}                 ║ Jᵥ
1500 | # ldp ⇨ \mathrm{\,P}_{▮l}                   ║ Pₗ
1501 | # grn ⇨ G(\boldsymbol{▮};\boldsymbol{▮})   ║ G(▮;▮)
1502 | 
1503 | context math(context)
1504 | snippet `bs(j|k|i|n|h)` "Bessel" iA
1505 | \\mathrm{\\,``rv=m[1].toUpperCase()``}_{${1:\\nu}}$0
1506 | endsnippet
1507 | 
1508 | context math(context)
1509 | snippet `(j|k|i|n|h)bs` "Bessel" iA
1510 | \\mathrm{\\,``rv=m[1].toUpperCase()``}_{${1:\\nu}}$0
1511 | endsnippet
1512 | 
1513 | context math(context)
1514 | snippet `ldp` "LegendreP" iA
1515 | \\mathrm{\\,P}_{${1:l}}^{$2}$0
1516 | endsnippet
1517 | 
1518 | context math(context)
1519 | snippet `grn` "Green" iA
1520 | G(\\boldsymbol{${1:r}};\\boldsymbol{${2:r'}})
1521 | endsnippet
1522 | 
1523 | 
1524 | 
1525 | #########################################################
1526 | #               other notations & commands              #
1527 | #########################################################
1528 | 
1529 | 
1530 | #   QQ     ⇨ ▢        [qed block (with css, don't use in LaTeX)]
1531 | #   %%     ⇨ ★
1532 | #   ？？？ ⇨ ==???==   ['???' with markdown highlight syntax]
1533 | #   BB     ⇨  \boxed{▮}
1534 | #   @@     ⇨  \left.  \right|_{}
1535 | 
1536 | context !math(context)
1537 | snippet `QQ` "qed" iA
1538 | <span class="qed"></span>
1539 | endsnippet
1540 | 
1541 | context !math(context)
1542 | snippet %% "big star" A
1543 | $\\color{red}\\bigstar$
1544 | endsnippet
1545 | 
1546 | context !math(context)
1547 | snippet `(\?\?\?|？？？)` "can't understand" A
1548 | ==???==
1549 | endsnippet
1550 | 
1551 | context math(context)
1552 | snippet `BB` "cdot" iA
1553 | \\boxed{$1}$0
1554 | endsnippet
1555 | 
1556 | context math(context)
1557 | snippet `([^$]*)@@` "at" iA
1558 | ``
1559 | let text = m[1]
1560 | 
1561 | let depth=0;
1562 | let i=text.length;
1563 | 
1564 | while (i>=0) {
1565 |     i--;
1566 |     if (text[i] == '}'|| text[i] == ')' || text[i] ==']' ) depth++;
1567 |     if (text[i] == '{'|| text[i] == '(' || text[i] =='[' ) depth--;
1568 |     if ((text[i] == '+'|| text[i] == '=' || text[i] == '-' || text[i]=='&'|| text[i]==',')&& depth==0 || depth <0) break;
1569 | }
1570 | 
1571 | rv=`${text.slice(0,i+1)}\\\\left.${text.slice(i+1,text.length)}\\\\right|_{${snip.tabstop(1)}}^{${snip.tabstop(2)}}`
1572 | 
1573 | ``
1574 | endsnippet
1575 | 
1576 | #### color
1577 | 
1578 | # \red· --> {\color{red}▮}
1579 | # \red; --> {\color{red}${visual}}
1580 | 
1581 | context math(context)
1582 | snippet `\\(red|green|blue) ` "useful color" iA
1583 | {\\color{``rv=m[1]``}$1}
1584 | endsnippet
1585 | 
1586 | context math(context)
1587 | snippet `\\(red|green|blue);` "useful color" iA
1588 | {\\color{``rv=m[1]``}``rv=visual()``}
1589 | endsnippet
1590 | 
1591 | 
1592 | ########################################################
1593 | #                     lint                             #
1594 | ########################################################
1595 | 
1596 | ####
1597 | #
1598 | # {}  ⇨   ' '
1599 | # +!  ⇨   +1
1600 | # +@  ⇨   +2
1601 | # 、、⇨   \\
1602 | # 》  ⇨   >
1603 | 
1604 | context math(context)
1605 | snippet `(|_|\^)(?<!\\frac)\{\}([^\$]+)` "delete ^{}" iA
1606 | ``rv=m[2].replace(/\\/g,"\\\\")``
1607 | endsnippet
1608 | 
1609 | context math(context)
1610 | snippet `\+!` "+1" iA
1611 | +1
1612 | endsnippet
1613 | 
1614 | context math(context)
1615 | snippet `\+@` "+2" iA
1616 | +2
1617 | endsnippet
1618 | 
1619 | 
1620 | context math(context)
1621 | snippet `、、` "render \\" iA
1622 | \\\\
1623 | endsnippet
1624 | 
1625 | snippet `([ ]*)》 ` "quote" iAM
1626 | ``rv=(document.getText(document.lineAt(editor.selection.active).range).replace(m[0],"")=="")? (m[1]+'> ') :m[0]``
1627 | endsnippet
1628 | 
1629 | ########################################################
1630 | #                     Temp                             #
1631 | ########################################################
1632 | 
1633 | #### autoclose bracket
1634 | #
1635 | # (  ⇨ ()
1636 | # [  ⇨ []
1637 | # {  ⇨ {}
1638 | # \{ ⇨ \{\}
1639 | 
1640 | context autoclosing()
1641 | snippet `(?<!\\left)\(` "bracket" iAM
1642 | ($1)$0
1643 | endsnippet
1644 | 
1645 | context autoclosing()
1646 | snippet `(?<!\\left)\[` "bracket" iA
1647 | [$1]$0
1648 | endsnippet
1649 | 
1650 | priority 100
1651 | context autoclosing()
1652 | snippet `\{` "bracket" iA
1653 | {$1}$0
1654 | endsnippet
1655 | 
1656 | priority 10000
1657 | context autoclosing() && math(context)
1658 | snippet `(?<!\\left)\\\{` "bracket" iA
1659 | \\{$1\\}$0
1660 | endsnippet
1661 | 
1662 | 
1663 | 
1664 | ########################################################
1665 | #                    Trash                             #
1666 | ########################################################
1667 | 


--------------------------------------------------------------------------------