Regenerate for linguist@9.2.0

* add `source.aiken`, `source.clue`, `source.daslang`, `source.koka`,
  `source.leo`, `source.m3u`, `source.sail`, `source.torrc`,
  `source.uplc`, `source.vento`, `source.zmodel`
* update a bunch of grammars

For more info, see:

* [`github-linguist/linguist@9.2.0`](https://github.com/github-linguist/linguist/releases/tag/v9.2.0)

Author: wooorm

lang/etc.js

@@ -30,6 +30,10 @@ const grammar = {
       match: '\\b(true|false|TRUE|FALSE)\\b',
       name: 'constant.logical.bool.boolean.${1:/downcase}'
     },
+    boolish: {
+      match: '(?i)\\b(true|false|yes|no|on|off)\\b',
+      name: 'constant.logical.bool.boolean.${1:/downcase}'
+    },
     bracket: {
       patterns: [
         {

lang/source.4dm.js

@@ -277,7 +277,7 @@ const grammar = {
       patterns: [
         {
           match:
-            '^\\n*[\\t ]*(?i)(If|While|Else|End if|For each|End for each|End for|Begin SQL|End SQL|while|End while|Use|End use|Case of|End case|Repeat|Until|For)\\b',
+            '^\\n*[\\t ]*(?i)(If|While|Else|End if|For each|End for each|End for|Begin SQL|End SQL|while|End while|Use|End use|Case of|End case|Repeat|Until|For|End try|Try|Catch|Throw|return|continue|break|property|var)\\b',
           name: 'keyword.control.4d'
         }
       ]

lang/source.QB64.js

@@ -19,7 +19,7 @@ const grammar = {
     'classic-quickbasic'
   ],
   patterns: [
-    {match: '\\n', name: 'meta.ending-space'},
+    {match: '\\r?\\n', name: 'meta.ending-space'},
     {include: '#round-brackets'},
     {
       begin: '^(?=\\t)',
@@ -58,7 +58,7 @@ const grammar = {
         5: {name: 'punctuation.definition.parameters.QB64'}
       },
       match:
-        '^\\s*((?i:function|sub))\\s*([a-zA-Z_]\\w*)\\s*(\\()([^)]*)(\\)).*\\n?',
+        '^\\s*((?i:function|sub))\\s*([a-zA-Z_]\\w*)\\s*(\\()([^)]*)(\\)).*\\r?\\n?',
       name: 'meta.function.QB64'
     },
     {
@@ -75,7 +75,7 @@ const grammar = {
         {
           begin: "'|",
           beginCaptures: {0: {name: 'punctuation.definition.comment.QB64'}},
-          end: '\\n',
+          end: '\\r?\\n',
           name: 'comment.line.apostrophe.QB64'
         }
       ]

lang/source.abl.js

@@ -0,0 +1,99 @@
+// This is a TextMate grammar distributed by `starry-night`.
+// This grammar is developed at
+// <https://github.com/aiken-lang/vscode-aiken>
+// and licensed `apache-2.0`.
+// See <https://github.com/wooorm/starry-night> for more info.
+/**
+ * @import {Grammar} from '@wooorm/starry-night'
+ */
+
+/** @type {Grammar} */
+const grammar = {
+  extensions: ['.ak'],
+  names: ['aiken'],
+  patterns: [
+    {include: '#comments'},
+    {include: '#keywords'},
+    {include: '#strings'},
+    {include: '#constant'},
+    {include: '#entity'}
+  ],
+  repository: {
+    binary_number: {
+      match: '\\b0b[0-1]+\\b',
+      name: 'constant.numeric.binary.aiken'
+    },
+    boolean: {
+      match: '\\b(True|False)\\b',
+      name: 'constant.language.boolean.aiken'
+    },
+    comments: {patterns: [{match: '//.*', name: 'comment.line.aiken'}]},
+    constant: {
+      patterns: [
+        {include: '#binary_number'},
+        {include: '#octal_number'},
+        {include: '#hexadecimal_number'},
+        {include: '#decimal_number'},
+        {include: '#boolean'},
+        {match: '[[:upper:]][[:word:]]*', name: 'entity.name.type.aiken'}
+      ]
+    },
+    decimal_number: {
+      match: '\\b[[:digit:]][[:digit:]_]*(\\.[[:digit:]]*)?\\b',
+      name: 'constant.numeric.decimal.aiken'
+    },
+    entity: {
+      patterns: [
+        {
+          begin: '\\b([[:lower:]][[:word:]]*)([[:space:]]*)?\\(',
+          captures: {1: {name: 'entity.name.function.aiken'}},
+          end: '\\)',
+          patterns: [{include: '$self'}]
+        },
+        {
+          match: '\\b([[:lower:]][[:word:]]*):\\s',
+          name: 'variable.parameter.aiken'
+        },
+        {
+          match: '\\b([[:lower:]][[:word:]]*):',
+          name: 'entity.name.namespace.aiken'
+        }
+      ]
+    },
+    hexadecimal_number: {
+      match: '\\b0x[[:xdigit:]]+\\b',
+      name: 'constant.numeric.hexadecimal.aiken'
+    },
+    keywords: {
+      patterns: [
+        {
+          match:
+            '\\b(if|else|when|is|fn|use|let|pub|type|opaque|const|todo|expect|test|bench|trace|fail|validator|and|or|as|via|once)\\b',
+          name: 'keyword.control.aiken'
+        },
+        {match: '->', name: 'keyword.operator.arrow.aiken'},
+        {match: '<-', name: 'keyword.operator.back_arrow.aiken'},
+        {match: '\\|>', name: 'keyword.operator.pipe.aiken'},
+        {match: '\\.\\.', name: 'keyword.operator.splat.aiken'},
+        {match: '(<=|>=|==|!=|<|>)', name: 'keyword.operator.comparison.aiken'},
+        {match: '(&&|\\|\\|)', name: 'keyword.operator.logical.aiken'},
+        {match: '\\|', name: 'keyword.operator.other.aiken'},
+        {match: '(\\+|\\-|/|\\*|%)', name: 'keyword.operator.arithmetic.aiken'},
+        {match: '=', name: 'keyword.operator.assignment.aiken'}
+      ]
+    },
+    octal_number: {
+      match: '\\b0o[0-7]+\\b',
+      name: 'constant.numeric.octal.aiken'
+    },
+    strings: {
+      begin: '"',
+      end: '"',
+      name: 'string.quoted.double.aiken',
+      patterns: [{match: '\\\\.', name: 'constant.character.escape.aiken'}]
+    }
+  },
+  scopeName: 'source.aiken'
+}
+
+export default grammar

lang/source.aiken.js

@@ -22,7 +22,6 @@ const grammar = {
     'annotation-declaration': {
       begin: '([@][_[:alpha:]]+)\\b',
       beginCaptures: {1: {name: 'storage.type.annotation.apex'}},
-      end: '(?<=\\)|$)',
       patterns: [
         {
           begin: '\\(',

lang/source.apex.js

@@ -517,7 +517,11 @@ const grammar = {
           },
           end: '(?=\\;)|(?=\\,)|(?=)(?=\\);)',
           name: 'meta.block.ballerina',
-          patterns: [{include: '#statements'}, {include: '#punctuation-comma'}]
+          patterns: [
+            {include: '#natural-expr'},
+            {include: '#statements'},
+            {include: '#punctuation-comma'}
+          ]
         },
         {match: '\\*', name: 'keyword.generator.asterisk.ballerina'}
       ]
@@ -733,6 +737,7 @@ const grammar = {
           match: '\\b(check|foreach|if|checkpanic)\\b',
           name: 'keyword.control.ballerina'
         },
+        {include: '#natural-expr'},
         {include: '#call'},
         {match: '\\b(var)\\b', name: 'support.type.primitive.ballerina'},
         {
@@ -1006,6 +1011,33 @@ const grammar = {
         {match: '\\|', name: 'keyword.operator.ballerina'}
       ]
     },
+    'natural-expr': {
+      patterns: [
+        {
+          begin: 'natural',
+          beginCaptures: {0: {name: 'keyword.other.ballerina'}},
+          end: '(?=\\})',
+          endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
+          patterns: [{include: '#natural-expr-body'}]
+        }
+      ]
+    },
+    'natural-expr-body': {
+      patterns: [
+        {
+          begin: '\\{',
+          beginCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
+          contentName: 'string.template.ballerina',
+          end: '(?=\\})',
+          endCaptures: {0: {name: 'punctuation.definition.block.ballerina'}},
+          patterns: [
+            {include: '#template-substitution-element'},
+            {include: '#string-character-escape'},
+            {include: '#templateVariable'}
+          ]
+        }
+      ]
+    },
     numbers: {
       patterns: [
         {

lang/source.ballerina.js

@@ -52,6 +52,7 @@ const grammar = {
     bsdoc: {
       patterns: [
         {include: '#bsdoc_param_and_type'},
+        {include: '#bsdoc_return_and_type'},
         {include: '#bsdoc_generic'}
       ]
     },
@@ -88,6 +89,25 @@ const grammar = {
       match:
         "(?i:\\s*(rem|'+)\\s*(@)(param|type)\\s+(?:(\\{)\\s*([^\\}]+)\\s*(\\}))?\\s*([a-z0-9_.]+)?(.*))"
     },
+    bsdoc_return_and_type: {
+      captures: {
+        1: {name: 'comment.line.apostrophe.brs'},
+        2: {
+          name: 'punctuation.definition.block.tag.bsdoc storage.type.class.bsdoc'
+        },
+        3: {
+          name: 'punctuation.definition.block.tag.bsdoc storage.type.class.bsdoc'
+        },
+        4: {name: 'punctuation.definition.bracket.curly.begin.bsdoc'},
+        5: {
+          name: ' comment.block.documentation.brs entity.name.type.instance.bsdoc'
+        },
+        6: {name: 'punctuation.definition.bracket.curly.end.bsdoc'},
+        7: {name: 'comment.block.documentation.brs'}
+      },
+      match:
+        "(?i:\\s*(rem|'+)\\s*(@)(return|returns)\\s+(?:(\\{)\\s*([^\\}]+)\\s*(\\}))?\\s*([a-z0-9_.]+.*)?)"
+    },
     class_declaration: {
       captures: {
         1: {name: 'keyword.other.class.brs'},
@@ -179,7 +199,6 @@ const grammar = {
         {include: '#try_catch'},
         {include: '#non_identifier_keywords'},
         {include: '#operators'},
-        {include: '#support_functions'},
         {include: '#variables_and_params'},
         {include: '#annotation'}
       ]
@@ -196,15 +215,20 @@ const grammar = {
       patterns: [
         {include: '#comment'},
         {include: '#annotation'},
-        {
-          begin: '(?i)\\s*\\b([a-z0-9_]+)(?:[ \\t]*(=))?',
-          beginCaptures: {
-            1: {name: 'variable.object.enummember.brs'},
-            2: {name: 'keyword.operator.assignment.brs'}
-          },
-          end: '\r?\n',
-          patterns: [{include: '#primitive_literal_expression'}]
-        }
+        {include: '#enum_field'}
+      ]
+    },
+    enum_field: {
+      begin: '(?i)\\s*\\b([a-z0-9_]+)(?:[ \\t]*(=))?',
+      beginCaptures: {
+        1: {name: 'variable.object.enummember.brs'},
+        2: {name: 'keyword.operator.assignment.brs'}
+      },
+      end: '\r?\n',
+      patterns: [
+        {include: '#primitive_literal_expression'},
+        {include: '#comment'},
+        {include: '#annotation'}
       ]
     },
     field: {
@@ -554,40 +578,6 @@ const grammar = {
       match:
         '(?i:\\b(boolean|integer|longinteger|float|double|string|object|function|sub|interface|dynamic|brsub|dim|const)\\b)'
     },
-    support_builtin_functions: {
-      match:
-        '(?i:\\b(GetLastRun(RuntimeError|CompileError)|Rnd|Box|Type|objfun|pos|eval)\\b)',
-      name: 'support.function.brs'
-    },
-    support_component_functions: {
-      match:
-        '(?i:\\b(R(ight|e(set(Index)?|ad(B(yte(IfAvailable)?|lock)|File|Line)?|move(Head|Tail|Index)))|Ge(nXML(Header)?|t(Res(ource|ponse(Headers|Code))|X|M(i(nute|llisecond)|o(nth|de(l)?)|essage)|B(yte(sPerBlock|Array)|o(o(tVersion(Number)?|lean)|dy))|S(t(orageCardInfo|a(ndards|tusByte)|ring(Count)?)|i(zeInMegabytes|gnedByte)|ource(Host|Identity|Port)|ub|ec(tionList|ond)|afe(X|Height|Y|Width))|H(o(stName|ur)|e(ight|ad))|Y(ear)?|N(extArticle|ame(dElements)?)|C(hildElements|ontrols|urrent(Standard|Con(trolValue|fig)|Input))|T(i(tle|me(Server|Zone))|o(String|File)|ext|ail)|I(n(t|dex|puts)|dentity)|ZoneDateTime|D(e(scription|vice(BootCount|Name|U(niqueId|ptime)))|a(y(OfWeek)?|ta))|U(se(dInMegabytes|rData)|tcDateTime)|Ent(ityEncode|ry)|V(ersion(Number)?|alue)|KeyList|F(ileSystemType|loat|a(ilureReason|mily)|reeInMegabytes)|W(holeState|idth)|LocalDateTime|Attributes))|M(id|D5|ap(StereoOutput(Aux)?|DigitalOutput))|Boolean|S(h(ift|ow)|canWiFi|t((Clear|Display)?|art|r(i(ng)?)?)|implify|ubtract(Milliseconds|Seconds)|e(nd(RawMessage|B(yte|lock)|Line)?|t(R(ollOverRegion|e(s(ize|olution)|c(tangle|eiveEol)))|X|M(i(n(imumTransferRate|ute)|llisecond)|o(nth|de(CaseSensitive)?)|ultiscreenBezel)|B(yteEventPort|o(olean|dy)|a(ckground(Bitmap|Color)|udRate))|S(t(andard|ring)|ub|e(ndEol|cond)|afeTextRegion)|H(o(stName|ur)|eight)|Y(ear)?|Name|C(hannelVolumes(Aux)?|ontrolValue|ursor(Bitmap|Pos(ition)?))|Time(Server|Zone)?|I(n(t|put)|P4(Gateway|Broadcast|Netmask|Address))|OutputState|D(HCP|omain|e(stination|fault(Mode|Transistion))|a(y(OfWeek)?|te(Time)?))|U(ser(Data|AndPassword)|tcDateTime|rl)|P(o(werSaveMode|rt)|assword|roxy)|E(ntry|cho|ol)|V(iewMode|olume(Aux)?)|F(o(nt|r(egroundColor|groundColor))|l(oat|ashRate))|W(holeState|i(dth|Fi(Passphrase|ESSID)))|L(ineEventPort|o(calDateTime|opMode)|auguage)|Audio(Mode(Aux)?|Stream(Aux)?|Output(Aux)?))|ek(Relative|ToEnd|Absolute)))|H(ide|ead|asAttribute)|N(ormalize|ext)|C(hr|ount|urrentPosition|l(s|ear(Region|Events)?))|T(o(Base64String|HexString|kenize|AsciiString)|estInter(netConnectivity|face)|rim)|I(s(MousePresent|N(ext|ame)|InputActive|Empty|Valid|LittleEndianCPU)|n(str|te(ger)|valid))|Object|D(ynamic|isplay(Preload|File(Ex)?)|o(uble|esExist)|elete)|U(n(shift|pack)|Case)|P(o(st(Message|From(String|File))|p(String(s)?)?)|ush(String)?|eek|lay(StaticImage|File)?|arse(String|File)?|reloadFile(Ex)?)|E(nable(R(ollover|egion)|Cursor|Input|Output)|xists)|Void|F(indIndex|unction|l(oat|ush)|rom(Base64String|HexString|AsciiString))|W(hile|aitMessage|rite(File)?)|L(ookup|e(n|ft))|A(s(ync(GetTo(String|File)|Head|PostFrom(String|File)|Flush)|c)?|tEof|dd(Re(ctangle(Region|_region)|place)|Milliseconds|BodyElement|Seconds|Head(er)?|CircleRegion|Tail|DNSServer|E(vent|lement(WithBody)?)|Attribute)|pp(end(String|File)?|ly))|ToStr)\\b)',
-      name: 'support.function.component.brs'
-    },
-    support_functions: {
-      patterns: [
-        {include: '#support_builtin_functions'},
-        {include: '#support_global_functions'},
-        {include: '#support_global_string_functions'},
-        {include: '#support_global_math_functions'},
-        {include: '#support_component_functions'}
-      ]
-    },
-    support_global_functions: {
-      match:
-        '(?i:\\b(Re(adAsciiFile|bootSystem)|GetInterface|MatchFiles|Sleep|C(opyFile|reate(Directory|Object))|Delete(Directory|File)|UpTime|FormatDrive|ListDir|W(ait|riteAsciiFile))\\b)',
-      name: 'support.function.brs'
-    },
-    support_global_math_functions: {
-      match:
-        '(?i:\\b(S(in|qr|gn)|C(sng|dbl|os)|Tan|Int|Exp|Fix|Log|A(tn|bs))\\b)',
-      name: 'support.function.brs'
-    },
-    support_global_string_functions: {
-      match:
-        '(?i:\\b(Right|Mid|Str(i(ng(i)?)?)?|Chr|Instr|UCase|Val|Asc|L(Case|e(n|ft)))\\b)',
-      name: 'support.function.brs'
-    },
     template_string: {
       begin: '(`)',
       beginCaptures: {1: {name: 'string.template.brs'}},

lang/source.brs.js

@@ -1,6 +1,6 @@
 // This is a TextMate grammar distributed by `starry-night`.
 // This grammar is developed at
-// <https://github.com/textmate/c.tmbundle>
+// <https://github.com/mikomikotaishi/c.tmbundle>
 // and licensed permissive.
 // See <https://github.com/wooorm/starry-night> for more info.
 /**
@@ -24,6 +24,7 @@ const grammar = {
     '.gml',
     '.h++',
     '.hh',
+    '.hip',
     '.hpp',
     '.hxx',
     '.inl',
@@ -44,6 +45,7 @@ const grammar = {
     'cpp',
     'edje-data-collection',
     'game-maker-language',
+    'hip',
     'metal',
     'swig'
   ],
@@ -79,26 +81,25 @@ const grammar = {
       match: '\\b(f|m)[A-Z]\\w*\\b',
       name: 'variable.other.readwrite.member.c++'
     },
-    {match: '\\b(this|nullptr)\\b', name: 'variable.language.c++'},
+    {match: '\\b(this)\\b', name: 'variable.language.c++'},
     {match: '\\b(template|concept)\\b\\s*', name: 'storage.type.template.c++'},
     {
-      match: '\\b(const_cast|dynamic_cast|reinterpret_cast|static_cast)\\b\\s*',
+      match:
+        '\\b(const_cast|dynamic_cast|reinterpret_cast|static_assert|static_cast)\\b\\s*',
       name: 'keyword.operator.cast.c++'
     },
     {
       match:
-        '\\b(co_await|co_return|co_yield|and|and_eq|bitand|bitor|compl|not|not_eq|or|or_eq|typeid|xor|xor_eq)\\b',
+        '\\b(and|and_eq|bitand|bitor|co_await|co_return|co_yield|compl|not|not_eq|or|or_eq|typeid|xor|xor_eq)\\b',
       name: 'keyword.operator.c++'
     },
-    {
-      match: '\\b(class|wchar_t|char8_t|char16_t|char32_t)\\b',
-      name: 'storage.type.c++'
-    },
+    {match: '\\b(class)\\b', name: 'storage.type.c++'},
     {
       match:
-        '\\b(consteval|constinit|constexpr|export|mutable|typename|thread_local|noexcept|final|override)\\b',
+        '\\b(alignas|alignof|consteval|constinit|constexpr|decltype|final|mutable|noexcept|override|requires|thread_local|typename)\\b',
       name: 'storage.modifier.c++'
     },
+    {match: '\\b(import|export|module)\\b', name: 'keyword.module.c++'},
     {
       begin:
         '(?x)\n    \t\t\t\t(?:  ^                                 # begin-of-line\n    \t\t\t\t  |  (?: (?<!else|new|=) )             #  or word + space before name\n    \t\t\t\t)\n    \t\t\t\t((?:[A-Za-z_][A-Za-z0-9_]*::)*+~[A-Za-z_][A-Za-z0-9_]*) # actual name\n    \t\t\t\t \\s*(\\()                           # start bracket or end-of-line\n    \t\t\t',