...

Package t

import "github.com/alecthomas/chroma/lexers/t"
Overview
Index

Overview ▾

Variables

var TOML = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "TOML",
        Aliases:   []string{"toml"},
        Filenames: []string{"*.toml"},
        MimeTypes: []string{"text/x-toml"},
    },
    tomlRules,
))

TableGen lexer.

var Tablegen = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "TableGen",
        Aliases:   []string{"tablegen"},
        Filenames: []string{"*.td"},
        MimeTypes: []string{"text/x-tablegen"},
    },
    tablegenRules,
))

Tasm lexer.

var Tasm = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "TASM",
        Aliases:         []string{"tasm"},
        Filenames:       []string{"*.asm", "*.ASM", "*.tasm"},
        MimeTypes:       []string{"text/x-tasm"},
        CaseInsensitive: true,
    },
    tasmRules,
))

Tcl lexer.

var Tcl = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Tcl",
        Aliases:   []string{"tcl"},
        Filenames: []string{"*.tcl", "*.rvt"},
        MimeTypes: []string{"text/x-tcl", "text/x-script.tcl", "application/x-tcl"},
    },
    tclRules,
))

Tcsh lexer.

var Tcsh = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Tcsh",
        Aliases:   []string{"tcsh", "csh"},
        Filenames: []string{"*.tcsh", "*.csh"},
        MimeTypes: []string{"application/x-csh"},
    },
    tcshRules,
))

Tex lexer.

var TeX = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "TeX",
        Aliases:   []string{"tex", "latex"},
        Filenames: []string{"*.tex", "*.aux", "*.toc"},
        MimeTypes: []string{"text/x-tex", "text/x-latex"},
    },
    texRules,
))

Termcap lexer.

var Termcap = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Termcap",
        Aliases:   []string{"termcap"},
        Filenames: []string{"termcap", "termcap.src"},
        MimeTypes: []string{},
    },
    termcapRules,
))

Terminfo lexer.

var Terminfo = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Terminfo",
        Aliases:   []string{"terminfo"},
        Filenames: []string{"terminfo", "terminfo.src"},
        MimeTypes: []string{},
    },
    terminfoRules,
))

Terraform lexer.

var Terraform = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Terraform",
        Aliases:   []string{"terraform", "tf"},
        Filenames: []string{"*.tf"},
        MimeTypes: []string{"application/x-tf", "application/x-terraform"},
    },
    terraformRules,
))

Thrift lexer.

var Thrift = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Thrift",
        Aliases:   []string{"thrift"},
        Filenames: []string{"*.thrift"},
        MimeTypes: []string{"application/x-thrift"},
    },
    thriftRules,
))

TradingView lexer

var TradingView = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "TradingView",
        Aliases:   []string{"tradingview", "tv"},
        Filenames: []string{"*.tv"},
        MimeTypes: []string{"text/x-tradingview"},
        DotAll:    true,
        EnsureNL:  true,
    },
    tradingViewRules,
))

TransactSQL lexer.

var TransactSQL = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "Transact-SQL",
        Aliases:         []string{"tsql", "t-sql"},
        MimeTypes:       []string{"text/x-tsql"},
        NotMultiline:    true,
        CaseInsensitive: true,
    },
    transactSQLRules,
))

Turing lexer.

var Turing = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Turing",
        Aliases:   []string{"turing"},
        Filenames: []string{"*.turing", "*.tu"},
        MimeTypes: []string{"text/x-turing"},
    },
    turingRules,
))

Turtle lexer.

var Turtle = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "Turtle",
        Aliases:         []string{"turtle"},
        Filenames:       []string{"*.ttl"},
        MimeTypes:       []string{"text/turtle", "application/x-turtle"},
        NotMultiline:    true,
        CaseInsensitive: true,
    },
    turtleRules,
))

Twig lexer.

var Twig = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Twig",
        Aliases:   []string{"twig"},
        Filenames: []string{},
        MimeTypes: []string{"application/x-twig"},
        DotAll:    true,
    },
    twigRules,
))

TypeScript lexer.

var TypeScript = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "TypeScript",
        Aliases:   []string{"ts", "tsx", "typescript"},
        Filenames: []string{"*.ts", "*.tsx"},
        MimeTypes: []string{"text/x-typescript"},
        DotAll:    true,
        EnsureNL:  true,
    },
    typeScriptRules,
))

TypoScriptCSSData lexer.

var TypoScriptCSSData = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "TypoScriptCssData",
        Aliases:   []string{"typoscriptcssdata"},
        Filenames: []string{},
        MimeTypes: []string{},
    },
    typoScriptCSSDataRules,
))

TypoScriptHTMLData lexer.

var TypoScriptHTMLData = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "TypoScriptHtmlData",
        Aliases:   []string{"typoscripthtmldata"},
        Filenames: []string{},
        MimeTypes: []string{},
    },
    typoScriptHTMLDataRules,
))

Typoscript lexer.

var Typoscript = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "TypoScript",
        Aliases:   []string{"typoscript"},
        Filenames: []string{"*.ts"},
        MimeTypes: []string{"text/x-typoscript"},
        DotAll:    true,
        Priority:  0.1,
    },
    typoscriptRules,
))