source: node_modules/prismjs/components/prism-elixir.js

Prism.languages.elixir = {
        'doc': {
                pattern: /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
                inside: {
                        'attribute': /^@\w+/,
                        'string': /['"][\s\S]+/
                }
        },
        'comment': {
                pattern: /#.*/,
                greedy: true
        },
        // ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>
        'regex': {
                pattern: /~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
                greedy: true
        },
        'string': [
                {
                        // ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
                        pattern: /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
                        greedy: true,
                        inside: {
                                // See interpolation below
                        }
                },
                {
                        pattern: /("""|''')[\s\S]*?\1/,
                        greedy: true,
                        inside: {
                                // See interpolation below
                        }
                },
                {
                        // Multi-line strings are allowed
                        pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
                        greedy: true,
                        inside: {
                                // See interpolation below
                        }
                }
        ],
        'atom': {
                // Look-behind prevents bad highlighting of the :: operator
                pattern: /(^|[^:]):\w+/,
                lookbehind: true,
                alias: 'symbol'
        },
        'module': {
                pattern: /\b[A-Z]\w*\b/,
                alias: 'class-name'
        },
        // Look-ahead prevents bad highlighting of the :: operator
        'attr-name': /\b\w+\??:(?!:)/,
        'argument': {
                // Look-behind prevents bad highlighting of the && operator
                pattern: /(^|[^&])&\d+/,
                lookbehind: true,
                alias: 'variable'
        },
        'attribute': {
                pattern: /@\w+/,
                alias: 'variable'
        },
        'function': /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,
        'number': /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
        'keyword': /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,
        'boolean': /\b(?:false|nil|true)\b/,
        'operator': [
                /\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
                {
                        // We don't want to match <<
                        pattern: /([^<])<(?!<)/,
                        lookbehind: true
                },
                {
                        // We don't want to match >>
                        pattern: /([^>])>(?!>)/,
                        lookbehind: true
                }
        ],
        'punctuation': /<<|>>|[.,%\[\]{}()]/
};

Prism.languages.elixir.string.forEach(function (o) {
        o.inside = {
                'interpolation': {
                        pattern: /#\{[^}]+\}/,
                        inside: {
                                'delimiter': {
                                        pattern: /^#\{|\}$/,
                                        alias: 'punctuation'
                                },
                                rest: Prism.languages.elixir
                        }
                }
        };
});