// This is a TextMate grammar distributed by `starry-night`.
// This grammar is developed at
// <https://github.com/savonet/vscode-liquidsoap>
// and licensed `mit`.
// See <https://github.com/wooorm/starry-night> for more info.
/**
 * @import {Grammar} from '@wooorm/starry-night'
 */

/** @type {Grammar} */
const grammar = {
  extensions: ['.liq'],
  names: ['liquidsoap'],
  patterns: [
    {include: '#comments'},
    {include: '#bindings'},
    {include: '#expressions'}
  ],
  repository: {
    bindings: {
      patterns: [
        {
          captures: {
            1: {name: 'keyword.liquidsoap'},
            2: {name: 'entity.name.function.binding.liquidsoap'}
          },
          match: "\\b(for)[[:space:]]+(__*|_*[[:alpha:]][[[:alpha:]]0-9_']*)"
        },
        {
          captures: {
            1: {name: 'keyword.other.function.declaration.liquidsoap'},
            2: {name: 'storage.modifier.liquidsoap'},
            3: {name: 'entity.name.function.binding.liquidsoap'}
          },
          match:
            "\\b(let)[[:space:]]+(eval[[:space:]]+|replaces[[:space:]]+|json\\.parse(?:\\[[^\\]]*\\])?[[:space:]]+|yaml\\.parse(?:\\[[^\\]]*\\])?[[:space:]]+)?(?<!eval|replaces|json\\.parse|yaml\\.parse)(__*|_*[[:alpha:]][[[:alpha:]]0-9_'.]*)[[:space:]]*(?!,|::|[[:space:]])"
        },
        {
          begin: '\\b(let)[[:space:]]+\\[',
          beginCaptures: {
            1: {name: 'keyword.other.function.declaration.pattern.liquidsoap'}
          },
          end: '\\]',
          patterns: [{include: '#pattern-assignments'}]
        },
        {
          begin: '\\b(let)[[:space:]]+\\{',
          beginCaptures: {
            1: {name: 'keyword.other.function.declaration.pattern.liquidsoap'}
          },
          end: '\\}',
          patterns: [{include: '#pattern-assignments'}]
        },
        {
          begin: '\\b(let)[[:space:]]+\\(',
          beginCaptures: {
            1: {name: 'keyword.other.function.declaration.pattern.liquidsoap'}
          },
          end: '\\)',
          patterns: [{include: '#pattern-assignments'}]
        },
        {
          begin:
            "\\b(def)[[:space:]]+(rec[[:space:]]+|replaces[[:space:]]+)?(?<!rec|replaces)(__*|_*[[:alpha:]][[[:alpha:]]0-9_'.]*)",
          beginCaptures: {
            1: {name: 'keyword.other.function.definition.liquidsoap'},
            2: {name: 'storage.modifier.liquidsoap'},
            3: {name: 'entity.name.function.binding.liquidsoap'}
          },
          end: '(?<=end)\\b',
          endCaptures: {1: {name: 'keyword.other.function.end.liquidsoap'}},
          patterns: [{include: '#def-params'}, {include: '#function-body'}]
        },
        {
          captures: {1: {name: 'entity.name.function.binding.liquidsoap'}},
          match: "\\b(__*|_*[[:alpha:]][[[:alpha:]]0-9_']*)[[:space:]]*=(?!=)"
        }
      ]
    },
    comments: {
      patterns: [
        {
          begin: '#<',
          end: '>#',
          name: 'comment.block.liquidsoap',
          patterns: [{include: '#comments-doc'}]
        },
        {
          begin: '#',
          end: '\\n',
          name: 'comment.line.number-sign.liquidsoap',
          patterns: [{include: '#comments-doc'}]
        }
      ]
    },
    'comments-doc': {
      patterns: [
        {match: '@param', name: 'comment.doc.param.liquidsoap'},
        {match: '@category', name: 'comment.doc.category.liquidsoap'},
        {match: '@argsof', name: 'comment.doc.argsof.liquidsoap'}
      ]
    },
    constants: {
      patterns: [
        {
          match: '\\b(true|false)\\b',
          name: 'constant.language.boolean.liquidsoap'
        },
        {
          match: '\\b([0-9][0-9_]*?)\\.[0-9][0-9_]*(?!\\})\\b',
          name: 'constant.numeric.decimal.float.liquidsoap'
        },
        {
          match: '\\b0(x|X)[0-9][0-9a-fA-F_]+\\b',
          name: 'constant.numeric.hexadecimal.integer.liquidsoap'
        },
        {
          match: '\\b0(o|O)[0-9][0-9_]+\\b',
          name: 'constant.numeric.octal.integer.liquidsoap'
        },
        {
          match: '\\b([0-9]+w?)[0-9]+h[0-9]+\\b',
          name: 'constant.time.predicate.liquidsoap'
        },
        {
          match: '\\b[0-9]+w([0-9]+h?)([0-9]+m?)([0-9]+s?)\\b',
          name: 'constant.time.predicate.liquidsoap'
        },
        {
          match: '\\b([0-9]+w?)[0-9]+h([0-9]+m?)([0-9]+s?)\\b',
          name: 'constant.time.predicate.liquidsoap'
        },
        {
          match: '\\b([0-9]+w?)([0-9]+h?)[0-9]+m([0-9]+s?)\\b',
          name: 'constant.time.predicate.liquidsoap'
        },
        {
          match: '\\b([0-9]+w?)([0-9]+h?)([0-9]+m?)[0-9]+s\\b',
          name: 'constant.time.predicate.liquidsoap'
        },
        {
          match: '\\b[0-9][0-9_]*\\b',
          name: 'constant.numeric.decimal.integer.liquidsoap'
        }
      ]
    },
    'def-param': {
      patterns: [
        {
          captures: {1: {name: 'variable.parameter.liquidsoap'}},
          match: "~(__*|_*[[:alpha:]][[[:alpha:]]0-9_']*)"
        },
        {
          match: ',',
          name: 'keyword.other.liquidsoap punctuation.comma punctuation.separator.comma'
        },
        {include: '#expressions'}
      ]
    },
    'def-params': {
      patterns: [
        {
          begin: '[[:space:]]*\\(',
          end: '\\)',
          patterns: [{include: '#def-param'}]
        }
      ]
    },
    expressions: {
      patterns: [
        {
          begin: '(\\?)(?![\\?\\.])',
          beginCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          end: '(:)',
          endCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          patterns: [{include: '#expressions'}]
        },
        {
          begin: '\\b(if)\\b',
          beginCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          end: '\\b(end)\\b',
          endCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          patterns: [
            {
              match: '\\b(then|else|elsif)\\b',
              name: 'keyword.control.liquidsoap'
            },
            {include: '$self'}
          ]
        },
        {
          begin: '\\b(for)\\b',
          beginCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          end: '\\b(end)\\b',
          endCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          patterns: [
            {match: '\\b(to|do)\\b', name: 'keyword.control.liquidsoap'},
            {include: '$self'}
          ]
        },
        {
          begin: '\\b(while)\\b',
          beginCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          end: '\\b(end)\\b',
          endCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          patterns: [
            {match: '\\b(do)\\b', name: 'keyword.control.liquidsoap'},
            {include: '$self'}
          ]
        },
        {
          begin: '\\b(try)\\b',
          beginCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          end: '\\b(end)\\b',
          endCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          patterns: [
            {
              captures: {
                1: {name: 'keyword.control.liquidsoap'},
                2: {name: 'entity.name.function.binding.liquidsoap'},
                3: {name: 'keyword.control.liquidsoap'}
              },
              match:
                "\\b(catch)[[:space:]]+(__*|[[:alpha:]][[[:alpha:]]0-9_']*)[[:space:]]+(do)\\b"
            },
            {
              begin:
                "\\b(catch)[[:space:]]+(__*|[[:alpha:]][[[:alpha:]]0-9_']*)[[:space:]]+(:)",
              beginCaptures: {
                1: {name: 'keyword.control.liquidsoap'},
                2: {name: 'entity.name.function.binding.liquidsoap'},
                3: {name: 'keyword.control.liquidsoap'}
              },
              end: '(do)',
              endCaptures: {1: {name: 'keyword.other.liquidsoap'}},
              patterns: [{include: '#expressions'}]
            },
            {include: '$self'}
          ]
        },
        {
          begin: '\\b(begin)\\b',
          beginCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          end: '\\b(end)\\b',
          endCaptures: {1: {name: 'keyword.control.liquidsoap'}},
          patterns: [{include: '$self'}]
        },
        {
          begin: '\\.?\\{',
          end: '\\}',
          patterns: [{include: '#records'}, {include: '#expressions'}]
        },
        {
          begin: '\\b(fun)[[:space:]]*\\(',
          captures: {
            1: {name: 'keyword.other.function.definition.anonymous.liquidsoap'}
          },
          end: '\\)',
          patterns: [{include: '#def-param'}]
        },
        {
          begin:
            "\\??\\.?%?(__*|[[:alpha:]][[[:alpha:]]0-9_']*)[[:space:]]*\\(",
          beginCaptures: {1: {name: 'entity.name.function.liquidsoap'}},
          end: '\\)',
          name: 'meta.function-call.liquidsoap',
          patterns: [{include: '#function-call-arguments'}]
        },
        {
          captures: {
            1: {name: 'keyword.other.liquidsoap'},
            2: {name: 'variable.method.liquidsoap'}
          },
          match: "(\\??\\.)(__*|_*[[:alpha:]][[[:alpha:]]0-9_']*)"
        },
        {
          begin: '(:)(?![=:])',
          beginCaptures: {1: {name: 'keyword.other.cast.liquidsoap'}},
          end: '\\)',
          name: 'meta.type-annotation.liquidsoap',
          patterns: [{include: '#types'}]
        },
        {include: '#keywords'},
        {include: '#constants'},
        {include: '#identifiers'},
        {include: '#strings'}
      ]
    },
    'function-body': {
      patterns: [
        {
          begin: '[[:space:]]*(?:=|\\n)',
          end: '\\b(end)\\b',
          endCaptures: {1: {name: 'keyword.other.function.end.liquidsoap'}},
          patterns: [{include: '$self'}]
        }
      ]
    },
    'function-call-arguments': {
      patterns: [
        {
          captures: {1: {name: 'variable.language.arguments.named.liquidsoap'}},
          match: "(__*|_*[[:alpha:]][[[:alpha:]]0-9_']*)="
        },
        {
          match: ',',
          name: 'keyword.other.liquidsoap punctuation.comma punctuation.separator.comma'
        },
        {include: '#expressions'}
      ]
    },
    identifiers: {
      patterns: [
        {
          match: "%[[:alpha:]][[[:alpha:]]0-9_']*",
          name: 'variable.encoder.liquidsoap'
        },
        {
          match: "\\b(?!r/)(__*|_*[[:alpha:]][[[:alpha:]]0-9_']*)",
          name: 'variable.liquidsoap'
        }
      ]
    },
    keywords: {
      patterns: [
        {
          match:
            '(%ifdef|%ifndef|%ifversion|%ifnversion|%ifencoder|%ifnencoder|%else|%endif)\\b',
          name: 'keyword.other.liquidsoap'
        },
        {match: '->', name: 'keyword.control.function.declaration.liquidsoap'},
        {
          match: '\\b(and|or|not)\\b',
          name: 'keyword.operator.boolean.liquidsoap'
        },
        {match: '\\.\\.\\.', name: 'keyword.operator.spread.liquidsoap'},
        {match: '::', name: 'keyword.operator.append.liquidsoap'},
        {match: '[+\\-/*]\\.?', name: 'keyword.operator.arithmetic.liquidsoap'},
        {
          match: '(>=|<=|>|<|==|!=)',
          name: 'keyword.operator.compare.liquidsoap'
        },
        {match: ':=', name: 'keyword.operator.set.liquidsoap'},
        {match: '\\?\\?', name: 'keyword.operator.coalesce.liquidsoap'},
        {
          match: ',',
          name: 'keyword.other.liquidsoap punctuation.comma punctuation.separator.comma'
        }
      ]
    },
    'pattern-assignments': {
      patterns: [
        {
          match: "\\b(?!r/)(__*|_*[[:alpha:]][[[:alpha:]]0-9_']*)",
          name: 'entity.name.function.binding.liquidsoap'
        },
        {
          begin: '\\[',
          end: '\\]',
          patterns: [{include: '#pattern-assignments'}]
        },
        {
          begin: '\\(',
          end: '\\)',
          patterns: [{include: '#pattern-assignments'}]
        },
        {
          begin: '\\{',
          end: '\\}',
          patterns: [{include: '#pattern-assignments'}]
        },
        {
          match: ',',
          name: 'keyword.other.liquidsoap punctuation.comma punctuation.separator.comma'
        },
        {match: '\\.\\.\\.', name: 'keyword.operator.spread.liquidsoap'}
      ]
    },
    records: {
      patterns: [
        {
          captures: {1: {name: 'entity.name.method.liquidsoap'}},
          match: "\\b(__*|_*[[:alpha:]][[[:alpha:]]0-9_']*)[[:space:]]*=(?!=)"
        },
        {
          match: ',',
          name: 'keyword.other.liquidsoap punctuation.comma punctuation.separator.comma'
        },
        {include: '#expressions'}
      ]
    },
    'source-type-arguments': {
      patterns: [
        {
          captures: {
            1: {name: 'storage.type.source.track.liquidsoap'},
            2: {name: 'keyword.other.liquidsoap'},
            3: {name: 'storage.type.source.format.liquidsoap'},
            4: {name: 'storage.type.source.format.params.liquidsoap'}
          },
          match:
            '\\b([[[:alpha:]]]+)(\\??)[[:space:]]*=[[:space:]]*([[[:alpha:]].]+)(\\([[[:alpha:]]0-9.]+\\))?'
        },
        {
          captures: {
            1: {name: 'storage.type.source.track.liquidsoap'},
            2: {name: 'keyword.other.liquidsoap'}
          },
          match: '\\b([[[:alpha:]]]+)(\\??)\\b'
        },
        {
          match: ',',
          name: 'keyword.other.liquidsoap punctuation.comma punctuation.separator.comma'
        }
      ]
    },
    'string-escapes': {
      patterns: [
        {match: '\\\\.', name: 'constant.character.escape.liquidsoap'},
        {
          begin: '#\\{',
          end: '\\}',
          name: 'string.interpolation.liquidsoap',
          patterns: [
            {match: '\\\\}', name: 'string.interpolation.escape.liquidsoap'},
            {include: '#expressions'}
          ]
        }
      ]
    },
    strings: {
      patterns: [
        {
          begin: '"',
          end: '"',
          name: 'string.quoted.double.liquidsoap',
          patterns: [{include: '#string-escapes'}]
        },
        {
          begin: "'",
          end: "'",
          name: 'string.quoted.single.liquidsoap',
          patterns: [{include: '#string-escapes'}]
        },
        {
          begin: 'r/',
          end: '/[gismu]*',
          name: 'string.regexp.liquidsoap',
          patterns: [
            {match: '\\\\/', name: 'constant.character.escape.liquidsoap'}
          ]
        },
        {
          begin: '\\{([a-z_]*)\\|',
          end: '\\|\\1\\}',
          name: 'string.unquoted.raw.liquidsoap'
        }
      ]
    },
    types: {
      patterns: [
        {
          captures: {
            1: {name: 'storage.type.ground.liquidsoap'},
            2: {name: 'keyword.other.liquidsoap'}
          },
          match: '\\b(int|float|unit|bool)(?:(\\?)|\\b)'
        },
        {
          begin: '\\b(source)\\(',
          beginCaptures: {1: {name: 'storage.type.source.liquidsoap'}},
          end: '\\)(\\??)',
          endCaptures: {1: {name: 'keyword.other.liquidsoap'}},
          patterns: [{include: '#source-type-arguments'}]
        },
        {
          captures: {
            1: {name: 'storage.type.source.liquidsoap'},
            2: {name: 'keyword.other.liquidsoap'}
          },
          match: 'source(\\??)'
        },
        {
          begin: '\\(',
          end: '\\)(\\??)',
          endCaptures: {1: {name: 'keyword.other.liquidsoap'}},
          patterns: [
            {include: '#types'},
            {
              match: ',',
              name: 'keyword.other.liquidsoap punctuation.comma punctuation.separator.comma'
            }
          ]
        },
        {
          begin: '\\[',
          end: '\\](\\??)',
          endCaptures: {1: {name: 'keyword.other.liquidsoap'}},
          patterns: [
            {include: '#types'},
            {
              match: ',',
              name: 'keyword.other.liquidsoap punctuation.comma punctuation.separator.comma'
            }
          ]
        },
        {
          begin: '\\{',
          end: '\\}(\\??)',
          endCaptures: {1: {name: 'keyword.other.liquidsoap'}},
          patterns: [
            {
              captures: {1: {name: 'entity.name.method.liquidsoap'}},
              match:
                "\\b(__*|_*[[:alpha:]][[[:alpha:]]0-9_']*)[[:space:]]*:(?!:)"
            },
            {include: '#types'},
            {
              match: ',',
              name: 'keyword.other.liquidsoap punctuation.comma punctuation.separator.comma'
            }
          ]
        }
      ]
    }
  },
  scopeName: 'source.liquidsoap'
}

export default grammar