static/highlight/es/languages/latex.js

   1 /*! `latex` grammar compiled for Highlight.js 11.11.1 */
   2 var hljsGrammar = (function () {
   3   'use strict';
   4
   5   /*
   6   Language: LaTeX
   7   Author: Benedikt Wilde <bwilde@posteo.de>
   8   Website: https://www.latex-project.org
   9   Category: markup
  10   */
  11
  12   /** @type LanguageFn */
  13   function latex(hljs) {
  14     const regex = hljs.regex;
  15     const KNOWN_CONTROL_WORDS = regex.either(...[
  16       '(?:NeedsTeXFormat|RequirePackage|GetIdInfo)',
  17       'Provides(?:Expl)?(?:Package|Class|File)',
  18       '(?:DeclareOption|ProcessOptions)',
  19       '(?:documentclass|usepackage|input|include)',
  20       'makeat(?:letter|other)',
  21       'ExplSyntax(?:On|Off)',
  22       '(?:new|renew|provide)?command',
  23       '(?:re)newenvironment',
  24       '(?:New|Renew|Provide|Declare)(?:Expandable)?DocumentCommand',
  25       '(?:New|Renew|Provide|Declare)DocumentEnvironment',
  26       '(?:(?:e|g|x)?def|let)',
  27       '(?:begin|end)',
  28       '(?:part|chapter|(?:sub){0,2}section|(?:sub)?paragraph)',
  29       'caption',
  30       '(?:label|(?:eq|page|name)?ref|(?:paren|foot|super)?cite)',
  31       '(?:alpha|beta|[Gg]amma|[Dd]elta|(?:var)?epsilon|zeta|eta|[Tt]heta|vartheta)',
  32       '(?:iota|(?:var)?kappa|[Ll]ambda|mu|nu|[Xx]i|[Pp]i|varpi|(?:var)rho)',
  33       '(?:[Ss]igma|varsigma|tau|[Uu]psilon|[Pp]hi|varphi|chi|[Pp]si|[Oo]mega)',
  34       '(?:frac|sum|prod|lim|infty|times|sqrt|leq|geq|left|right|middle|[bB]igg?)',
  35       '(?:[lr]angle|q?quad|[lcvdi]?dots|d?dot|hat|tilde|bar)'
  36     ].map(word => word + '(?![a-zA-Z@:_])'));
  37     const L3_REGEX = new RegExp([
  38       // A function \module_function_name:signature or \__module_function_name:signature,
  39       // where both module and function_name need at least two characters and
  40       // function_name may contain single underscores.
  41       '(?:__)?[a-zA-Z]{2,}_[a-zA-Z](?:_?[a-zA-Z])+:[a-zA-Z]*',
  42       // A variable \scope_module_and_name_type or \scope__module_ane_name_type,
  43       // where scope is one of l, g or c, type needs at least two characters
  44       // and module_and_name may contain single underscores.
  45       '[lgc]__?[a-zA-Z](?:_?[a-zA-Z])*_[a-zA-Z]{2,}',
  46       // A quark \q_the_name or \q__the_name or
  47       // scan mark \s_the_name or \s__vthe_name,
  48       // where variable_name needs at least two characters and
  49       // may contain single underscores.
  50       '[qs]__?[a-zA-Z](?:_?[a-zA-Z])+',
  51       // Other LaTeX3 macro names that are not covered by the three rules above.
  52       'use(?:_i)?:[a-zA-Z]*',
  53       '(?:else|fi|or):',
  54       '(?:if|cs|exp):w',
  55       '(?:hbox|vbox):n',
  56       '::[a-zA-Z]_unbraced',
  57       '::[a-zA-Z:]'
  58     ].map(pattern => pattern + '(?![a-zA-Z:_])').join('|'));
  59     const L2_VARIANTS = [
  60       { begin: /[a-zA-Z@]+/ }, // control word
  61       { begin: /[^a-zA-Z@]?/ } // control symbol
  62     ];
  63     const DOUBLE_CARET_VARIANTS = [
  64       { begin: /\^{6}[0-9a-f]{6}/ },
  65       { begin: /\^{5}[0-9a-f]{5}/ },
  66       { begin: /\^{4}[0-9a-f]{4}/ },
  67       { begin: /\^{3}[0-9a-f]{3}/ },
  68       { begin: /\^{2}[0-9a-f]{2}/ },
  69       { begin: /\^{2}[\u0000-\u007f]/ }
  70     ];
  71     const CONTROL_SEQUENCE = {
  72       className: 'keyword',
  73       begin: /\\/,
  74       relevance: 0,
  75       contains: [
  76         {
  77           endsParent: true,
  78           begin: KNOWN_CONTROL_WORDS
  79         },
  80         {
  81           endsParent: true,
  82           begin: L3_REGEX
  83         },
  84         {
  85           endsParent: true,
  86           variants: DOUBLE_CARET_VARIANTS
  87         },
  88         {
  89           endsParent: true,
  90           relevance: 0,
  91           variants: L2_VARIANTS
  92         }
  93       ]
  94     };
  95     const MACRO_PARAM = {
  96       className: 'params',
  97       relevance: 0,
  98       begin: /#+\d?/
  99     };
 100     const DOUBLE_CARET_CHAR = {
 101       // relevance: 1
 102       variants: DOUBLE_CARET_VARIANTS };
 103     const SPECIAL_CATCODE = {
 104       className: 'built_in',
 105       relevance: 0,
 106       begin: /[$&^_]/
 107     };
 108     const MAGIC_COMMENT = {
 109       className: 'meta',
 110       begin: /% ?!(T[eE]X|tex|BIB|bib)/,
 111       end: '$',
 112       relevance: 10
 113     };
 114     const COMMENT = hljs.COMMENT(
 115       '%',
 116       '$',
 117       { relevance: 0 }
 118     );
 119     const EVERYTHING_BUT_VERBATIM = [
 120       CONTROL_SEQUENCE,
 121       MACRO_PARAM,
 122       DOUBLE_CARET_CHAR,
 123       SPECIAL_CATCODE,
 124       MAGIC_COMMENT,
 125       COMMENT
 126     ];
 127     const BRACE_GROUP_NO_VERBATIM = {
 128       begin: /\{/,
 129       end: /\}/,
 130       relevance: 0,
 131       contains: [
 132         'self',
 133         ...EVERYTHING_BUT_VERBATIM
 134       ]
 135     };
 136     const ARGUMENT_BRACES = hljs.inherit(
 137       BRACE_GROUP_NO_VERBATIM,
 138       {
 139         relevance: 0,
 140         endsParent: true,
 141         contains: [
 142           BRACE_GROUP_NO_VERBATIM,
 143           ...EVERYTHING_BUT_VERBATIM
 144         ]
 145       }
 146     );
 147     const ARGUMENT_BRACKETS = {
 148       begin: /\[/,
 149       end: /\]/,
 150       endsParent: true,
 151       relevance: 0,
 152       contains: [
 153         BRACE_GROUP_NO_VERBATIM,
 154         ...EVERYTHING_BUT_VERBATIM
 155       ]
 156     };
 157     const SPACE_GOBBLER = {
 158       begin: /\s+/,
 159       relevance: 0
 160     };
 161     const ARGUMENT_M = [ ARGUMENT_BRACES ];
 162     const ARGUMENT_O = [ ARGUMENT_BRACKETS ];
 163     const ARGUMENT_AND_THEN = function(arg, starts_mode) {
 164       return {
 165         contains: [ SPACE_GOBBLER ],
 166         starts: {
 167           relevance: 0,
 168           contains: arg,
 169           starts: starts_mode
 170         }
 171       };
 172     };
 173     const CSNAME = function(csname, starts_mode) {
 174       return {
 175         begin: '\\\\' + csname + '(?![a-zA-Z@:_])',
 176         keywords: {
 177           $pattern: /\\[a-zA-Z]+/,
 178           keyword: '\\' + csname
 179         },
 180         relevance: 0,
 181         contains: [ SPACE_GOBBLER ],
 182         starts: starts_mode
 183       };
 184     };
 185     const BEGIN_ENV = function(envname, starts_mode) {
 186       return hljs.inherit(
 187         {
 188           begin: '\\\\begin(?=[ \t]*(\\r?\\n[ \t]*)?\\{' + envname + '\\})',
 189           keywords: {
 190             $pattern: /\\[a-zA-Z]+/,
 191             keyword: '\\begin'
 192           },
 193           relevance: 0,
 194         },
 195         ARGUMENT_AND_THEN(ARGUMENT_M, starts_mode)
 196       );
 197     };
 198     const VERBATIM_DELIMITED_EQUAL = (innerName = "string") => {
 199       return hljs.END_SAME_AS_BEGIN({
 200         className: innerName,
 201         begin: /(.|\r?\n)/,
 202         end: /(.|\r?\n)/,
 203         excludeBegin: true,
 204         excludeEnd: true,
 205         endsParent: true
 206       });
 207     };
 208     const VERBATIM_DELIMITED_ENV = function(envname) {
 209       return {
 210         className: 'string',
 211         end: '(?=\\\\end\\{' + envname + '\\})'
 212       };
 213     };
 214
 215     const VERBATIM_DELIMITED_BRACES = (innerName = "string") => {
 216       return {
 217         relevance: 0,
 218         begin: /\{/,
 219         starts: {
 220           endsParent: true,
 221           contains: [
 222             {
 223               className: innerName,
 224               end: /(?=\})/,
 225               endsParent: true,
 226               contains: [
 227                 {
 228                   begin: /\{/,
 229                   end: /\}/,
 230                   relevance: 0,
 231                   contains: [ "self" ]
 232                 }
 233               ],
 234             }
 235           ]
 236         }
 237       };
 238     };
 239     const VERBATIM = [
 240       ...[
 241         'verb',
 242         'lstinline'
 243       ].map(csname => CSNAME(csname, { contains: [ VERBATIM_DELIMITED_EQUAL() ] })),
 244       CSNAME('mint', ARGUMENT_AND_THEN(ARGUMENT_M, { contains: [ VERBATIM_DELIMITED_EQUAL() ] })),
 245       CSNAME('mintinline', ARGUMENT_AND_THEN(ARGUMENT_M, { contains: [
 246         VERBATIM_DELIMITED_BRACES(),
 247         VERBATIM_DELIMITED_EQUAL()
 248       ] })),
 249       CSNAME('url', { contains: [
 250         VERBATIM_DELIMITED_BRACES("link"),
 251         VERBATIM_DELIMITED_BRACES("link")
 252       ] }),
 253       CSNAME('hyperref', { contains: [ VERBATIM_DELIMITED_BRACES("link") ] }),
 254       CSNAME('href', ARGUMENT_AND_THEN(ARGUMENT_O, { contains: [ VERBATIM_DELIMITED_BRACES("link") ] })),
 255       ...[].concat(...[
 256         '',
 257         '\\*'
 258       ].map(suffix => [
 259         BEGIN_ENV('verbatim' + suffix, VERBATIM_DELIMITED_ENV('verbatim' + suffix)),
 260         BEGIN_ENV('filecontents' + suffix, ARGUMENT_AND_THEN(ARGUMENT_M, VERBATIM_DELIMITED_ENV('filecontents' + suffix))),
 261         ...[
 262           '',
 263           'B',
 264           'L'
 265         ].map(prefix =>
 266           BEGIN_ENV(prefix + 'Verbatim' + suffix, ARGUMENT_AND_THEN(ARGUMENT_O, VERBATIM_DELIMITED_ENV(prefix + 'Verbatim' + suffix)))
 267         )
 268       ])),
 269       BEGIN_ENV('minted', ARGUMENT_AND_THEN(ARGUMENT_O, ARGUMENT_AND_THEN(ARGUMENT_M, VERBATIM_DELIMITED_ENV('minted')))),
 270     ];
 271
 272     return {
 273       name: 'LaTeX',
 274       aliases: [ 'tex' ],
 275       contains: [
 276         ...VERBATIM,
 277         ...EVERYTHING_BUT_VERBATIM
 278       ]
 279     };
 280   }
 281
 282   return latex;
 283
 284 })();
 285 ;
 286 export default hljsGrammar;