Package r

Variables

R/S lexer.

var R = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "R",
        Aliases:   []string{"splus", "s", "r"},
        Filenames: []string{"*.S", "*.R", "*.r", ".Rhistory", ".Rprofile", ".Renviron"},
        MimeTypes: []string{"text/S-plus", "text/S", "text/x-r-source", "text/x-r", "text/x-R", "text/x-r-history", "text/x-r-profile"},
    },
    rRules,
))

Racket lexer.

var Racket = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Racket",
        Aliases:   []string{"racket", "rkt"},
        Filenames: []string{"*.rkt", "*.rktd", "*.rktl"},
        MimeTypes: []string{"text/x-racket", "application/x-racket"},
    },
    racketRules,
))

Ragel lexer.

var Ragel = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Ragel",
        Aliases:   []string{"ragel"},
        Filenames: []string{},
        MimeTypes: []string{},
    },
    ragelRules,
))

Raku lexer.

var Raku Lexer = internal.Register(MustNewLazyLexer(
    &Config{
        Name:    "Raku",
        Aliases: []string{"perl6", "pl6", "raku"},
        Filenames: []string{
            "*.pl", "*.pm", "*.nqp", "*.p6", "*.6pl", "*.p6l", "*.pl6", "*.6pm",
            "*.p6m", "*.pm6", "*.t", "*.raku", "*.rakumod", "*.rakutest", "*.rakudoc",
        },
        MimeTypes: []string{
            "text/x-perl6", "application/x-perl6",
            "text/x-raku", "application/x-raku",
        },
        DotAll: true,
    },
    rakuRules,
))

Reasonml lexer.

var Reasonml = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "ReasonML",
        Aliases:   []string{"reason", "reasonml"},
        Filenames: []string{"*.re", "*.rei"},
        MimeTypes: []string{"text/x-reasonml"},
    },
    reasonmlRules,
))

Reg lexer.

var Reg = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "reg",
        Aliases:   []string{"registry"},
        Filenames: []string{"*.reg"},
        MimeTypes: []string{"text/x-windows-registry"},
    },
    regRules,
))

Restructuredtext lexer.

var Restructuredtext = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "reStructuredText",
        Aliases:   []string{"rst", "rest", "restructuredtext"},
        Filenames: []string{"*.rst", "*.rest"},
        MimeTypes: []string{"text/x-rst", "text/prs.fallenstein.rst"},
    },
    restructuredtextRules,
))

Rexx lexer.

var Rexx = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "Rexx",
        Aliases:         []string{"rexx", "arexx"},
        Filenames:       []string{"*.rexx", "*.rex", "*.rx", "*.arexx"},
        MimeTypes:       []string{"text/x-rexx"},
        NotMultiline:    true,
        CaseInsensitive: true,
    },
    rexxRules,
))

Ruby lexer.

var Ruby = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Ruby",
        Aliases:   []string{"rb", "ruby", "duby"},
        Filenames: []string{"*.rb", "*.rbw", "Rakefile", "*.rake", "*.gemspec", "*.rbx", "*.duby", "Gemfile"},
        MimeTypes: []string{"text/x-ruby", "application/x-ruby"},
        DotAll:    true,
    },
    rubyRules,
))

Rust lexer.

var Rust = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Rust",
        Aliases:   []string{"rust", "rs"},
        Filenames: []string{"*.rs", "*.rs.in"},
        MimeTypes: []string{"text/rust", "text/x-rust"},
        EnsureNL:  true,
    },
    rustRules,
))