package s

import "github.com/alecthomas/chroma/lexers/s"

Index

Variables 

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

SQL lexer. 

var SYSTEMD = internal.Register(MustNewLazyLexer(
	&Config{
		Name:    "SYSTEMD",
		Aliases: []string{"systemd"},

		Filenames: []string{"*.automount", "*.device", "*.dnssd", "*.link", "*.mount", "*.netdev", "*.network", "*.path", "*.scope", "*.service", "*.slice", "*.socket", "*.swap", "*.target", "*.timer"},
		MimeTypes: []string{"text/plain"},
	},
	systemdRules,
))
var Sas = internal.Register(MustNewLazyLexer(
	&Config{
		Name:            "SAS",
		Aliases:         []string{"sas"},
		Filenames:       []string{"*.SAS", "*.sas"},
		MimeTypes:       []string{"text/x-sas", "text/sas", "application/x-sas"},
		CaseInsensitive: true,
	},
	sasRules,
))

Sas lexer. 

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

Sass lexer. 

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

Scala lexer. 

var SchemeLang = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Scheme",
		Aliases:   []string{"scheme", "scm"},
		Filenames: []string{"*.scm", "*.ss"},
		MimeTypes: []string{"text/x-scheme", "application/x-scheme"},
	},
	schemeLangRules,
))

Scheme lexer. 

var Scilab = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Scilab",
		Aliases:   []string{"scilab"},
		Filenames: []string{"*.sci", "*.sce", "*.tst"},
		MimeTypes: []string{"text/scilab"},
	},
	scilabRules,
))

Scilab lexer. 

var Scss = internal.Register(MustNewLazyLexer(
	&Config{
		Name:            "SCSS",
		Aliases:         []string{"scss"},
		Filenames:       []string{"*.scss"},
		MimeTypes:       []string{"text/x-scss"},
		NotMultiline:    true,
		DotAll:          true,
		CaseInsensitive: true,
	},
	scssRules,
))

Scss lexer. 

var Smalltalk = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Smalltalk",
		Aliases:   []string{"smalltalk", "squeak", "st"},
		Filenames: []string{"*.st"},
		MimeTypes: []string{"text/x-smalltalk"},
	},
	smalltalkRules,
))

Smalltalk lexer. 

var Smarty = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Smarty",
		Aliases:   []string{"smarty"},
		Filenames: []string{"*.tpl"},
		MimeTypes: []string{"application/x-smarty"},
		DotAll:    true,
	},
	smartyRules,
))

Smarty lexer. 

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

Snobol lexer. 

var Solidity = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Solidity",
		Aliases:   []string{"sol", "solidity"},
		Filenames: []string{"*.sol"},
		MimeTypes: []string{},
		DotAll:    true,
	},
	solidityRules,
))

Solidity lexer. 

var Sparql = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "SPARQL",
		Aliases:   []string{"sparql"},
		Filenames: []string{"*.rq", "*.sparql"},
		MimeTypes: []string{"application/sparql-query"},
	},
	sparqlRules,
))

Sparql lexer. 

var Squidconf = internal.Register(MustNewLazyLexer(
	&Config{
		Name:            "SquidConf",
		Aliases:         []string{"squidconf", "squid.conf", "squid"},
		Filenames:       []string{"squid.conf"},
		MimeTypes:       []string{"text/x-squidconf"},
		NotMultiline:    true,
		CaseInsensitive: true,
	},
	squidconfRules,
))

Squidconf lexer. 

var StandardML = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Standard ML",
		Aliases:   []string{"sml"},
		Filenames: []string{"*.sml", "*.sig", "*.fun"},
		MimeTypes: []string{"text/x-standardml", "application/x-standardml"},
	},
	standardMLRules,
))

Standard ML lexer. 

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

Stylus lexer. 

var Svelte = internal.Register(DelegatingLexer(h.HTML, MustNewLazyLexer(
	&Config{
		Name:      "Svelte",
		Aliases:   []string{"svelte"},
		Filenames: []string{"*.svelte"},
		MimeTypes: []string{"application/x-svelte"},
		DotAll:    true,
	},
	svelteRules,
)))

Svelte lexer. 

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

Swift lexer. 

var Systemverilog = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "systemverilog",
		Aliases:   []string{"systemverilog", "sv"},
		Filenames: []string{"*.sv", "*.svh"},
		MimeTypes: []string{"text/x-systemverilog"},
		EnsureNL:  true,
	},
	systemvarilogRules,
))

Systemverilog lexer.

Source Files

sas.go sass.go scala.go scheme.go scilab.go scss.go smalltalk.go smarty.go sml.go snobol.go solidity.go sparql.go sql.go squid.go stylus.go svelte.go swift.go systemd.go systemverilog.go

Version
v0.9.2
Published
Jun 15, 2021
Platform
js/wasm
Imports
6 packages
Last checked
1 hour ago –

Tools for package owners.