Package d

Variables

D lexer. https://dlang.org/spec/lex.html

var D = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "D",
        Aliases:   []string{"d"},
        Filenames: []string{"*.d", "*.di"},
        MimeTypes: []string{"text/x-d"},
        EnsureNL:  true,
    },
    dRules,
))

Dart lexer.

var Dart = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Dart",
        Aliases:   []string{"dart"},
        Filenames: []string{"*.dart"},
        MimeTypes: []string{"text/x-dart"},
        DotAll:    true,
    },
    dartRules,
))

Diff lexer.

var Diff = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Diff",
        Aliases:   []string{"diff", "udiff"},
        EnsureNL:  true,
        Filenames: []string{"*.diff", "*.patch"},
        MimeTypes: []string{"text/x-diff", "text/x-patch"},
    },
    diffRules,
))

Django/Jinja lexer.

var DjangoJinja = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Django/Jinja",
        Aliases:   []string{"django", "jinja"},
        Filenames: []string{},
        MimeTypes: []string{"application/x-django-templating", "application/x-jinja"},
        DotAll:    true,
    },
    djangoJinjaRules,
))

Docker lexer.

var Docker = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "Docker",
        Aliases:         []string{"docker", "dockerfile"},
        Filenames:       []string{"Dockerfile", "*.docker"},
        MimeTypes:       []string{"text/x-dockerfile-config"},
        CaseInsensitive: true,
    },
    dockerRules,
))

Dtd lexer.

var Dtd = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "DTD",
        Aliases:   []string{"dtd"},
        Filenames: []string{"*.dtd"},
        MimeTypes: []string{"application/xml-dtd"},
        DotAll:    true,
    },
    dtdRules,
))

Dylan lexer.

var Dylan = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "Dylan",
        Aliases:         []string{"dylan"},
        Filenames:       []string{"*.dylan", "*.dyl", "*.intr"},
        MimeTypes:       []string{"text/x-dylan"},
        CaseInsensitive: true,
    },
    func() Rules {
        return Rules{
            "root": {
                {`\s+`, Whitespace, nil},
                {`//.*?\n`, CommentSingle, nil},
                {`([a-z0-9-]+:)([ \t]*)(.*(?:\n[ \t].+)*)`, ByGroups(NameAttribute, Whitespace, LiteralString), nil},
                Default(Push("code")),
            },
            "code": {
                {`\s+`, Whitespace, nil},
                {`//.*?\n`, CommentSingle, nil},
                {`/\*`, CommentMultiline, Push("comment")},
                {`"`, LiteralString, Push("string")},
                {`'(\\.|\\[0-7]{1,3}|\\x[a-f0-9]{1,2}|[^\\\'\n])'`, LiteralStringChar, nil},
                {`#b[01]+`, LiteralNumberBin, nil},
                {`#o[0-7]+`, LiteralNumberOct, nil},
                {`[-+]?(\d*\.\d+([ed][-+]?\d+)?|\d+(\.\d*)?e[-+]?\d+)`, LiteralNumberFloat, nil},
                {`[-+]?\d+`, LiteralNumberInteger, nil},
                {`#x[0-9a-f]+`, LiteralNumberHex, nil},

                {`(\?\\?)([\w!&*<>|^$%@+~?/=-]+)(:)(token|name|variable|expression|body|case-body|\*)`,
                    ByGroups(Operator, NameVariable, Operator, NameBuiltin), nil},
                {`(\?)(:)(token|name|variable|expression|body|case-body|\*)`,
                    ByGroups(Operator, Operator, NameVariable), nil},
                {`(\?\\?)([\w!&*<>|^$%@+~?/=-]+)`, ByGroups(Operator, NameVariable), nil},

                {`(=>|::|#\(|#\[|##|\?\?|\?=|\?|[(){}\[\],.;])`, Punctuation, nil},
                {`:=`, Operator, nil},
                {`#[tf]`, Literal, nil},
                {`#"`, LiteralStringSymbol, Push("symbol")},
                {`#[a-z0-9-]+`, Keyword, nil},
                {`#(all-keys|include|key|next|rest)`, Keyword, nil},
                {`[\w!&*<>|^$%@+~?/=-]+:`, KeywordConstant, nil},
                {`<[\w!&*<>|^$%@+~?/=-]+>`, NameClass, nil},
                {`\*[\w!&*<>|^$%@+~?/=-]+\*`, NameVariableGlobal, nil},
                {`\$[\w!&*<>|^$%@+~?/=-]+`, NameConstant, nil},
                {`(let|method|function)([ \t]+)([\w!&*<>|^$%@+~?/=-]+)`, ByGroups(NameBuiltin, Whitespace, NameVariable), nil},
                {`(error|signal|return|break)`, NameException, nil},
                {`(\\?)([\w!&*<>|^$%@+~?/=-]+)`, ByGroups(Operator, Name), nil},
            },
            "comment": {
                {`[^*/]`, CommentMultiline, nil},
                {`/\*`, CommentMultiline, Push()},
                {`\*/`, CommentMultiline, Pop(1)},
                {`[*/]`, CommentMultiline, nil},
            },
            "symbol": {
                {`"`, LiteralStringSymbol, Pop(1)},
                {`[^\\"]+`, LiteralStringSymbol, nil},
            },
            "string": {
                {`"`, LiteralString, Pop(1)},
                {`\\([\\abfnrtv"\']|x[a-f0-9]{2,4}|[0-7]{1,3})`, LiteralStringEscape, nil},
                {`[^\\"\n]+`, LiteralString, nil},
                {`\\\n`, LiteralString, nil},
                {`\\`, LiteralString, nil},
            },
        }
    },
))