▽

Package p

Variables

Pl/Pgsql lexer.

var PLpgSQL = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "PL/pgSQL",
        Aliases:         []string{"plpgsql"},
        Filenames:       []string{},
        MimeTypes:       []string{"text/x-plpgsql"},
        NotMultiline:    true,
        CaseInsensitive: true,
    },
    plpgSQLRules,
))

Pacmanconf lexer.

var Pacmanconf = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "PacmanConf",
        Aliases:   []string{"pacmanconf"},
        Filenames: []string{"pacman.conf"},
        MimeTypes: []string{},
    },
    pacmanconfRules,
))

Perl lexer.

var Perl = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Perl",
        Aliases:   []string{"perl", "pl"},
        Filenames: []string{"*.pl", "*.pm", "*.t"},
        MimeTypes: []string{"text/x-perl", "application/x-perl"},
        DotAll:    true,
    },
    perlRules,
))

Pig lexer.

var Pig = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "Pig",
        Aliases:         []string{"pig"},
        Filenames:       []string{"*.pig"},
        MimeTypes:       []string{"text/x-pig"},
        CaseInsensitive: true,
    },
    pigRules,
))

Pkgconfig lexer.

var Pkgconfig = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "PkgConfig",
        Aliases:   []string{"pkgconfig"},
        Filenames: []string{"*.pc"},
        MimeTypes: []string{},
    },
    pkgconfigRules,
))

var Plaintext = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "plaintext",
        Aliases:   []string{"text", "plain", "no-highlight"},
        Filenames: []string{"*.txt"},
        MimeTypes: []string{"text/plain"},
        Priority:  0.1,
    },
    internal.PlaintextRules,
))

var PlutusCoreLang = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Plutus Core",
        Aliases:   []string{"plutus-core", "plc"},
        Filenames: []string{"*.plc"},
        MimeTypes: []string{"text/x-plutus-core", "application/x-plutus-core"},
    },
    plutusCoreRules,
))

Pony lexer.

var Pony = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Pony",
        Aliases:   []string{"pony"},
        Filenames: []string{"*.pony"},
        MimeTypes: []string{},
    },
    ponyRules,
))

Postgresql Sql Dialect lexer.

var PostgreSQL = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "PostgreSQL SQL dialect",
        Aliases:         []string{"postgresql", "postgres"},
        Filenames:       []string{},
        MimeTypes:       []string{"text/x-postgresql"},
        NotMultiline:    true,
        CaseInsensitive: true,
    },
    postgreSQLRules,
))

Postscript lexer.

var Postscript = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "PostScript",
        Aliases:   []string{"postscript", "postscr"},
        Filenames: []string{"*.ps", "*.eps"},
        MimeTypes: []string{"application/postscript"},
    },
    postscriptRules,
))

Povray lexer.

var Povray = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "POVRay",
        Aliases:   []string{"pov"},
        Filenames: []string{"*.pov", "*.inc"},
        MimeTypes: []string{"text/x-povray"},
    },
    povrayRules,
))

PowerQuery lexer.

var PowerQuery = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "PowerQuery",
        Aliases:         []string{"powerquery", "pq"},
        Filenames:       []string{"*.pq"},
        MimeTypes:       []string{"text/x-powerquery"},
        DotAll:          true,
        CaseInsensitive: true,
    },
    powerqueryRules,
))

Powershell lexer.

var Powershell = internal.Register(MustNewLazyLexer(
    &Config{
        Name:            "PowerShell",
        Aliases:         []string{"powershell", "posh", "ps1", "psm1", "psd1"},
        Filenames:       []string{"*.ps1", "*.psm1", "*.psd1"},
        MimeTypes:       []string{"text/x-powershell"},
        DotAll:          true,
        CaseInsensitive: true,
    },
    powershellRules,
))

Prolog lexer.

var Prolog = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Prolog",
        Aliases:   []string{"prolog"},
        Filenames: []string{"*.ecl", "*.prolog", "*.pro", "*.pl"},
        MimeTypes: []string{"text/x-prolog"},
    },
    prologRules,
))

Promql lexer.

var Promql = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "PromQL",
        Aliases:   []string{"promql"},
        Filenames: []string{"*.promql"},
        MimeTypes: []string{},
    },
    promqlRules,
))

ProtocolBuffer lexer.

var ProtocolBuffer = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Protocol Buffer",
        Aliases:   []string{"protobuf", "proto"},
        Filenames: []string{"*.proto"},
        MimeTypes: []string{},
    },
    protocolBufferRules,
))

Puppet lexer.

var Puppet = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Puppet",
        Aliases:   []string{"puppet"},
        Filenames: []string{"*.pp"},
        MimeTypes: []string{},
    },
    puppetRules,
))

Python lexer.

var Python = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Python",
        Aliases:   []string{"python", "py", "sage", "python3", "py3"},
        Filenames: []string{"*.py", "*.pyi", "*.pyw", "*.jy", "*.sage", "*.sc", "SConstruct", "SConscript", "*.bzl", "BUCK", "BUILD", "BUILD.bazel", "WORKSPACE", "*.tac"},
        MimeTypes: []string{"text/x-python", "application/x-python", "text/x-python3", "application/x-python3"},
    },
    pythonRules,
))

Python2 lexer.

var Python2 = internal.Register(MustNewLazyLexer(
    &Config{
        Name:      "Python 2",
        Aliases:   []string{"python2", "py2"},
        Filenames: []string{},
        MimeTypes: []string{"text/x-python2", "application/x-python2"},
    },
    python2Rules,
))