github-linguist 5.2.0 → 5.3.0

data/grammars/source.ne.json

@@ -0,0 +1,108 @@
+{
+  "fileTypes": [
+    "ne"
+  ],
+  "name": "nearley",
+  "patterns": [
+    {
+      "match": "@include|@builtin|@lexer",
+      "name": "keyword.control.ne"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "entity.name.type.ne"
+        },
+        "2": {
+          "name": "variable.parameter.ne"
+        },
+        "3": {
+          "name": "keyword.operator.ne"
+        }
+      },
+      "match": "([\\w+?]+)(\\[.+\\])?\\s+((-|=)+>)"
+    },
+    {
+      "match": "\\$[\\w+?]+",
+      "name": "variable.parameter.ne"
+    },
+    {
+      "match": "%[\\w+?]+",
+      "name": "storage.type.ne"
+    },
+    {
+      "match": "null",
+      "name": "constant.language.ne"
+    },
+    {
+      "begin": "([\\w+?]+\\[)",
+      "captures": {
+        "1": {
+          "name": "entity.name.function"
+        },
+        "2": {
+          "name": "entity.name.function"
+        }
+      },
+      "end": "(\\])",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "match": "[\\w+?]+",
+      "name": "entity.name.type.ne"
+    },
+    {
+      "match": "(\\|)|(:\\+)|(:\\*)|(:\\?)|(\\()|(\\))",
+      "name": "keyword.operator.ne"
+    },
+    {
+      "begin": "#",
+      "end": "\\n",
+      "name": "comment.line.ne"
+    },
+    {
+      "begin": "\\[",
+      "end": "\\]",
+      "name": "string.regex.ne",
+      "patterns": [
+        {
+          "match": "\\\\.",
+          "name": "constant.character.escape.ne"
+        }
+      ]
+    },
+    {
+      "begin": "\"",
+      "end": "\"",
+      "name": "string.quoted.double.ne",
+      "patterns": [
+        {
+          "match": "\\\\.",
+          "name": "constant.character.escape.ne"
+        }
+      ]
+    },
+    {
+      "begin": "(@?{%)",
+      "captures": {
+        "1": {
+          "name": "comment.block.ne"
+        },
+        "2": {
+          "name": "comment.block.ne"
+        }
+      },
+      "end": "(%})",
+      "patterns": [
+        {
+          "include": "source.js"
+        }
+      ]
+    }
+  ],
+  "scopeName": "source.ne"
+}

data/grammars/source.nim_filter.json

@@ -1,106 +1,106 @@
 {
+  "name": "Nim Source Code Filter",
+  "scopeName": "source.nim_filter",
   "fileTypes": [
     "nimf"
   ],
-  "name": "Nim Source Code Filter",
+  "uuid": "c6396a10-4bb4-4929-aee5-1d893828b098",
   "patterns": [
     {
-      "begin": "\\A(#!)",
-      "end": "\\z(!?\\n)",
       "name": "meta.start.nim_filter",
+      "begin": "\\A(#!)",
       "patterns": [
         {
-          "begin": "^\\s*#",
-          "end": "\\n",
           "name": "comment.line.nim_filter",
+          "begin": "^\\s*#",
           "patterns": [
             {
-              "match": "\\b((\\d[_\\d]*\\.[_\\d]+([eE][\\+\\-]?\\d[_\\d]*)?)|([eE][\\+\\-]?\\d[_\\d]*))('[fF](32|64))?",
-              "name": "constant.numeric.float.decimal.nim_filter"
+              "name": "constant.numeric.float.decimal.nim_filter",
+              "match": "\\b((\\d[_\\d]*\\.[_\\d]+([eE][\\+\\-]?\\d[_\\d]*)?)|([eE][\\+\\-]?\\d[_\\d]*))('[fF](32|64))?"
             },
             {
-              "match": "\\b(0[xX][0-9A-Fa-f][_0-9A-Fa-f]*)('[iIuU](8|16|32|64))?",
-              "name": "constant.numeric.integer.hexadecimal.nim_filter"
+              "name": "constant.numeric.integer.hexadecimal.nim_filter",
+              "match": "\\b(0[xX][0-9A-Fa-f][_0-9A-Fa-f]*)('[iIuU](8|16|32|64))?"
             },
             {
               "comment": "For simplicity's sake, we don't enforce floats only having 32 and 64 prefix types.",
-              "match": "\\b(0o[0-7][_0-7]*)('[iIuUfF](8|16|32|64))?",
-              "name": "constant.numeric.integer.octal.nim_filter"
+              "name": "constant.numeric.integer.octal.nim_filter",
+              "match": "\\b(0o[0-7][_0-7]*)('[iIuUfF](8|16|32|64))?"
             },
             {
-              "match": "\\b(0(b|B)[01][_01]*)('[iIuUfF](8|16|32|64))?",
-              "name": "constant.numeric.integer.binary.nim_filter"
+              "name": "constant.numeric.integer.binary.nim_filter",
+              "match": "\\b(0(b|B)[01][_01]*)('[iIuUfF](8|16|32|64))?"
             },
             {
-              "match": "\\b(\\d[_\\d]*)('[iIuUfF](8|16|32|64))?",
-              "name": "constant.numeric.integer.decimal.nim_filter"
+              "name": "constant.numeric.integer.decimal.nim_filter",
+              "match": "\\b(\\d[_\\d]*)('[iIuUfF](8|16|32|64))?"
             },
             {
               "comment": "Language Constants.",
-              "match": "\\b(true|false|inf|nil)\\b",
-              "name": "constant.language.nim_filter"
+              "name": "constant.language.nim_filter",
+              "match": "\\b(true|false|inf|nil)\\b"
             },
             {
               "comment": "Keywords that affect program control flow or scope.",
-              "match": "\\b(block|break|case|continue|do|elif|else|end|except|finally|for|if|raise|return|try|when|while|yield)\\b",
-              "name": "keyword.control.nim_filter"
+              "name": "keyword.control.nim_filter",
+              "match": "\\b(block|break|case|continue|do|elif|else|end|except|finally|for|if|raise|return|try|when|while|yield)\\b"
             },
             {
               "comment": "Keyword boolean operators for expressions.",
-              "match": "(\\b(and|in|is|isnot|not|notin|or|xor)\\b)",
-              "name": "keyword.operator.boolean.nim_filter"
+              "name": "keyword.operator.boolean.nim_filter",
+              "match": "(\\b(and|in|is|isnot|not|notin|or|xor)\\b)"
             },
             {
               "comment": "Generic operators for expressions.",
-              "match": "(\\b()\\b|(=|\\+|-|\\*|/|<|>|@|\\$|~|&|%|!|\\?|\\^|\\.|:|\\\\)+)",
-              "name": "keyword.operator.nim_filter"
+              "name": "keyword.operator.nim_filter",
+              "match": "(\\b()\\b|(=|\\+|-|\\*|/|<|>|@|\\$|~|&|%|!|\\?|\\^|\\.|:|\\\\)+)"
             },
             {
               "comment": "Other keywords.",
-              "match": "(\\b(addr|as|asm|atomic|bind|cast|concept|const|discard|distinct|div|enum|export|from|import|include|let|mod|object|of|ptr|ref|shl|shr|static|tuple|type|var)\\b)",
-              "name": "keyword.other.nim_filter"
+              "name": "keyword.other.nim_filter",
+              "match": "(\\b(addr|as|asm|atomic|bind|cast|concept|const|discard|distinct|div|enum|export|from|import|include|let|mod|object|of|ptr|ref|shl|shr|static|tuple|type|var)\\b)"
             },
             {
               "comment": "Invalid and unused keywords.",
-              "match": "(\\b(converter|generic|interface|lambda|mixin|out|shared|with|without)\\b)",
-              "name": "keyword.invalid.nim_filter"
+              "name": "keyword.invalid.nim_filter",
+              "match": "(\\b(converter|generic|interface|lambda|mixin|out|shared|with|without)\\b)"
             },
             {
               "comment": "Built-in, concrete types.",
-              "match": "\\b(((uint|int|float)(8|16|32|64)?)|bool|string|cstring|char|tobject|typedesc)\\b",
-              "name": "storage.type.concrete.nim_filter"
+              "name": "storage.type.concrete.nim_filter",
+              "match": "\\b(((uint|int|float)(8|16|32|64)?)|bool|string|cstring|char|tobject|typedesc)\\b"
             },
             {
               "comment": "Built-in, generic types.",
-              "match": "\\b(range|array|seq|natural|set|ref|ptr)\\b",
-              "name": "storage.type.generic.nim_filter"
+              "name": "storage.type.generic.nim_filter",
+              "match": "\\b(range|array|seq|natural|set|ref|ptr)\\b"
             },
             {
               "comment": "Function types",
-              "match": "\\b(proc|iterator|method|template|macro)\\b",
-              "name": "storage.type.function.nim_filter"
+              "name": "storage.type.function.nim_filter",
+              "match": "\\b(proc|iterator|method|template|macro)\\b"
             },
             {
               "comment": "Common functions",
-              "match": "\\b(echo|newException)\\b",
-              "name": "keyword.function.nim_filter"
+              "name": "keyword.function.nim_filter",
+              "match": "\\b(echo|newException)\\b"
             },
             {
               "comment": "Special types.",
-              "match": "\\b(openarray|varargs|void)\\b",
-              "name": "storage.type.generic.nim_filter"
+              "name": "storage.type.generic.nim_filter",
+              "match": "\\b(openarray|varargs|void)\\b"
             },
             {
-              "begin": "(\\w[_\\w]*)?\\\"\\\"\\\"",
               "comment": "(Raw) Triple Quoted String",
-              "end": "\\\"\\\"\\\"[^\"]",
-              "name": "string.quoted.triple.nim_filter"
+              "name": "string.quoted.triple.nim_filter",
+              "begin": "(\\w[_\\w]*)?\\\"\\\"\\\"",
+              "end": "\\\"\\\"\\\"[^\"]"
             },
             {
-              "begin": "r\\\"",
               "comment": "Raw Double Quoted String",
-              "end": "\\\"",
               "name": "string.quoted.double.raw.nim_filter",
+              "begin": "r\\\"",
+              "end": "\\\"",
               "patterns": [
                 {
                   "match": "\\\"\\\""
@@ -108,10 +108,10 @@
               ]
             },
             {
-              "begin": "(\\w[_\\w]*)?\\\"",
               "comment": "Double Quoted String",
-              "end": "\\\"",
               "name": "string.quoted.double.nim_filter",
+              "begin": "(\\w[_\\w]*)?\\\"",
+              "end": "\\\"",
               "patterns": [
                 {
                   "match": "(\\\\([abenrclftv]|[\"']|[0-9])|x[0-9A-Fa-f]{2})"
@@ -120,14 +120,14 @@
             },
             {
               "comment": "Single quoted character literal",
-              "match": "\\'(\\\\\\d{1,3}|\\\\?[^\\n]?)\\'",
-              "name": "string.quoted.single.nim_filter"
+              "name": "string.quoted.single.nim_filter",
+              "match": "\\'(\\\\\\d{1,3}|\\\\?[^\\n]?)\\'"
             }
-          ]
+          ],
+          "end": "\\n"
         }
-      ]
+      ],
+      "end": "\\z(!?\\n)"
     }
-  ],
-  "scopeName": "source.nim_filter",
-  "uuid": "c6396a10-4bb4-4929-aee5-1d893828b098"
+  ]
 }

data/grammars/source.nut.json

@@ -0,0 +1,266 @@
+{
+  "comment": "Squirrel Syntax: version 0.2.1",
+  "fileTypes": [
+    "nut"
+  ],
+  "name": "Squirrel",
+  "patterns": [
+    {
+      "include": "#special-block"
+    },
+    {
+      "include": "#comments"
+    },
+    {
+      "match": "\\b(break|case|catch|default|do|else|for|foreach|if|resume|return|switch|throw|try|while|yield)\\b",
+      "name": "keyword.control.squirrel"
+    },
+    {
+      "match": "\\b(clone|delete|in|instanceof|typeof)\\b",
+      "name": "keyword.control.squirrel"
+    },
+    {
+      "match": "\\b(base|this)\\b",
+      "name": "variable.language.squirrel"
+    },
+    {
+      "match": "\\b(class|constructor|function|local)\\b",
+      "name": "storage.type.squirrel"
+    },
+    {
+      "match": "\\b(const|extends|static)\\b",
+      "name": "storage.modifier.squirrel"
+    },
+    {
+      "match": "\\b(null|true|false)\\b",
+      "name": "constant.squirrel.squirrel"
+    },
+    {
+      "match": "!|%|&|\\*|\\-\\-|\\-|\\+\\+|\\+|==|=|!=|<=>|<=|>=|<-|>>>|<<|>>|<|>|!|&&|\\|\\||\\?\\:|\\*=|(?<!\\()/=|%=|\\+=|\\-=|&=|%=|\\.",
+      "name": "keyword.operator.squirrel"
+    },
+    {
+      "match": "\\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\\.[0-9]+)?))\\b",
+      "name": "constant.numeric.squirrel"
+    },
+    {
+      "match": "\\b([_A-Za-z][_A-Za-z0-9]\\w*)\\b(?=\\s*(?:[({\"']|\\[\\[))",
+      "name": "support.function.any-method.squirrel"
+    },
+    {
+      "match": "(?<=[^.]\\.)\\b([_A-Za-z][_A-Za-z0-9]\\w*)",
+      "name": "variable.other.squirrel"
+    },
+    {
+      "include": "#attributes"
+    },
+    {
+      "include": "#block"
+    },
+    {
+      "include": "#strings"
+    }
+  ],
+  "repository": {
+    "attributes": {
+      "begin": "</",
+      "end": "/>",
+      "name": "meta.attributes.squirrel",
+      "patterns": [
+        {
+          "include": "$base"
+        }
+      ]
+    },
+    "block": {
+      "patterns": [
+        {
+          "begin": "\\{",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.section.block.begin.bracket.curly.squirrel"
+            }
+          },
+          "end": "\\}",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.section.block.end.bracket.curly.squirrel"
+            }
+          },
+          "name": "meta.block.squirrel",
+          "patterns": [
+            {
+              "include": "$base"
+            }
+          ]
+        }
+      ]
+    },
+    "special-block": {
+      "patterns": [
+        {
+          "begin": "\\b(class)\\b\\s*([_A-Za-z][_A-Za-z0-9]*\\b)?+(\\s*(extends)\\s*([_A-Za-z][_A-Za-z0-9]*\\b))?",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.type.squirrel"
+            },
+            "2": {
+              "name": "entity.name.type.squirrel"
+            },
+            "4": {
+              "name": "storage.type.modifier.squirrel"
+            },
+            "5": {
+              "name": "entity.name.type.inherited.squirrel"
+            }
+          },
+          "end": "(?<=\\})|(?=(=))",
+          "name": "meta.class-block.squirrel",
+          "patterns": [
+            {
+              "include": "#block"
+            }
+          ]
+        },
+        {
+          "begin": "\\b(function)\\b\\s*([_A-Za-z][_A-Za-z0-9]*\\b)?+(\\s*(::)\\s*([_A-Za-z][_A-Za-z0-9]*\\b))?",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.type.squirrel"
+            },
+            "2": {
+              "name": "entity.name.type.squirrel"
+            },
+            "4": {
+              "name": "punctuation.separator.global.access.squirrel"
+            },
+            "5": {
+              "name": "entity.name.function.squirrel"
+            }
+          },
+          "end": "(?<=\\})|(?=(=))",
+          "name": "meta.function-block.squirrel",
+          "patterns": [
+            {
+              "include": "#block"
+            }
+          ]
+        },
+        {
+          "begin": "\\b([_A-Za-z][_A-Za-z0-9]*\\b)?+(\\s*(<-))",
+          "beginCaptures": {
+            "1": {
+              "name": "entity.name.type.squirrel"
+            },
+            "3": {
+              "name": "punctuation.separator.namespace.access.squirrel"
+            }
+          },
+          "end": "(?<=\\})|(?=(;|,|\\(|\\)|>|\\[|\\]|=))",
+          "name": "meta.namespace-block.squirrel",
+          "patterns": [
+            {
+              "include": "#block"
+            }
+          ]
+        }
+      ]
+    },
+    "comments": {
+      "patterns": [
+        {
+          "captures": {
+            "1": {
+              "name": "meta.toc-list.banner.block.squirrel"
+            }
+          },
+          "match": "^/\\* =(\\s*.*?)\\s*= \\*/$\\n?",
+          "name": "comment.block.squirrel"
+        },
+        {
+          "begin": "/\\*",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.comment.begin.squirrel"
+            }
+          },
+          "end": "\\*/",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.comment.end.squirrel"
+            }
+          },
+          "name": "comment.block.squirrel"
+        },
+        {
+          "begin": "(^[ \\t]+)?(?=//)",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.whitespace.comment.leading.squirrel"
+            }
+          },
+          "end": "(?!\\G)",
+          "patterns": [
+            {
+              "begin": "//",
+              "beginCaptures": {
+                "0": {
+                  "name": "punctuation.definition.comment.squirrel"
+                }
+              },
+              "end": "(?=\\n)",
+              "name": "comment.line.double-slash.squirrel"
+            }
+          ]
+        },
+        {
+          "begin": "(^[ \\t]+)?(?=#)",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.whitespace.comment.leading.squirrel"
+            }
+          },
+          "end": "(?!\\G)",
+          "patterns": [
+            {
+              "begin": "#",
+              "beginCaptures": {
+                "0": {
+                  "name": "punctuation.definition.comment.squirrel"
+                }
+              },
+              "end": "(?=\\n)",
+              "name": "comment.line.hash.squirrel"
+            }
+          ]
+        }
+      ]
+    },
+    "strings": {
+      "patterns": [
+        {
+          "begin": "@?\"",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.begin.squirrel"
+            }
+          },
+          "end": "\"",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.definition.string.end.squirrel"
+            }
+          },
+          "name": "string.quoted.double.squirrel",
+          "patterns": [
+            {
+              "match": "\\\\.",
+              "name": "constant.character.escape.squirrel"
+            }
+          ]
+        }
+      ]
+    }
+  },
+  "scopeName": "source.nut"
+}