
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

(function (Prism) {
  var schemeExpression =
    /\((?:[^();"#\\]|\\[\s\S]|;.*(?!.)|"(?:[^"\\]|\\.)*"|#(?:\{(?:(?!#\})[\s\S])*#\}|[^{])|<expr>)*\)/
      .source;
  // allow for up to pow(2, recursivenessLog2) many levels of recursive brace expressions
  // For some reason, this can't be 4
  var recursivenessLog2 = 5;
  for (var i = 0; i < recursivenessLog2; i++) {
    schemeExpression = schemeExpression.replace(/<expr>/g, function () {
      return schemeExpression;
    });
  }
  schemeExpression = schemeExpression.replace(/<expr>/g, /[^\s\S]/.source);

  var lilypond = (Prism.languages.lilypond = {
    comment: /%(?:(?!\{).*|\{[\s\S]*?%\})/,
    'embedded-scheme': {
      pattern: RegExp(
        /(^|[=\s])#(?:"(?:[^"\\]|\\.)*"|[^\s()"]*(?:[^\s()]|<expr>))/.source.replace(
          /<expr>/g,
          function () {
            return schemeExpression;
          }
        ),
        'm'
      ),
      lookbehind: true,
      greedy: true,
      inside: {
        scheme: {
          pattern: /^(#)[\s\S]+$/,
          lookbehind: true,
          alias: 'language-scheme',
          inside: {
            'embedded-lilypond': {
              pattern: /#\{[\s\S]*?#\}/,
              greedy: true,
              inside: {
                punctuation: /^#\{|#\}$/,
                lilypond: {
                  pattern: /[\s\S]+/,
                  alias: 'language-lilypond',
                  inside: null, // see below
                },
              },
            },
            rest: Prism.languages.scheme,
          },
        },
        punctuation: /#/,
      },
    },
    string: {
      pattern: /"(?:[^"\\]|\\.)*"/,
      greedy: true,
    },
    'class-name': {
      pattern: /(\\new\s+)[\w-]+/,
      lookbehind: true,
    },
    keyword: {
      pattern: /\\[a-z][-\w]*/i,
      inside: {
        punctuation: /^\\/,
      },
    },
    operator: /[=|]|<<|>>/,
    punctuation: {
      pattern:
        /(^|[a-z\d])(?:'+|,+|[_^]?-[_^]?(?:[-+^!>._]|(?=\d))|[_^]\.?|[.!])|[{}()[\]<>^~]|\\[()[\]<>\\!]|--|__/,
      lookbehind: true,
    },
    number: /\b\d+(?:\/\d+)?\b/,
  });

  lilypond['embedded-scheme'].inside['scheme'].inside[
    'embedded-lilypond'
  ].inside['lilypond'].inside = lilypond;

  Prism.languages.ly = lilypond;
})(Prism);