# A collection of simple regexp-based rules that can be applied to content

# to disambiguate languages with the same file extension.

#

# There are two top-level keys: disambiguations and named_patterns.

#

# disambiguations - a list of disambiguation rules, one for each

# extension or group of extensions.

# extensions - an array of file extensions that this block applies to.

# rules - list of rules that are applied in order to the content

# of a file with a matching extension. Rules are evaluated

# until one of them matches. If none matches, no language

# is returned.

# language - Language to be returned if the rule matches.

# pattern - Ruby-compatible regular expression that makes the rule

# match. If no pattern is specified, the rule always matches.

# Pattern can be a string with a single regular expression

# or an array of strings that will be merged in a single

# regular expression (with union).

# and - An and block merges multiple rules and checks that all of

# them must match.

# negative_pattern - Same as pattern, but checks for absence of matches.

# named_pattern - A pattern can be reused by specifying it in the

# named_patterns section and referencing it here by its

# key.

# named_patterns - Key-value map of reusable named patterns.

#

# Please keep this list alphabetized.

#

---

disambiguations:

- extensions: ['.1', '.2', '.3', '.4', '.5', '.6', '.7', '.8', '.9']

rules:

- language: Roff Manpage

and:

- named_pattern: mdoc-date

- named_pattern: mdoc-title

- named_pattern: mdoc-heading

- language: Roff Manpage

and:

- named_pattern: man-title

- named_pattern: man-heading

- language: Roff

pattern: '^\.(?:[A-Za-z]{2}(?:\s|$)|\\")'

- language: Text

- extensions: ['.1in', '.1m', '.1x', '.3in', '.3m', '.3p', '.3pm', '.3qt', '.3x', '.man', '.mdoc']

rules:

- language: Roff Manpage

and:

- named_pattern: mdoc-date

- named_pattern: mdoc-title

- named_pattern: mdoc-heading

- language: Roff Manpage

and:

- named_pattern: man-title

- named_pattern: man-heading

- language: Roff

- extensions: ['.action']

rules:

- language: ROS Interface

and:

- pattern: '(?i)^[a-z]\w*(?:\/[a-z]\w*)?(?:<=\d+)?(?:\[(?:<=\d+)?\])?\s+\w+\b'

- pattern: '^---\s*$'

- negative_pattern: '^\s*[^\s@#\w-]'

- extensions: ['.al']

rules:

# AL pattern source from https://github.com/microsoft/AL/blob/master/grammar/alsyntax.tmlanguage - keyword.other.applicationobject.al

- language: AL

and:

- pattern: '\b(?i:(CODEUNIT|PAGE|PAGEEXTENSION|PAGECUSTOMIZATION|DOTNET|ENUM|ENUMEXTENSION|VALUE|QUERY|REPORT|TABLE|TABLEEXTENSION|XMLPORT|PROFILE|CONTROLADDIN|REPORTEXTENSION|INTERFACE|PERMISSIONSET|PERMISSIONSETEXTENSION|ENTITLEMENT))\b'

# Open-ended fallback to Perl AutoLoader

- language: Perl

- extensions: ['.alg']

rules:

- language: ALGOL

pattern:

# ALGOL 60 comments

- '(?i)^comment\b.*(;|comment)'

# ALGOL 68 comments

- '^#[^#\r\n]+#$'

# ALGOL 60/68 keywords

- '(?i)\b(integer|real|boolean|string)\b\s+\w+\s*:=\s*'

- '(?i)^begin[\s\S]*^end'

- extensions: ['.app']

rules:

- language: Erlang

pattern: '^\{\s*(?:application|''application'')\s*,\s*(?:[a-z]+[\w@]*|''[^'']+'')\s*,\s*\[(?:.|[\r\n])*\]\s*\}\.[ \t]*$'

- extensions: ['.as']

rules:

- language: ActionScript

pattern: '^\s*(?:package(?:\s+[\w.]+)?\s+(?:\{|$)|import\s+[\w.*]+\s*;|(?:intrinsic\s+)class\s+[\w<>.]+|\s+class\s+extends\s+[\w<>.]+|(?:(?:public|protected|private|static)\s+)*(?:(?:var|const|local)\s+\w+\s*:\s*[\w<>.]+(?:\s*=.*)?\s*;|function\s+\w+\s*\((?:\s*\w+\s*:\s*[\w<>.]+\s*(,\s*\w+\s*:\s*[\w<>.]+\s*)*)?\)))'

- extensions: ['.asc']

rules:

- language: Public Key

pattern: '^(----[- ]BEGIN|ssh-(rsa|dss)) '

- language: AsciiDoc

pattern: '^[=-]+\s|\{\{[A-Za-z]'

- language: AGS Script

pattern: '^(\/\/.+|((import|export)\s+)?(function|int|float|char)\s+((room|repeatedly|on|game)_)?([A-Za-z]+[A-Za-z_0-9]+)\s*[;\(])'

- extensions: ['.asm']

rules:

- language: Assembly

pattern: '(?i)mov\s+[^\s]{2,},'

- language: Motorola 68K Assembly

named_pattern: m68k

- extensions: ['.asy']

rules:

- language: LTspice Symbol

pattern: '^SymbolType[ \t]'

- language: Asymptote

- extensions: ['.bas']

rules:

- language: B4X

pattern: '\A\W{0,3}(?:.*(?:\r?\n|\r)){0,9}B4(?:J|A|R|i)=true'

- language: FreeBASIC

named_pattern: freebasic

- language: FreeBASIC

and:

- pattern: '(?i)^[ \t]*return '

- negative_pattern: '(?i)[ \t]*gosub '

- language: BASIC

pattern: '\A\s*\d'

- language: QuickBASIC

named_pattern: quickbasic

- language: VBA

named_pattern: vba

- language: Visual Basic 6.0

named_pattern: vb-module

- extensions: ['.bb']

rules:

- language: BlitzBasic

pattern: '(<^\s*; |End Function)'

- language: BitBake

pattern: '^(# |include|require|inherit)\b'

- language: Clojure

pattern: '\((def|defn|defmacro|let)\s'

- extensions: ['.bf']

rules:

- language: Beef

pattern: '(?-m)^\s*using\s+(System|Beefy)(\.(.*))?;\s*$'

- language: HyPhy

pattern:

- '(?-m)^\s*#include\s+".*";\s*$'

- '\sfprintf\s*\('

- language: Brainfuck

pattern: '(>\+>|>\+<)'

- extensions: ['.bi']

rules:

- language: FreeBASIC

named_pattern: freebasic

- language: FreeBASIC

and:

- pattern: '(?i)^[ \t]*return '

- negative_pattern: '(?i)[ \t]*gosub '

- language: QuickBASIC

named_pattern: quickbasic

- extensions: ['.bs']

rules:

- language: Bikeshed

pattern: '^(?i:<pre\s+class)\s*=\s*(''|\"|\b)metadata\b(''|\"|\b)[^>\r\n]*>'

- language: BrighterScript

pattern:

- (?i:^\s*(?:sub\s*\w+\(.*?\))|(?::\s*sub\(.*?\))$)

- (?i:^\s*(end\ssub)$)

- (?i:^\s*(?:function\s*\w+\(.*?\)\s*as\s*\w*)|(?::\s*function\(.*?\)\s*as\s*\w*)$)

- (?i:^\s*(end\sfunction)$)

- language: Bluespec BH

pattern: '^package\s+[A-Za-z_][A-Za-z0-9_'']*(?:\s*\(|\s+where)'

- extensions: ['.bst']

rules:

- language: BibTeX Style

pattern: 'ENTRY\s*\{'

- language: BuildStream

- extensions: ['.builds']

rules:

- language: XML

pattern: '^(\s*)(?i:<Project|<Import|<Property|<?xml|xmlns)'

- extensions: ['.cairo']

rules:

- language: Cairo Zero

pattern: '(^(\s*)%lang(\s+)([A-Za-z0-9_]+))|(^(\s*)%builtins(\s+)([A-Za-z0-9_]+\s*)*$)|(^(\s*)from(\s+)starkware\.(cairo|starknet)\.([A-Za-z0-9_.\s]+?)import)|(,\s*ap\+\+;$)|(;\s*ap\+\+$)'

- language: Cairo

- extensions: ['.ch']

rules:

- language: xBase

pattern: '^\s*#\s*(?i:if|ifdef|ifndef|define|command|xcommand|translate|xtranslate|include|pragma|undef)\b'

- extensions: ['.cl']

rules:

- language: Common Lisp

pattern: '^\s*\((?i:defun|in-package|defpackage) '

- language: Cool

pattern: '^class'

- language: OpenCL

pattern: '\/\* |\/\/ |^\}'

- extensions: ['.cls']

rules:

- language: Visual Basic 6.0

and:

- named_pattern: vb-class

- pattern: '^\s*BEGIN(?:\r?\n|\r)\s*MultiUse\s*=.*(?:\r?\n|\r)\s*Persistable\s*='

- language: VBA

named_pattern: vb-class

- language: TeX

pattern: '^\s*\\(?:NeedsTeXFormat|ProvidesClass)\{'

- language: ObjectScript

pattern: '^Class\s'

- language: OpenEdge ABL

pattern: '(?i)^\s*(?:end\s+(?:class|interface)\.|(?:class|interface)\s+[a-z_][a-z0-9_#$%&-]*:)'

- extensions: ['.cmp']

rules:

- language: Gerber Image

pattern: '^[DGMT][0-9]{2}\*(?:\r?\n|\r)'

- extensions: ['.cs']

rules:

- language: Smalltalk

pattern: '![\w\s]+methodsFor: '

- language: 'C#'

pattern: '^\s*(using\s+[A-Z][\s\w.]+;|namespace\s*[\w\.]+\s*(\{|;)|\/\/)'

- extensions: ['.csc']

rules:

- language: GSC

named_pattern: gsc

- extensions: ['.csl']

rules:

- language: XML

pattern: '(?i:^\s*(<\?xml|xmlns))'

- language: Kusto

pattern: '(^\|\s*(where|extend|project|limit|summarize))|(^\.\w+)'

- extensions: ['.d']

rules:

- language: D

# see http://dlang.org/spec/grammar

# ModuleDeclaration | ImportDeclaration | FuncDeclaration | unittest

pattern: '^module\s+[\w.]*\s*;|import\s+[\w\s,.:]*;|\w+\s+\w+\s*\(.*\)(?:\(.*\))?\s*\{[^}]*\}|unittest\s*(?:\(.*\))?\s*\{[^}]*\}'

- language: DTrace

# see http://dtrace.org/guide/chp-prog.html, http://dtrace.org/guide/chp-profile.html, http://dtrace.org/guide/chp-opt.html

pattern: '^(\w+:\w*:\w*:\w*|BEGIN|END|provider\s+|(tick|profile)-\w+\s+\{[^}]*\}|#pragma\s+D\s+(option|attributes|depends_on)\s|#pragma\s+ident\s)'

- language: Makefile

# path/target : dependency \

# target : \

# : dependency

# path/file.ext1 : some/path/../file.ext2

pattern: '([\/\\].*:\s+.*\s\\$|: \\$|^[ %]:|^[\w\s\/\\.]+\w+\.\w+\s*:\s+[\w\s\/\\.]+\w+\.\w+)'

- extensions: ['.dsp']

rules:

- language: Microsoft Developer Studio Project

pattern: '# Microsoft Developer Studio Generated Build File'

- language: Faust

pattern: '\bprocess\s*[(=]|\b(library|import)\s*\(\s*"|\bdeclare\s+(name|version|author|copyright|license)\s+"'

- extensions: ['.e']

rules:

- language: E

pattern:

- '^\s*(def|var)\s+(.+):='

- '^\s*(def|to)\s+(\w+)(\(.+\))?\s+\{'

- '^\s*(when)\s+(\(.+\))\s+->\s+\{'

- language: Eiffel

pattern:

- '^\s*\w+\s*(?:,\s*\w+)*[:]\s*\w+\s'

- '^\s*\w+\s*(?:\(\s*\w+[:][^)]+\))?(?:[:]\s*\w+)?(?:--.+\s+)*\s+(?:do|local)\s'

- '^\s*(?:across|deferred|elseif|ensure|feature|from|inherit|inspect|invariant|note|once|require|undefine|variant|when)\s*$'

- language: Euphoria

named_pattern: euphoria

- extensions: ['.ecl']

rules:

- language: ECLiPSe

pattern: '^[^#]+:-'

- language: ECL

pattern: ':='

- extensions: ['.es']

rules:

- language: Erlang

pattern: '^\s*(?:%%|main\s*\(.*?\)\s*->)'

- language: JavaScript

pattern: '\/\/|["'']use strict["'']|export\s+default\s|\/\*(?:.|[\r\n])*?\*\/'

- extensions: ['.ex']

rules:

- language: Elixir

pattern:

- '^\s*@moduledoc\s'

- '^\s*(?:cond|import|quote|unless)\s'

- '^\s*def(?:exception|impl|macro|module|protocol)[(\s]'

- language: Euphoria

named_pattern: euphoria

- extensions: ['.f']

rules:

- language: Forth

pattern: '^: '

- language: Filebench WML

pattern: 'flowop'

- language: Fortran

named_pattern: fortran

- extensions: ['.for']

rules:

- language: Forth

pattern: '^: '

- language: Fortran

named_pattern: fortran

- extensions: ['.fr']

rules:

- language: Forth

pattern: '^(: |also |new-device|previous )'

- language: Frege

pattern: '^\s*(import|module|package|data|type) '

- language: Text

- extensions: ['.frm']

rules:

- language: VBA

and:

- named_pattern: vb-form

- pattern: '^\s*Begin\s+\{[0-9A-Z\-]*\}\s?'

- language: Visual Basic 6.0

and:

- named_pattern: vb-form

- pattern: '^\s*Begin\s+VB\.Form\s+'

- language: INI

pattern: '\ATYPE=VIEW'

- extensions: ['.fs']

rules:

- language: Forth

pattern: '^(: |new-device)'

- language: 'F#'

pattern: '^\s*(#light|import|let|module|namespace|open|type)'

- language: GLSL

pattern: '^\s*(#version|precision|uniform|varying|vec[234])'

- language: Filterscript

pattern: '#include|#pragma\s+(rs|version)|__attribute__'

- extensions: ['.ftl']

rules:

- language: FreeMarker

pattern: '^(?:<|[a-zA-Z-][a-zA-Z0-9_-]+[ \t]+\w)|\$\{\w+[^\r\n]*?\}|^[ \t]*(?:<#--.*?-->|<#(?:[a-z]+)\s[^>]*>.*?</#(?:[a-z]+)>|\[#--.*?--\]|\[#(?:[a-z]+)\s[^\]]*\].*?\[#(?:[a-z]+)\])'

- language: Fluent

pattern: '^-?[a-zA-Z][a-zA-Z0-9_-]* *=|\{\$-?[a-zA-Z][-\w]*(?:\.[a-zA-Z][-\w]*)?\}'

- extensions: ['.g']

rules:

- language: GAP

pattern: '\s*(Declare|BindGlobal|KeyDependentOperation|Install(Method|GlobalFunction)|SetPackageInfo)'

- language: G-code

pattern: '^[MG][0-9]+(?:\r?\n|\r)'

- extensions: ['.gd']

rules:

- language: GAP

pattern: '\s*(Declare|BindGlobal|KeyDependentOperation)'

- language: GDScript

pattern: '\s*(extends|var|const|enum|func|class|signal|tool|yield|assert|onready)'

- extensions: ['.gml']

rules:

- language: XML

pattern: '(?i:^\s*(<\?xml|xmlns))'

- language: Graph Modeling Language

pattern: '(?i:^\s*(graph|node)\s+\[$)'

- language: Gerber Image

pattern: '^[DGMT][0-9]{2}\*$'

- language: Game Maker Language

- extensions: ['.gs']

rules:

- language: GLSL

pattern: '^#version\s+[0-9]+\b'

- language: Gosu

pattern: '^uses (java|gw)\.'

- language: Genie

pattern: '^\[indent=[0-9]+\]'

- extensions: ['.gsc']

rules:

- language: GSC

named_pattern: gsc

- extensions: ['.gsh']

rules:

- language: GSC

named_pattern: gsc

- extensions: ['.gts']

rules:

- language: Gerber Image

pattern: '^G0.'

- language: Glimmer TS

negative_pattern: '^G0.'

- extensions: ['.h']

rules:

- language: Objective-C

named_pattern: objectivec

- language: C++

named_pattern: cpp

- language: C

- extensions: ['.hh']

rules:

- language: Hack

pattern: '<\?hh'

- extensions: ['.html']

rules:

- language: Ecmarkup

pattern: '<emu-(?:alg|annex|biblio|clause|eqn|example|figure|gann|gmod|gprose|grammar|intro|not-ref|note|nt|prodref|production|rhs|table|t|xref)(?:$|\s|>)'

- language: HTML

- extensions: ['.i']

rules:

- language: Motorola 68K Assembly

named_pattern: m68k

- language: SWIG

pattern: '^[ \t]*%[a-z_]+\b|^%[{}]$'

- language: Assembly

pattern:

- '(?i)mov\s+[^\s]+,'

- '^\s+(i?)db\s+[a-z\d]'

- extensions: ['.ice']

rules:

- language: JSON

named_pattern: json

- language: Slice

- extensions: ['.inc']

rules:

- language: Motorola 68K Assembly

named_pattern: m68k

- language: PHP

pattern: '^<\?(?:php)?'

- language: SourcePawn

pattern:

- '^public\s+(?:SharedPlugin(?:\s+|:)__pl_\w+\s*=(?:\s*\{)?|(?:void\s+)?__pl_\w+_SetNTVOptional\(\)(?:\s*\{)?)'

- '^methodmap\s+\w+\s+<\s+\w+'

- '^\s*MarkNativeAsOptional\s*\('

- language: NASL

pattern:

- '^\s*include\s*\(\s*(?:"|'')[\\/\w\-\.:\s]+\.(?:nasl|inc)\s*(?:"|'')\s*\)\s*;'

- '^\s*(?:global|local)_var\s+(?:\w+(?:\s*=\s*[\w\-"'']+)?\s*)(?:,\s*\w+(?:\s*=\s*[\w\-"'']+)?\s*)*\s*;'

- '^\s*namespace\s+\w+\s*\{'

- '^\s*object\s+\w+\s*(?:extends\s+\w+(?:::\w+)?)?\s*\{'

- '^\s*(?:public\s+|private\s+|\s*)function\s+\w+\s*\([\w\s,]*\)\s*\{'

- language: POV-Ray SDL

pattern: '^\s*#(declare|local|macro|while)\s'

- language: Pascal

pattern:

- '(?i:^\s*\{\$(?:mode|ifdef|undef|define)[ ]+[a-z0-9_]+\})'

- '^\s*end[.;]\s*$'

- language: BitBake

pattern: '^inherit(\s+[\w.-]+)+\s*$'

- language: Assembly

pattern:

- '^(?i)[^"m]*mov\s+[^\s]+,'

- '^\s+(?i)db\s+[a-z\d]'

- extensions: ['.json']

rules:

- language: OASv2-json

pattern: '"swagger":\s?"2.[0-9.]+"'

- language: OASv3-json

pattern: '"openapi":\s?"3.[0-9.]+"'

- language: JSON

- extensions: ['.k']

rules:

- language: KCL

pattern:

- '^schema [A-Za-z0-9_-]+'

- '^\}$'

- '\s*\}\s*'

- language: KFramework

pattern:

- '^requires\s+"[^"]+"$'

- '^syntax\s+\w+\s+::=.*'

- '^endmodule$'

- extensions: ['.l']

rules:

- language: Common Lisp

pattern: '\(def(un|macro)\s'

- language: Lex

pattern: '^(%[%{}]xs|<.*>)'

- language: Roff

pattern: '^\.[A-Za-z]{2}(\s|$)'

- language: PicoLisp

pattern: '^\((de|class|rel|code|data|must)\s'

- extensions: ['.lean']

rules:

- language: Lean

pattern: '^import [a-z]'

- language: Lean 4

pattern: '^import [A-Z]'

- extensions: ['.lp']

rules:

- language: Lambdapi

pattern: '(?:^|\s)symbol(?:$|\s)|(?:^|\s)rule(?:$|\s)'

- language: Linear Programming

pattern: '(?i)^\s*(?:minimize|minimum|min|maximize|maximum|max)(?:\s+multi-objectives)?\s*$'

- language: Answer Set Programming

pattern:

- '^\s*#(?:include|const|program|script|show|minimize|maximize|heuristic|project|edge|theory|defined)\b'

- '^\s*(?:[A-Za-z_]\w*(?:\([^)]*\))?\s*:-|:-)\s[^.]*\.'

- '^\s*[a-z_][a-zA-Z0-9_]*(?:\([^)]*\))?\s*\.\s*$'

- extensions: ['.ls']

rules:

- language: LoomScript

pattern: '^\s*package\s*[\w\.\/\*\s]*\s*\{'

- language: LiveScript

- extensions: ['.lsp', '.lisp']

rules:

- language: Common Lisp

pattern: '^\s*\((?i:defun|in-package|defpackage) '

- language: NewLisp

pattern: '^\s*\(define '

- extensions: ['.m']

rules:

- language: Objective-C

named_pattern: objectivec

- language: Mercury

pattern: ':- module'

- language: MUF

pattern: '^: '

- language: M

pattern: '^\s*;'

- language: Wolfram Language

and:

- pattern: '\(\*'

- pattern: '\*\)$'

- language: MATLAB

pattern: '^\s*%'

- language: Limbo

pattern: '^\w+\s*:\s*module\s*\{'

- extensions: ['.m4']

rules:

- language: M4Sugar

pattern:

- 'AC_DEFUN|AC_PREREQ|AC_INIT'

- '^_?m4_'

- language: 'M4'

- extensions: ['.mask']

rules:

- language: Unity3D Asset

pattern: 'tag:unity3d.com'

- extensions: ['.mc']

rules:

- language: Win32 Message File

pattern: '(?i)^[ \t]*(\/\*\s*)?MessageId=|^\.$'

- language: M4

pattern: '^dnl|^divert\((?:-?\d+)?\)|^\w+\(`[^\r\n]*?''[),]'

- language: Monkey C

pattern: '\b(?:using|module|function|class|var)\s+\w'

- extensions: ['.md']

rules:

- language: Markdown

pattern:

- '(^[-A-Za-z0-9=#!\*\[|>])|<\/'

- '\A\z'

- language: GCC Machine Description

pattern: '^(;;|\(define_)'

- language: Markdown

- extensions: ['.ml']

rules:

- language: OCaml

pattern: '(^\s*module)|let rec |match\s+(\S+\s)+with'

- language: Standard ML

pattern: '=> |case\s+(\S+\s)+of'

- extensions: ['.mod']

rules:

- language: XML

pattern: '<!ENTITY '

- language: NMODL

pattern: '\b(NEURON|INITIAL|UNITS)\b'

- language: Modula-2

pattern: '^\s*(?i:MODULE|END) [\w\.]+;'

- language: [Linux Kernel Module, AMPL]

- extensions: ['.mojo']

rules:

- language: Mojo

pattern: '^\s*(alias|def|from|fn|import|struct|trait)\s'

- language: XML

pattern: '^\s*<\?xml'

- extensions: ['.mps']

rules:

- language: JetBrains MPS

pattern: '<persistence'

- language: Mathematical Programming System

pattern: '(?i)^\s*(ROWS|COLUMNS)\s*$'

- extensions: ['.ms']

rules:

- language: Roff

pattern: '^[.''][A-Za-z]{2}(\s|$)'

- language: Unix Assembly

and:

- negative_pattern: '/\*'

- pattern: '^\s*\.(?:include\s|globa?l\s|[A-Za-z][_A-Za-z0-9]*:)'

- language: MAXScript

- extensions: ['.msg']

rules:

- language: OMNeT++ MSG

pattern: '^cplusplus\(?[\S]*\)?[\s]*\{?\{?|^namespace[\s]+([^.\s]*\.)*[^.\s]*;|^struct[\s]+[\S]+|^message[\s]+[\S]+(extends )?[\S]*[\s]*|^packet[\s]+[\S]+|^class[\s]+[\S]+(extends )?[\S]*[\s]*|^enum[\s]+[\S]+|^import ([^.\s]*\.)*[^.\s]*;'

- language: ROS Interface

and:

- pattern: '(?i)^[a-z]\w*(?:\/[a-z]\w*)?(?:<=\d+)?(?:\[(?:<=\d+)?\])?\s+\w+\b'

- negative_pattern: '^\s*[^\s@#\w-]'

- extensions: ['.n']

rules:

- language: Roff

pattern: '^[.'']'

- language: Nemerle

pattern: '^(module|namespace|using)\s'

- extensions: ['.ncl']

rules:

- language: XML

pattern: '^\s*<\?xml\s+version'

- language: Gerber Image

pattern: '^[DGMT][0-9]{2}\*(?:\r?\n|\r)'

- language: Nickel

pattern:

- '^let(?:\srec)?(?:\s[a-zA-Z_][a-zA-Z0-9_]*)?'

- '^import\s"[^"]+"\s+as\s'

- 'std\.[a-zA-Z_][a-zA-Z0-9_]*\.'

- language: Text

pattern: 'THE_TITLE'

- language: NCL

pattern:

- '^load "'

- '^begin$'

- '[0-9]\.$'

- '^;'

- extensions: ['.nl']

rules:

- language: NL

pattern: '^(b|g)[0-9]+ '

- language: NewLisp

- extensions: ['.nr']

rules:

- language: Roff

pattern: '^\.'

- language: Noir

- extensions: ['.nu']

rules:

- language: Nushell

pattern: '^\s*(import|export|module|def|let|let-env) '

- language: Nu

- extensions: ['.odin']

rules:

- language: Object Data Instance Notation

pattern: '(?:^|<)\s*[A-Za-z0-9_]+\s*=\s*<'

- language: Odin

pattern: 'package\s+\w+|\b(?:im|ex)port\s*"[\w:./]+"|\w+\s*::\s*(?:proc|struct)\s*\(|^\s*//\s'

- extensions: ['.p']

rules:

- language: Gnuplot

pattern:

- '^s?plot\b'

- '^set\s+(term|terminal|out|output|[xy]tics|[xy]label|[xy]range|style)\b'

- language: OpenEdge ABL

pattern:

- '(?i)\bDEFINE\s+(?:VARIABLE|TEMP-TABLE|BUFFER|QUERY|INPUT\s+PARAMETER|OUTPUT\s+PARAMETER)\b'

- '(?i)\bEND(?:\s+(?:PROCEDURE|FUNCTION|DO|FOR\s+EACH))?\.'

- extensions: ['.php']

rules:

- language: Hack

pattern: '<\?hh'

- language: PHP

pattern: '<\?[^h]'

- extensions: ['.pkl']

rules:

- language: Pkl

pattern:

- '^\s*(module|import|amends|extends|local|const|fixed|abstract|open|class|typealias|@\w+)\b'

- '^\s*[a-zA-Z0-9_$]+\s*(=|{|:)|^\s*`[^`]+`\s*(=|{|:)|for\s*\(|when\s*\('

- language: Pickle

- extensions: ['.pl']

rules:

- language: Prolog

pattern: '^[^#]*:-'

- language: Perl

and:

- negative_pattern: '^\s*use\s+v6\b'

- named_pattern: perl

- language: Raku

named_pattern: raku

- extensions: ['.plist']

rules:

- language: XML Property List

pattern: '^\s*(?:<\?xml\s|<!DOCTYPE\s+plist|<plist(?:\s+version\s*=\s*["'']\d+(?:\.\d+)?["''])?\s*>\s*$)'

- language: OpenStep Property List

- extensions: ['.plt']

rules:

- language: Prolog

pattern: '^\s*:-'

- extensions: ['.pm']

rules:

- language: Perl

and:

- negative_pattern: '^\s*use\s+v6\b'

- named_pattern: perl

- language: Raku

named_pattern: raku

- language: X PixMap

pattern: '^\s*\/\* XPM \*\/'

- extensions: ['.pod']

rules:

- language: Pod 6

pattern: '^[\s&&[^\r\n]]*=(comment|begin pod|begin para|item\d+)'

- language: Pod

- extensions: ['.pp']

rules:

- language: Pascal

pattern: '^\s*end[.;]'

- language: Puppet

pattern: '^\s+\w+\s+=>\s'

- extensions: ['.pro']

rules:

- language: Proguard

pattern: '^-(include\b.*\.pro$|keep\b|keepclassmembers\b|keepattributes\b)'

- language: Prolog

pattern: '^[^\[#]+:-'

- language: INI

pattern: 'last_client='

- language: QMake

and:

- pattern: HEADERS

- pattern: SOURCES

- language: IDL

pattern: '^\s*(?i:function|pro|compile_opt) \w[ \w,:]*$'

- extensions: ['.properties']

rules:

- language: INI

and:

- named_pattern: key_equals_value

- pattern: '^[;\[]'

- language: Java Properties

and:

- named_pattern: key_equals_value

- pattern: '^[#!]'

- language: INI

named_pattern: key_equals_value

- language: Java Properties

pattern: '^[^#!][^:]*:'

- extensions: ['.q']

rules:

- language: q

pattern: '((?i:[A-Z.][\w.]*:\{)|^\\(cd?|d|l|p|ts?) )'

- language: HiveQL

pattern: '(?i:SELECT\s+[\w*,]+\s+FROM|(CREATE|ALTER|DROP)\s(DATABASE|SCHEMA|TABLE))'

- extensions: ['.qs']

rules:

- language: Q#

pattern: '^((\/{2,3})?\s*(namespace|operation)\b)'

- language: Qt Script

pattern: '(\w+\.prototype\.\w+|===|\bvar\b)'

- extensions: ['.r']

rules:

- language: Rebol

pattern: '(?i:\bRebol\b)'

- language: Rez

pattern: '(#include\s+["<](Types\.r|Carbon\/Carbon\.r)[">])|((resource|data|type)\s+''[A-Za-z0-9]{4}''\s+((\(.*\)\s+){0,1}){)'

- language: R

pattern: '<-|^\s*#'

- extensions: ['.re']

rules:

- language: Reason

pattern:

- '^\s*module\s+type\s'

- '^\s*(?:include|open)\s+\w+\s*;\s*$'

- '^\s*let\s+(?:module\s\w+\s*=\s*\{|\w+:\s+.*=.*;\s*$)'

- language: C++

pattern:

- '^\s*#(?:(?:if|ifdef|define|pragma)\s+\w|\s*include\s+<[^>]+>)'

- '^\s*template\s*<'

- extensions: ['.res']

rules:

- language: ReScript

pattern:

- '^\s*(let|module|type)\s+\w*\s+=\s+'

- '^\s*(?:include|open)\s+\w+\s*$'

- extensions: ['.resource']

rules:

- language: RobotFramework

pattern:

- '^\*{3} (Settings|Variables|Keywords) \*{3}$'

- extensions: ['.rno']

rules:

- language: RUNOFF

pattern: '(?i:^\.!|^\f|\f$|^\.end lit(?:eral)?\b|^\.[a-zA-Z].*?;\.[a-zA-Z](?:[; \t])|\^\*[^\s*][^*]*\\\*(?:$|\s)|^\.c;[ \t]*\w+)'

- language: Roff

pattern: '^\.\\" '

- extensions: ['.rpy']

rules:

- language: Python

pattern: '^(import|from|class|def)\s'

- language: "Ren'Py"

- extensions: ['.rs']

rules:

- language: Rust

pattern: '^(use |fn |mod |pub |macro_rules|impl|#!?\[)'

- language: RenderScript

pattern: '#include|#pragma\s+(rs|version)|__attribute__'

- language: XML

pattern: '^\s*<\?xml'

- extensions: ['.s']

rules:

- language: Unix Assembly

pattern: '(?i:mov[lq]?)\s+[%\$]'

- language: Assembly

pattern: '(?i:mov)\s+[^\s%]{2,},'

- language: Motorola 68K Assembly

named_pattern: m68k

- extensions: ['.sc']

rules:

- language: SuperCollider

pattern: '(?i:\^(this|super)\.|^\s*~\w+\s*=\.)'

- language: Scala

pattern: '(^\s*import (scala|java)\.|^\s*class\b)'

- extensions: ['.scd']

rules:

- language: SuperCollider

pattern: '(?i:\^(this|super)\.|^\s*(~\w+\s*=\.|SynthDef\b))'

- language: Markdown

# Markdown syntax for scdoc

pattern: '^#+\s+(NAME|SYNOPSIS|DESCRIPTION)'

- extensions: ['.scm']

rules:

- language: Tree-sitter Query

pattern:

- '\(#[\w-]+[!\?]'

- '(?:[\)\]]\s*[\*\+\?](?:\s|$))'

- '(?:^\s*\w+:\s*[\(\[\"])'

- '\(#(?:set!|(?:not-)?(?:any-of|match)\?)'

- '@[\w.-]+(?:\)\s|$)'

negative_pattern:

- '\([+\-:<>\/=~\)]'

- language: Scheme

pattern:

- '(?:''[\(\*#]|\w->\w|\.\.\.[\s\)]|\([+\-:<>\/=~\)]|~>|[#`]\(|#:\w)'

- '^\s*\((?:define\*?|import|library|lambda)'

negative_pattern:

- '\(#[\w-]+[!\?]'

- '(?:[\)\]]\s*[\*\+\?](?:\s|$))'

- '@[\w.-]+(?:\)\s|$)'

- extensions: ['.sol']

rules:

- language: Solidity

pattern: '\bpragma\s+solidity\b|\b(?:abstract\s+)?contract\s+[a-zA-Z$_][a-zA-Z0-9$_]*(?:\s+is\s+(?:[a-zA-Z0-9$_][^\{]*?)?)?\s*\{'

- language: Gerber Image

pattern: '^[DGMT][0-9]{2}\*(?:\r?\n|\r)'

- extensions: ['.sql']

rules:

# Postgres

- language: PLpgSQL

pattern: '(?i:^\\i\b|AS\s+\$\$|LANGUAGE\s+''?plpgsql''?|BEGIN(\s+WORK)?\s*;)'

# IBM db2

- language: SQLPL

pattern: '(?i:ALTER\s+MODULE|MODE\s+DB2SQL|\bSYS(CAT|PROC)\.|ASSOCIATE\s+RESULT\s+SET|\bEND!\s*$)'

# Oracle

- language: PLSQL

pattern: '(?i:\$\$PLSQL_|XMLTYPE|systimestamp|\.nextval|CONNECT\s+BY|AUTHID\s+(DEFINER|CURRENT_USER)|constructor\W+function)'

# T-SQL

- language: TSQL

pattern: '(?i:^\s*GO\b|BEGIN(\s+TRY|\s+CATCH)|OUTPUT\s+INSERTED|DECLARE\s+@|\[dbo\])'

- language: SQL

- extensions: ['.srt']

rules:

- language: SubRip Text

pattern: '^(\d{2}:\d{2}:\d{2},\d{3})\s*(-->)\s*(\d{2}:\d{2}:\d{2},\d{3})$'

- extensions: ['.srv']

rules:

- language: ROS Interface

and:

- pattern: '(?i)^[a-z]\w*(?:\/[a-z]\w*)?(?:<=\d+)?(?:\[(?:<=\d+)?\])?\s+\w+\b'

- pattern: '^---\s*$'

- negative_pattern: '^\s*[^\s@#\w-]'

- extensions: ['.st']

rules:

- language: StringTemplate

pattern: '\$\w+[($]|.!\s*.+?\s*!.|<!\s*.+?\s*!>|\[!\s*.+?\s*!\]|\{!\s*.+?\s*!\}'

- language: Smalltalk

pattern: '\A\s*[\[{(^"''\w#]|[a-zA-Z_]\w*\s*:=\s*[a-zA-Z_]\w*|class\s*>>\s*[a-zA-Z_]\w*|^[a-zA-Z_]\w*\s+[a-zA-Z_]\w*:|^Class\s*\{|if(?:True|False):\s*\['

- extensions: ['.star']

rules:

- language: STAR

pattern: '^loop_\s*$'

- language: Starlark

- extensions: ['.stl']

rules:

- language: STL

pattern: '\A\s*solid(?:$|\s)[\s\S]*^endsolid(?:$|\s)'

- extensions: ['.svx']

rules:

- language: Survex data

pattern: '\A(;|\*[^*]+$)'

- language: mdsvex

- extensions: ['.sw']

rules:

- language: Sway

pattern: '^\s*(?:(?:abi|dep|fn|impl|mod|pub|trait)\s|#\[)'

- language: XML

pattern: '^\s*<\?xml\s+version'

- extensions: ['.t']

rules:

- language: Perl

and:

- negative_pattern: '^\s*use\s+v6\b'

- named_pattern: perl

- language: Raku

pattern: '^\s*(?:use\s+v6\b|\bmodule\b|\bmy\s+class\b)'

- language: Turing

pattern: '^\s*%[ \t]+|^\s*var\s+\w+(\s*:\s*\w+)?\s*:=\s*\w+'

- extensions: ['.tact']

rules:

- language: JSON

pattern: '\A\s*\{\"'

- language: Tact

- extensions: ['.tag']

rules:

- language: Java Server Pages

pattern: '<%[@!=\s]?\s*(taglib|tag|include|attribute|variable)\s'

- extensions: ['.tl']

rules:

- language: Teal

and:

- pattern: '--.*'

- pattern: '\b(local|function|end|record|interface|enum)\b'

- language: Type Language

- extensions: ['.tlv']

rules:

- language: TL-Verilog

pattern: '^\\.{0,10}TLV_version'

- extensions: ['.toc']

rules:

- language: World of Warcraft Addon Data

pattern: '^## |@no-lib-strip@'

- language: TeX

pattern: '^\\(contentsline|defcounter|beamer|boolfalse)'

- extensions: ['.tpl']

rules:

- language: Go Template

pattern: '\{\{-?\s*(\`?\"\\?\"?|\/\*\s|\w*)\b'

- language: Smarty

pattern: '(?<!\{)\{(\*\s|\$|\/)?\w*\b'

- extensions: ['.ts']

rules:

- language: XML

pattern: '<TS\b'

- language: TypeScript

- extensions: ['.tsp']

rules:

- language: TypeSpec

pattern: '^(import|using|namespace|interface|op|model|scalar|alias|union|enum)\s'

- language: TSPLIB data

pattern: '^(NAME|TYPE|DIMENSION|EDGE_WEIGHT_TYPE|EDGE_WEIGHT_FORMAT)\s*:'

- extensions: ['.tst']

rules:

- language: GAP

pattern: 'gap> '

# Heads up - we don't usually write heuristics like this (with no regex match)

- language: Scilab

- extensions: ['.tsx']

rules:

- language: XML

pattern: '(?i:^\s*<\?xml\s+version)'

- language: TSX

- extensions: ['.txt']

rules:

# The following RegExp is simply a collapsed and simplified form of the

# VIM_MODELINE pattern in `./lib/linguist/strategy/modeline.rb`.

- language: Vim Help File

pattern: '(?:(?:^|[ \t])(?:vi|Vi(?=m))(?:m[<=>]?[0-9]+|m)?|[ \t]ex)(?=:(?=[ \t]*set?[ \t][^\r\n:]+:)|:(?![ \t]*set?[ \t]))(?:(?:[ \t]*:[ \t]*|[ \t])\w*(?:[ \t]*=(?:[^\\\s]|\\.)*)?)*[ \t:](?:filetype|ft|syntax)[ \t]*=(help)(?=$|\s|:)'

- language: Hosts File

pattern: |-

(?xi) ^

# IPv4 address

(?<ipv4>

(?!\.)

(?:\.?

(?: 25[0-5] # 250-255

| 2[0-4]\d # 200-249

| 1\d\d # 100-199

| [1-9]?\d # 0-99

)\b

){4})

# CIDR notation: /[0-32]

(?<cidr>/(3[0-2]|[12]?\d)\b)?

# Domains list

(?<domains>

[ \t]+

\w[-\w]* (?:\.\w[-\w]*)*

(?<!-)\b

)*+

(?:$|\s)

- language: Adblock Filter List

pattern: |-

(?x)\A

\[

(?<version>

(?:

[Aa]d[Bb]lock

(?:[ \t][Pp]lus)?

|

u[Bb]lock

(?:[ \t][Oo]rigin)?

|

[Aa]d[Gg]uard

)

(?:[ \t] \d+(?:\.\d+)*+)?

)

(?:

[ \t]?;[ \t]?

\g<version>

)*+

\]

# HACK: This is a contrived use of heuristics needed to address

# an unusual edge-case. See https://git.io/JULye for discussion.

- language: Text

- extensions: ['.typ']