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 Sieve = internal.Register(MustNewLazyLexer(
	&Config{
		Name:      "Sieve",
		Aliases:   []string{"sieve"},
		Filenames: []string{"*.siv", "*.sieve"},
		MimeTypes: []string{},
	},
	func() Rules {
		return Rules{
			"root": {
				{`\s+`, Text, nil},
				{`[();,{}\[\]]`, Punctuation, nil},
				{`(?i)require`, KeywordNamespace, nil},
				{"" /* 278 byte string literal not displayed */, ByGroups(NameTag, NameTag), nil},
				{"" /* 242 byte string literal not displayed */, NameBuiltin, nil},
				{`(?i)set`, KeywordDeclaration, nil},
				{`([0-9.]+)([kmgKMG])?`, ByGroups(LiteralNumber, LiteralNumber), nil},
				{`#.*$`, CommentSingle, nil},
				{`/\*.*\*/`, CommentMultiline, nil},
				{`"[^"]*?"`, LiteralString, nil},
				{`text:`, NameTag, Push("text")},
			},
			"text": {
				{`[^.].*?\n`, LiteralString, nil},
				{`^\.`, Punctuation, Pop(1)},
			},
		}
	},
))

Sieve 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 sieve.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.10.0 (latest)
Published
Jan 12, 2022
Platform
js/wasm
Imports
6 packages
Last checked
6 hours ago –

Tools for package owners.