aboutsummaryrefslogtreecommitdiffstats
path: root/public/prism/prism-jsstacktrace.min.js
blob: 19bf6a73401a8a5a954740c9a3651685bf34f8f9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Prism.languages.jsstacktrace = {
  'error-message': { pattern: /^\S.*/m, alias: 'string' },
  'stack-frame': {
    pattern: /(^[ \t]+)at[ \t].*/m,
    lookbehind: !0,
    inside: {
      'not-my-code': {
        pattern:
          /^at[ \t]+(?!\s)(?:node\.js|<unknown>|.*(?:node_modules|\(<anonymous>\)|\(<unknown>|<anonymous>$|\(internal\/|\(node\.js)).*/m,
        alias: 'comment',
      },
      filename: {
        pattern: /(\bat\s+(?!\s)|\()(?:[a-zA-Z]:)?[^():]+(?=:)/,
        lookbehind: !0,
        alias: 'url',
      },
      function: {
        pattern:
          /(\bat\s+(?:new\s+)?)(?!\s)[_$a-zA-Z\xA0-\uFFFF<][.$\w\xA0-\uFFFF<>]*/,
        lookbehind: !0,
        inside: { punctuation: /\./ },
      },
      punctuation: /[()]/,
      keyword: /\b(?:at|new)\b/,
      alias: {
        pattern: /\[(?:as\s+)?(?!\s)[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\]/,
        alias: 'variable',
      },
      'line-number': {
        pattern: /:\d+(?::\d+)?\b/,
        alias: 'number',
        inside: { punctuation: /:/ },
      },
    },
  },
};
>(function (Prism) { /** * Functions to construct regular expressions * e.g. (interactive ... or (interactive) * * @param {string} name * @returns {RegExp} */ function simple_form(name) { return RegExp(/(\()/.source + '(?:' + name + ')' + /(?=[\s\)])/.source); } /** * booleans and numbers * * @param {string} pattern * @returns {RegExp} */ function primitive(pattern) { return RegExp( /([\s([])/.source + '(?:' + pattern + ')' + /(?=[\s)])/.source ); } // Patterns in regular expressions // Symbol name. See https://www.gnu.org/software/emacs/manual/html_node/elisp/Symbol-Type.html // & and : are excluded as they are usually used for special purposes var symbol = /(?!\d)[-+*/~!@$%^=<>{}\w]+/.source; // symbol starting with & used in function arguments var marker = '&' + symbol; // Open parenthesis for look-behind var par = '(\\()'; var endpar = '(?=\\))'; // End the pattern with look-ahead space var space = '(?=\\s)'; var nestedPar = /(?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))*\))*\))*/ .source; var language = { // Three or four semicolons are considered a heading. // See https://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html heading: { pattern: /;;;.*/, alias: ['comment', 'title'], }, comment: /;.*/, string: { pattern: /"(?:[^"\\]|\\.)*"/, greedy: true, inside: { argument: /[-A-Z]+(?=[.,\s])/, symbol: RegExp('`' + symbol + "'"), }, }, 'quoted-symbol': { pattern: RegExp("#?'" + symbol), alias: ['variable', 'symbol'], }, 'lisp-property': { pattern: RegExp(':' + symbol), alias: 'property', }, splice: { pattern: RegExp(',@?' + symbol), alias: ['symbol', 'variable'], }, keyword: [ { pattern: RegExp( par + '(?:and|(?:cl-)?letf|cl-loop|cond|cons|error|if|(?:lexical-)?let\\*?|message|not|null|or|provide|require|setq|unless|use-package|when|while)' + space ), lookbehind: true, }, { pattern: RegExp( par + '(?:append|by|collect|concat|do|finally|for|in|return)' + space ), lookbehind: true, }, ], declare: { pattern: simple_form(/declare/.source), lookbehind: true, alias: 'keyword', }, interactive: { pattern: simple_form(/interactive/.source), lookbehind: true, alias: 'keyword', }, boolean: { pattern: primitive(/nil|t/.source), lookbehind: true, }, number: { pattern: primitive(/[-+]?\d+(?:\.\d*)?/.source), lookbehind: true, }, defvar: { pattern: RegExp(par + 'def(?:const|custom|group|var)\\s+' + symbol), lookbehind: true, inside: { keyword: /^def[a-z]+/, variable: RegExp(symbol), }, }, defun: { pattern: RegExp( par + /(?:cl-)?(?:defmacro|defun\*?)\s+/.source + symbol + /\s+\(/.source + nestedPar + /\)/.source ), lookbehind: true, greedy: true, inside: { keyword: /^(?:cl-)?def\S+/, // See below, this property needs to be defined later so that it can // reference the language object. arguments: null, function: { pattern: RegExp('(^\\s)' + symbol), lookbehind: true, }, punctuation: /[()]/, }, }, lambda: { pattern: RegExp( par + 'lambda\\s+\\(\\s*(?:&?' + symbol + '(?:\\s+&?' + symbol + ')*\\s*)?\\)' ), lookbehind: true, greedy: true, inside: { keyword: /^lambda/, // See below, this property needs to be defined later so that it can // reference the language object. arguments: null, punctuation: /[()]/, }, }, car: { pattern: RegExp(par + symbol), lookbehind: true, }, punctuation: [ // open paren, brackets, and close paren /(?:['`,]?\(|[)\[\]])/, // cons { pattern: /(\s)\.(?=\s)/, lookbehind: true, }, ], }; var arg = { 'lisp-marker': RegExp(marker), varform: { pattern: RegExp( /\(/.source + symbol + /\s+(?=\S)/.source + nestedPar + /\)/.source ), inside: language, }, argument: { pattern: RegExp(/(^|[\s(])/.source + symbol), lookbehind: true, alias: 'variable', }, rest: language, }; var forms = '\\S+(?:\\s+\\S+)*'; var arglist = { pattern: RegExp(par + nestedPar + endpar), lookbehind: true, inside: { 'rest-vars': { pattern: RegExp('&(?:body|rest)\\s+' + forms), inside: arg, }, 'other-marker-vars': { pattern: RegExp('&(?:aux|optional)\\s+' + forms), inside: arg, }, keys: { pattern: RegExp('&key\\s+' + forms + '(?:\\s+&allow-other-keys)?'), inside: arg, }, argument: { pattern: RegExp(symbol), alias: 'variable', }, punctuation: /[()]/, }, }; language['lambda'].inside.arguments = arglist; language['defun'].inside.arguments = Prism.util.clone(arglist); language['defun'].inside.arguments.inside.sublist = arglist; Prism.languages.lisp = language; Prism.languages.elisp = language; Prism.languages.emacs = language; Prism.languages['emacs-lisp'] = language; })(Prism);