etc.cson

# Reusable, generic patterns for matching recurring language elements
scopeName: "etc"
patterns: [
	{include: "#comma"}
	{include: "#comment"}
	{include: "#esc"}
	{include: "#float"}
	{include: "#int"}
	{include: "#str"}
	{include: "#colon"}
	{include: "#eql"}
	{include: "#dot"}
]

repository:

	# Base64-encoded data
	base64:
		name: "constant.numeric.base64"
		match: "[A-Za-z0-9+/=]{4,}"

	# Commas
	comma:
		name: "punctuation.separator.delimiter.comma"
		match: ","

	# Comment-line; alias for `#commentHash`
	comment:
		patterns: [include: "#commentHash"]

	# ## Hash-style comments ##
	commentHash:
		name:  "comment.line.number-sign"
		begin: "#"
		end:   "$"
		beginCaptures:
			0: name: "punctuation.definition.comment"

	# ;; Semicolon-style comment ;;
	commentSemi:
		name: "comment.line.semicolon"
		begin: ";+"
		end:   "$"
		beginCaptures:
			0: name: "punctuation.definition.comment"
	
	# // C++ style double-slash comments
	commentSlash:
		name: "comment.line.double-slash"
		begin: "//"
		end:   "$"
		beginCaptures:
			0: name: "punctuation.definition.comment"

	# Unquoted string-like argument
	bareword:
		name: "string.unquoted.bareword"
		match: '[^"\\s][\\S]*'

	# True/false
	bool:
		name:  "constant.logical.bool.boolean.${1:/downcase}"
		match: "\\b(true|false|TRUE|FALSE)\\b"

	# Unpaired bracket/brace/parenthesis
	bracket:
		patterns: [
			{match: "\\{", name: "punctuation.definition.bracket.curly.brace.begin"}
			{match: "\\}", name: "punctuation.definition.bracket.curly.brace.end"}
			{match: "\\[", name: "punctuation.definition.bracket.square.begin"}
			{match: "\\]", name: "punctuation.definition.bracket.square.end"}
			{match: "\\(", name: "punctuation.definition.bracket.round.parenthesis.begin"}
			{match: "\\)", name: "punctuation.definition.bracket.round.parenthesis.end"}
			{match: "<",   name: "punctuation.definition.bracket.angle.ascii.begin"}
			{match: ">",   name: "punctuation.definition.bracket.angle.ascii.end"}
			{match: "⟨",   name: "punctuation.definition.bracket.angle.unicode.begin"}
			{match: "⟩",   name: "punctuation.definition.bracket.angle.unicode.end"}
		]
	
	# ...↓
	colon:
		name: "punctuation.delimiter.separator.colon"
		match: ":"

	# Dash/US‒ASCII “hyphen‒minus” (U+002D)
	dash:
		name: "punctuation.delimiter.separator.dash.hyphen"
		match: "-"

	# Dots/full-stops/periods/whatever
	dots:
		patterns: [
			{include: "#ellipsis"}  # ...
			{include: "#dotPair"}   # ..
			{include: "#dot"}       # .
		]

	# Dot: .
	dot:
		name: "punctuation.delimiter.separator.property.period.dot"
		match: "\\."
	
	# Lazy ellipsis: ‥
	dotPair:
		name: "keyword.operator.punctuation.dots.splat.range.spread.rest"
		match: "\\.\\.|‥"
	
	# Full-blown ellipsis: ...
	ellipsis:
		name: "keyword.operator.punctuation.ellipsis.splat.range.spread.rest"
		match: "\\.{3}|…"

	# Overblown ellipsis: ........................
	dotTrail:
		name: "punctuation.delimiter.separator.dotted.border.leader.dots"
		match: "\\.{4,}"


	# E-mail address, matched informally with regards to RFC 5322
	email:
		patterns: [
			{include: "#emailBracketed"}
			{include: "#emailQuoted"}
			{include: "#emailUnquoted"}
		]
	
	
	emailBracketed:
		patterns: [{
			# <ascii@angle.brackets>
			name: "meta.email-address.bracketed.ascii.angle-brackets"
			match: "(<)\\s*([^>@\\s]+@[^>@\\s]+)\\s*(>)"
			captures:
				1: patterns: [include: "#bracket"]
				2: patterns: [include: "#emailInnards"]
				3: patterns: [include: "#bracket"]
		},{
			# ⟨unicode@angle.brackets⟩
			name: "meta.email-address.bracketed.unicode.angle-brackets"
			match: "(⟨)\\s*([^⟩@\\s]+@[^⟩@\\s]+)\\s*(⟩)"
			captures:
				1: patterns: [include: "#bracket"]
				2: patterns: [include: "#emailInnards"]
				3: patterns: [include: "#bracket"]
		},{
			# «guille@mots»
			name: "meta.email-address.bracketed.guillemots"
			match: "(«)\\s*([^»@\\s]+@[^»@\\s]+)\\s*(»)"
			captures:
				1: patterns: [include: "#bracket"]
				2: patterns: [include: "#emailInnards"]
				3: patterns: [include: "#bracket"]
		},{
			# (round@brackets)
			name: "meta.email-address.bracketed.round-brackets"
			match: "(\\()\\s*([^\\)@\\s]+@[^\\)@\\s]+)\\s*(\\))"
			captures:
				1: patterns: [include: "#bracket"]
				2: patterns: [include: "#emailInnards"]
				3: patterns: [include: "#bracket"]
		},{
			# {curly@brackets}
			name: "meta.email-address.bracketed.curly-brackets"
			match: "({)\\s*([^}@\\s]+@[^}@\\s]+)\\s*(})"
			captures:
				1: patterns: [include: "#bracket"]
				2: patterns: [include: "#emailInnards"]
				3: patterns: [include: "#bracket"]
		},{
			# [squre@brackets]
			name: "meta.email-address.bracketed.square-brackets"
			match: "(\\[)\\s*([^\\]@\\s]+@[^\\]@\\s]+)\\s*(\\])"
			captures:
				1: patterns: [include: "#bracket"]
				2: patterns: [include: "#emailInnards"]
				3: patterns: [include: "#bracket"]
		}]


	# "quoted@address.strings"
	emailQuoted:
		patterns: [{
			# "straight@double.quotes"
			name: "meta.email-address.quoted.ascii.double-quotes"
			match: '(")\\s*([^"@\\s]+@[^"@\\s]+)\\s*(")'
			captures:
				0: name: "string.quoted.double"
				1: name: "punctuation.definition.string.begin.email-address"
				2: patterns: [include: "#emailInnards"]
				3: name: "punctuation.definition.string.end.email-address"
		},{
			# “directional@double.quotes”
			name: "meta.email-address.quoted.unicode.double-quotes"
			match: "(“)\\s*([^”@\\s]+@[^”@\\s]+)\\s*(”)"
			captures:
				0: name: "string.quoted.double"
				1: name: "punctuation.definition.string.begin.email-address"
				2: patterns: [include: "#emailInnards"]
				3: name: "punctuation.definition.string.end.email-address"
		},{
			# ‘directional@single.quotes’
			name: "meta.email-address.quoted.unicode.single-quotes"
			match: "(‘)\\s*([^’@\\s]+@[^’@\\s]+)\\s*(’)"
			captures:
				0: name: "string.quoted.single"
				1: name: "punctuation.definition.string.begin.email-address"
				2: patterns: [include: "#emailInnards"]
				3: name: "punctuation.definition.string.end.email-address"
		},{
			# `back@ticks`
			name: "meta.email-address.quoted.backticks"
			match: '(`)\\s*([^`@\\s]+@[^`@\\s]+)\\s*(`)'
			captures:
				0: name: "string.quoted.template.backticks"
				1: name: "punctuation.definition.string.begin.email-address"
				2: patterns: [include: "#emailInnards"]
				3: name: "punctuation.definition.string.end.email-address"
		},{
			# 'straight@single.quotes', `asymmetric@single.quotes'
			name: "meta.email-address.quoted.single-quotes"
			match: "(`|')\\s*([^'@\\s]+@[^'@\\s]+)\\s*(')"
			captures:
				0: name: "string.quoted.single"
				1: name: "punctuation.definition.string.begin.email-address"
				2: patterns: [include: "#emailInnards"]
				3: name: "punctuation.definition.string.end.email-address"
		}]
		

	# Unquoted address: local-part@domain.tld
	emailUnquoted:
		name: "meta.email-address.unquoted"
		match: """(?x)
			((?!\\.) (?:[^\\[\\(<⟨«\"'\\s@.]|\\.(?!\\.))++ @
			([^\\[\\(<⟨«\"'\\s@.]+?\\.(?=[^\\.\\s])(?:[^\\[\\(<⟨«\"'\\s@.]|\\.(?!\\.))++))
		"""
		captures: 1:
			name: "string.unquoted.email-address"
			patterns: [include: "#emailInnards"]
	
	
	# Stuff matched <inside.an.@email.address>
	emailInnards:
		name: "constant.other.reference.link.underline.email"
		match: "(?:\\G|^|(?<=\\n)).+"
		captures: 0: patterns: [{
			match: "\\G([^@]*)(@)(.*)"
			captures:
				1: name: "meta.local-part"
				2: name: "punctuation.separator.at-sign.email"
				3: name: "meta.domain"
		}]


	# Escape (Backslash-prefixed anything)
	esc:
		name: "constant.character.escape.backslash"
		match: "(\\\\)."
		captures:
			1: name: "punctuation.definition.escape.backslash"

	# Equals sign delimiting key-value pairs
	eql:
		name: "keyword.operator.assignment.key-value.equals-sign"
		match: "="


	# Floating point
	float:
		patterns: [
			{include: "#floatExp"}
			{include: "#floatNoExp"}
		]
	
	# Float, exponential notation
	floatExp:
		name:  "constant.numeric.float.real.decimal.dec.exponential.scientific"
		match: "[-+]?(?:[0-9]*\\.[0-9]+|[0-9]+\\.)(?:[eE][-+]?[0-9]+)++"
	
	# Float, basic
	floatNoExp:
		name: "constant.numeric.float.real.decimal.dec"
		match: "[-+]?(?:[0-9]*\\.[0-9]+|[0-9]+\\.)++"


	# Hexadecimal, +possibly-signed value
	hex:
		name: "constant.numeric.integer.int.hexadecimal.hex"
		match: "[-+]?[A-Fa-f0-9]+"

	# Hexadecimal, digits only
	hexNoSign:
		name: "constant.numeric.integer.int.hexadecimal.hex"
		match: "[A-Fa-f0-9]+"


	# Integer
	int:
		patterns: [
			{include: "#intExp"}
			{include: "#intNoExp"}
		]
	
	# Integer, exponential notation
	intExp:
		name:  "constant.numeric.integer.int.decimal.dec.exponential.scientific"
		match: "[-+]?[0-9]+[eE][-+]?[0-9]+"
	
	# Integer, basic
	intNoExp:
		name:  "constant.numeric.integer.int.decimal.dec"
		match: "[-+]?[0-9]+"
	
	
	# Dot-separated numbers which quack like an IP address
	ip:
		name:  "constant.numeric.other.ip-address"
		match: "(?:\\d+\\.){3,}\\d+(?=\\s|$)"
		captures:
			0: patterns: [include: "#dot"]
	
	
	# Colon with keyword highlighting
	kolon:
		name: "keyword.operator.assignment.key-value.colon"
		match: ":"
	
	
	# Both floats and integers
	num:
		patterns: [
			{include: "#float"}
			{include: "#int"}
		]
	
	
	# C-like unary and binary operators
	op:
		patterns: [
			{include: "#opBitAssign"}
			{include: "#opMathAssign"}
			{include: "#opBit"}
			{include: "#opFix"}
			{include: "#opCmp"}
			{include: "#opLog"}
			{include: "#opMath"}
		]
	
	# Bitwise operators
	opBit:
		patterns: [
			{match: "\\^", name: "keyword.operator.bitwise.xor"}
			{match: "~",   name: "keyword.operator.bitwise.not"}
			{match: "&",   name: "keyword.operator.bitwise.and"}
			{match: "\\|", name: "keyword.operator.bitwise.or"}
			{match: "<<",  name: "keyword.operator.bitwise.shift.left"}
			{match: ">>>", name: "keyword.operator.bitwise.shift.right.unsigned"}
			{match: ">>",  name: "keyword.operator.bitwise.shift.right.signed"}
		]
	
	# Bitwise assignment operators
	opBitAssign:
		patterns: [
			{match: "\\^=", name: "keyword.operator.assignment.bitwise.xor"}
			{match: "~=",   name: "keyword.operator.assignment.bitwise.not"}
			{match: "&=",   name: "keyword.operator.assignment.bitwise.and"}
			{match: "\\|=", name: "keyword.operator.assignment.bitwise.or"}
			{match: "<<=",  name: "keyword.operator.assignment.bitwise.shift.left"}
			{match: ">>>=", name: "keyword.operator.assignment.bitwise.shift.right.unsigned"}
			{match: ">>=",  name: "keyword.operator.assignment.bitwise.shift.right.signed"}
		]
	
	# Comparison operators
	opCmp:
		patterns: [
			{match: "<=>", name: "keyword.operator.logical.comparison.starship.spaceship"}
			{match: "<=",  name: "keyword.operator.logical.comparison.less-than-or-equal-to.lte"}
			{match: "<",   name: "keyword.operator.logical.comparison.less-than.lt"}
			{match: ">=",  name: "keyword.operator.logical.comparison.greater-than-or-equal-to.gte"}
			{match: ">",   name: "keyword.operator.logical.comparison.greater-than.gt"}
			{match: "===", name: "keyword.operator.logical.comparison.equal-to.equals.equal.eql.eq.strict"}
			{match: "==",  name: "keyword.operator.logical.comparison.equal-to.equals.equal.eql.eq"}
			{match: "!==", name: "keyword.operator.logical.comparison.not-equal-to.not-equal.unequal.neql.ne.strict"}
			{match: "!=",  name: "keyword.operator.logical.comparison.not-equal-to.not-equal.unequal.neql.ne"}
		]
	
	# Prefix and postfix
	opFix:
		patterns: [
			{match: "\\+{2}", name: "keyword.operator.increment"}
			{match: "-{2}",   name: "keyword.operator.decrement"}
		]
	
	# Logical operators
	opLog:
		patterns: [
			{match: "!!",     name: "keyword.operator.logical.boolean.cast"}
			{match: "!",      name: "keyword.operator.logical.boolean.not.negation.negate"}
			{match: "&&",     name: "keyword.operator.logical.boolean.and"}
			{match: "\\|{2}", name: "keyword.operator.logical.boolean.or"}
			{match: "\\?{2}", name: "keyword.operator.logical.boolean.or.nullish"}
		]
	
	# Mathematical operators
	opMath:
		patterns: [
			{match: "\\*{2}|\\^", name: "keyword.operator.arithmetic.exponentiation.exponent.exp.power"}
			{match: "\\+",        name: "keyword.operator.arithmetic.addition.add.plus"}
			{match: "\\*",        name: "keyword.operator.arithmetic.multiplication.multiply.times"}
			{match: "/",          name: "keyword.operator.arithmetic.division.divide"}
			{match: "%",          name: "keyword.operator.arithmetic.remainder.modulo.modulus.mod"}
			
			# This should really be `\p{Dash}`, but Atom whines about an "invalid character property",
			# even though ECMAScript, Oniguruma and Perl's regular expression syntaxes all support it.
			name: "keyword.operator.arithmetic.subtraction.subtract.minus"
			match: "[-\u058A\u05BE\u1400\u1806‐-―\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D]"
		]
	
	# Arithmetical assignment operators
	opMathAssign:
		patterns: [
			{match: "\\*{2}=|\\^=", name: "keyword.operator.assignment.arithmetic.exponentiation.exponent.exp.power"}
			{match: "\\+=",         name: "keyword.operator.assignment.arithmetic.addition.add.plus"}
			{match: "\\*=",         name: "keyword.operator.assignment.arithmetic.multiplication.multiply.times"}
			{match: "/=",           name: "keyword.operator.assignment.arithmetic.division.divide"}
			{match: "%=",           name: "keyword.operator.assignment.arithmetic.remainder.modulo.modulus.mod"}
			
			name: "keyword.operator.assignment.arithmetic.subtraction.subtract.minus"
			match: "[-\u058A\u05BE\u1400\u1806‐-―\u2E17\u2E1A\u2E3A\u2E3B\u2E40\u301C\u3030\u30A0\uFE31\uFE32\uFE58\uFE63\uFF0D]="
		]
	
	
	# Semicolon
	semi:
		name: "punctuation.delimiter.separator.semicolon"
		match: ";"
	
	
	# Strings
	str:
		patterns: [
			{include: "#strDouble"}
			{include: "#strSingle"}
		]
	
	# Double-quoted string
	strDouble:
		name:  "string.quoted.double"
		begin: '"'
		end:   '"|(?=$)'
		beginCaptures: 0: name: "punctuation.definition.string.begin"
		endCaptures:   0: name: "punctuation.definition.string.end"
		patterns: [include: "#esc"]
	
	# Single-quoted string
	strSingle:
		name:  "string.quoted.single"
		begin: "'"
		end:   "'|(?=$)"
		beginCaptures: 0: name: "punctuation.definition.string.begin"
		endCaptures:   0: name: "punctuation.definition.string.end"
		patterns: [include: "#esc"]


	# Horizontal tab (U+0009)
	tab:
		patterns: [
			{match: "^\\t+", captures: 0: patterns: [match: "\\t", name: "punctuation.whitespace.leading.tab.hard-tab"]}
			{match: "\\t+$", captures: 0: patterns: [match: "\\t", name: "punctuation.whitespace.trailing.tab.hard-tab"]}
			{match: "\\t",   name: "punctuation.whitespace.tab.hard-tab"}
		]


	# URL/e-mail address
	url:
		patterns: [{
			# https://etc, git://github.com/
			match: """(?x)
				("|'|\\b)
				(
					# Not part of official URL schemes, included here for convenience
					(?: (?:jdbc|mvn|odbc|view-source) :)?

					# Common protocols/URI schemes
					( https?
					| s?ftp
					| ftps
					| file
					| wss?
					| (?:git|svn) (?:\\+(?:https?|ssh))?
					| ssh
					
					# Less common URI schemes
					| aaas?
					| acap
					| adiumxtra
					| admin
					| afp
					| app
					| atom
					| aurora
					| aw
					| beshare
					| bolo
					| cassandra
					| chrome(?:-extension)?
					| coaps?
					| cockroach
					| content
					| couchbase
					| crid
					| cvs
					| dict
					| dns
					| docker
					| ed2k
					| facetime
					| feed
					| finger
					| fish
					| gemini
					| github(?:-(?:mac|linux|windows))?
					| gizmoproject
					| gopher
					| go
					| hcp
					| imap
					| irc[6s]?
					| issue
					| keyparc
					| lastfm
					| ldaps?
					| man(?:-?page)?
					| maria(?:db)?
					| market
					| message
					| mms
					| modern-?sqlite
					| mongodb
					| ms-help
					| mssql
					| mumble
					| my?sql
					| netezza
					| nfs
					| ni
					| nntp
					| notes
					| oleodbc
					| oracle
					| payto
					| pgsql
					| pg
					| pop
					| postgres(?:ql)?
					| postgresql
					| presto(?:dbs?|s)
					| reload
					| resource
					| res
					| rmi
					| rsync
					| rtmf?p
					| rtmp
					| s3
					| saphana
					| secondlife
					| sgn
					| shttp
					| slack
					| smb
					| snmp
					| soldat
					| sqlite3?
					| sqlserver
					| steam
					| stratum\\+[a-z]+
					| stuns?
					| teamspeak
					| telnet
					| turns?
					| txmt
					| udp
					| unreal
					| ut2004
					| ventrilo
					| vnc
					| wais
					| web\\+[a-z]+
					| webcal
					| wtai
					| wyciwyg
					| xmpp
					| xri
					| z39\\.50[rs]
					| zoommtg
					
					# User-defined/arbitrary URI scheme starting with `x-`
					| x(?:-[a-z][a-z0-9]*)++
					) ://
					
					# Path specifier
					(?:
						(?! \\#\\w*\\#)
						(?: [-:\\@\\w.,~%+_/?=&\\#;|!])
					)+
					
					# Don't include trailing punctuation
					(?<![-.,?:\\#;])
				)
				(\\1)
			"""
			captures:
				1: name: "punctuation.definition.link.begin.url"
				2: name: "constant.other.reference.link.underline.$3.url"
				4: name: "punctuation.definition.link.end.url"
		},{
			# mailto:this@guy
			match: """(?x)
				("|'|\\b)
				(
					mailto (:)
					(?:
						(?! \\#\\w*\\#)
						(?: [-:@\\w.,~%+_/?=&\\#;|!])
					)+
					(?<![-.,?:\\#;])
				)
				(\\1)
			"""
			captures:
				1: name: "punctuation.definition.link.begin.url"
				2: name: "constant.other.reference.link.underline.mailto.url"
				3: name: "punctuation.separator.delimiter.scheme.url"
				4: name: "punctuation.definition.link.end.url"
		}]


	# Semantic version string
	version:
		name: "constant.other.version-string"
		match: """(?x)
			("|'|\\b)
			([vV]?)
			(0 | [1-9]\\d*) (\\.)
			(0 | [1-9]\\d*) (\\.)
			(0 | [1-9]\\d*)
			(?:
				(-)
				(
					(?: 0
					| [1-9]\\d*
					| \\d*[a-zA-Z-][0-9a-zA-Z-]*
					)
					
					(?:
						\\.
						(?: 0
						| [1-9]\\d*
						| \\d*[a-zA-Z-][0-9a-zA-Z-]*
						)
					)*
				)
			)?
			(?:
				(\\+)
				(
					[0-9a-zA-Z-]+
					(?:\\.[0-9a-zA-Z-]+)*
				)
			)?
			(\\1)
		"""
		captures:
			1:  name: "punctuation.definition.version-string.begin"
			2:  name: "punctuation.definition.version-prefix"
			3:  name: "meta.major.release-number"
			4:  patterns: [include: "#dot"]
			5:  name: "meta.minor.release-number"
			6:  patterns: [include: "#dot"]
			7:  name: "meta.patch.release-number"
			8:  patterns: [include: "#dash"]
			9:  name: "meta.prerelease.release-number", patterns: [include: "#dot"]
			10: name: "punctuation.delimiter.separator.plus"
			11: name: "meta.build-metadata", patterns: [include: "#dot"]
			12: name: "punctuation.definition.version-string.end"