github-linguist 7.6.0 → 7.10.0

data/grammars/source.python.json

@@ -1720,6 +1720,9 @@
         {
           "include": "#lambda"
         },
+        {
+          "include": "#generator"
+        },
         {
           "include": "#illegal-operator"
         },
@@ -1735,6 +1738,9 @@
         {
           "include": "#list"
         },
+        {
+          "include": "#odd-function-call"
+        },
         {
           "include": "#round-braces"
         },
@@ -2605,6 +2611,25 @@
         }
       ]
     },
+    "generator": {
+      "begin": "\\bfor\\b",
+      "end": "\\bin\\b",
+      "patterns": [
+        {
+          "include": "#expression"
+        }
+      ],
+      "beginCaptures": {
+        "0": {
+          "name": "keyword.control.flow.python"
+        }
+      },
+      "endCaptures": {
+        "0": {
+          "name": "keyword.control.flow.python"
+        }
+      }
+    },
     "illegal-anno": {
       "name": "invalid.illegal.annotation.python",
       "match": "-\u003e"
@@ -2760,6 +2785,7 @@
           "include": "#special-names"
         },
         {
+          "name": "meta.indexed-name.python",
           "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
         }
       ]
@@ -2979,6 +3005,7 @@
       }
     },
     "member-access": {
+      "name": "meta.member.access.python",
       "begin": "(\\.)\\s*(?!\\.)",
       "end": "(?x)\n  # stop when you've just read non-whitespace followed by non-word\n  # i.e. when finished reading an identifier or function call\n  (?\u003c=\\S)(?=\\W) |\n  # stop when seeing the start of something that's not a word,\n  # i.e. when seeing a non-identifier\n  (^|(?\u003c=\\s))(?=[^\\\\\\w\\s]) |\n  $\n",
       "patterns": [
@@ -2987,6 +3014,9 @@
         },
         {
           "include": "#member-access-base"
+        },
+        {
+          "include": "#member-access-attribute"
         }
       ],
       "beginCaptures": {
@@ -2995,6 +3025,10 @@
         }
       }
     },
+    "member-access-attribute": {
+      "name": "meta.attribute.python",
+      "match": "(?x)\n  \\b ([[:alpha:]_]\\w*) \\b\n"
+    },
     "member-access-base": {
       "patterns": [
         {
@@ -3018,6 +3052,7 @@
       ]
     },
     "member-access-class": {
+      "name": "meta.member.access.python",
       "begin": "(\\.)\\s*(?!\\.)",
       "end": "(?\u003c=\\S)(?=\\W)|$",
       "patterns": [
@@ -3124,6 +3159,20 @@
         }
       }
     },
+    "odd-function-call": {
+      "begin": "(?x)\n  (?\u003c= \\] | \\) ) \\s*\n  (?=\\()\n",
+      "end": "(\\))",
+      "patterns": [
+        {
+          "include": "#function-arguments"
+        }
+      ],
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.arguments.end.python"
+        }
+      }
+    },
     "operator": {
       "match": "(?x)\n    \\b(?\u003c!\\.)\n      (?:\n        (and | or | not | in | is)                         (?# 1)\n        |\n        (for | if | else | await | (?:yield(?:\\s+from)?))  (?# 2)\n      )\n    (?!\\s*:)\\b\n\n    | (\u003c\u003c | \u003e\u003e | \u0026 | \\| | \\^ | ~)                          (?# 3)\n\n    | (\\*\\* | \\* | \\+ | - | % | // | / | @)                (?# 4)\n\n    | (!= | == | \u003e= | \u003c= | \u003c | \u003e)                          (?# 5)\n",
       "captures": {
@@ -4709,6 +4758,9 @@
         {
           "include": "#function-declaration"
         },
+        {
+          "include": "#generator"
+        },
         {
           "include": "#statement-keyword"
         },

data/grammars/source.q.json

@@ -1,65 +1,133 @@
 {
-  "name": "q",
+  "name": "q/kdb",
   "scopeName": "source.q",
   "patterns": [
     {
-      "name": "comment.block.source.q",
-      "begin": "/\n",
-      "end": "\\\\\n"
+      "name": "comment.block.q",
+      "begin": "^\\s*/\\s*$\\n",
+      "end": "^\\s*\\\\\\s*$\\n"
     },
     {
-      "name": "comment.line.source.q",
-      "match": "\\s/.*|^/.*"
+      "name": "comment.block.q",
+      "begin": "^\\\\\\s*\\n",
+      "end": "'As far as I know, there is no way to exit this kind of block comment'"
     },
     {
-      "name": "comment.block.source.q",
-      "begin": "\\\\\n",
-      "end": "\\\\\n"
+      "name": "comment.line.q",
+      "match": "\\s/.+$\\n?|^/.+$\\n"
     },
     {
-      "name": "other.source.q",
-      "match": "(?=(\\W|\\b))((\\.Q\\.\\w+)|(\\.z\\.\\w+)|(\\\\\\w+))(?=(\\W|\\b))",
-      "captures": {
+      "name": "string.quoted.string.source.q",
+      "begin": "\"",
+      "end": "\"",
+      "patterns": [
+        {
+          "name": "constant.numeric.complex.source.q",
+          "match": "\\\\[trn\\\\\\\"]"
+        },
+        {
+          "name": "constant.numeric.complex.source.q",
+          "match": "\\\\[0-9]{3}"
+        },
+        {
+          "name": "message.error.q",
+          "match": "\\\\[0-9]{1,2}"
+        }
+      ]
+    },
+    {
+      "name": "string.interpolated.symbol.q",
+      "match": "(`:[:/a-zA-Z0-9_.]*)|(`[:a-zA-Z0-9_.]*)"
+    },
+    {
+      "begin": "(?=(\\W|\\b))(\\.[a-zA-Z]+[a-zA-Z0-9_]*)(\\.[a-zA-Z0-9_]*)*\\s*\\[(?=.*\\]\\s*([,+\\-*%@$!?\u003c\u003e=~|\u0026\\#]?)(::|:))",
+      "end": "\\]([,+\\-*%@$!?\u003c\u003e=~|\u0026\\#]?)(::|:)",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ],
+      "beginCaptures": {
         "2": {
-          "name": "support.function.q"
+          "name": "variable.parameter.complex.namespace_dict_assign.q"
+        },
+        "3": {
+          "name": "variable.parameter.complex.namespace_dict_assign.q"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "support.function.assignment.q"
+        },
+        "2": {
+          "name": "support.function.assignment.q"
         }
       }
     },
     {
-      "name": "string.quoted.string.source.q",
-      "match": "\".*?\""
+      "name": "variable.parameter.complex.namespace_assignment.q",
+      "match": "(?=(\\W|\\b))(\\.[a-zA-Z]+[a-zA-Z0-9_]*)(\\.[a-zA-Z0-9_]*)*\\s*([,+\\-*%@$!?\u003c\u003e=~|\u0026\\#]?)(::|:)",
+      "captures": {
+        "4": {
+          "name": "support.function.assignment.q"
+        },
+        "5": {
+          "name": "support.function.assignment.q"
+        }
+      }
+    },
+    {
+      "name": "support.function.namespace.q",
+      "match": "\\.[qQhkozj]\\.\\w+"
     },
     {
-      "name": "string.interpolated.symbol.source.q",
-      "match": "`[:/a-zA-Z0-9_.]+"
+      "name": "source.other_namespaces.q",
+      "match": "(?=(\\W|\\b))(\\.[a-zA-Z]+[a-zA-Z0-9_]*)(\\.[a-zA-Z0-9_]*)*(?=(\\W|\\b))"
     },
     {
-      "name": "other.source.q",
-      "match": "(?=([^a-zA-Z0-9]|\\b))(\\.?[a-zA-Z]+[a-zA-Z0-9_\\.]*\\s*)(:)\\s*",
+      "name": "other.assignment.q",
+      "match": "(?=([^a-zA-Z0-9]|\\b))([a-zA-Z]+[a-zA-Z0-9_]*)\\s*([,+\\-*%@$!?\u003c\u003e=~|\u0026\\#]?)(::|:)",
       "captures": {
         "2": {
-          "name": "variable.parameter.complex.source.q"
+          "name": "variable.parameter.complex.assignment.q"
         },
         "3": {
           "name": "support.function.q"
+        },
+        "4": {
+          "name": "support.function.q"
         }
       }
     },
     {
-      "name": "support.function.q",
-      "match": "[!$@\\\\/_#?|',`(\\\\:)]"
-    },
-    {
-      "name": "support.function.q",
-      "match": "\\.(?=\\W)"
+      "begin": "(?=([^a-zA-Z0-9]|\\b))([a-zA-Z]+[a-zA-Z0-9_]*)\\s*\\[(?=.*\\]\\s*([,+\\-*%@$!?\u003c\u003e=~|\u0026\\#]?)(::|:))",
+      "end": "\\]([,+\\-*%@$!?\u003c\u003e=~|\u0026\\#]?)(::|:)",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ],
+      "beginCaptures": {
+        "2": {
+          "name": "variable.parameter.complex.dict_assign.q"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "support.function.assignment.q"
+        },
+        "2": {
+          "name": "support.function.assignment.q"
+        }
+      }
     },
     {
       "contentName": "meta.function.parameters.q",
       "begin": "(\\{\\s*\\[)",
-      "end": "(?=\\]\\s*)",
+      "end": "]",
       "patterns": [
         {
-          "match": "\\b([a-zA-Z_][a-zA-Z_0-9]*)\\s*(?:(;)|(?=[\\]\\)]))",
+          "match": "\\b([a-zA-Z_][a-zA-Z0-9_]*)\\s*(?:(;)|(?=[\\]\\)]))",
           "captures": {
             "1": {
               "name": "entity.other.inherited-class.q"
@@ -72,49 +140,68 @@
       ]
     },
     {
-      "name": "other.source.q",
-      "match": "(?=(\\W|\\b))(prd|while|wavg|delete|min|like|exp|abs|insert|wsum|last|log|div|cos|sin|sqrt|max|in|exec|within|xexp|avg|second|hour|minute|update|sum|by|from|select|neg|not|null|string|reciprocal|floor|ceiling|signum|mod|xbar|xlog|and|or|each|scan|over|prior|mmu|lsq|inv|md5|ltime|gtime|count|first|var|dev|med|cov|cor|all|any|rand|sums|prds|mins|maxs|fills|deltas|ratios|avgs|differ|prev|next|rank|reverse|iasc|idesc|asc|desc|msum|mcount|mavg|mdev|xrank|mmin|mmax|xprev|rotate|distinct|group|where|flip|type|key|til|get|value|attr|cut|set|upsert|raze|union|inter|except|cross|sv|vs|sublist|enlist|read0|read1|hopen|hclose|hdel|hsym|hcount|peach|system|ltrim|rtrim|trim|lower|upper|ssr|view|tables|views|cols|xcols|keys|xkey|xcol|xasc|xdesc|fkeys|meta|lj|aj|aj0|ij|pj|asof|uj|ww|wj|wj1|fby|xgroup|ungroup|ej|save|load|rsave|rload|show|csv|parse|eval)(?=(\\W|\\b))",
-      "captures": {
-        "2": {
-          "name": "keyword.other.complex.source.q"
-        }
-      }
+      "name": "keyword.other.complex.keyword.q",
+      "match": "(?=(\\W|\\b))(abs|acos|aj|aj0|all|and|any|asc|asin|asof|atan|attr|avg|avgs|bin|binr|by|ceiling|cols|cor|cos|count|cov|cross|csv|cut|delete|deltas|desc|dev|differ|distinct|div|do|dsave|each|ej|ema|enlist|eval|except|exec|exit|exp|fby|fills|first|fkeys|flip|floor|from|get|getenv|group|gtime|hclose|hcount|hdel|hopen|hsym|iasc|idesc|if|ij|ijf|in|insert|inter|inv|key|keys|last|like|lj|ljf|load|log|lower|lsq|ltime|ltrim|mavg|max|maxs|mcount|md5|mdev|med|meta|min|mins|mmax|mmin|mmu|mod|msum|neg|next|not|null|or|over|parse|peach|pj|prd|prds|prev|prior|rand|rank|ratios|raze|read0|read1|reciprocal|reval|reverse|rload|rotate|rsave|rtrim|save|scan|scov|sdev|select|set|setenv|show|signum|sin|sqrt|ss|ssr|string|sublist|sum|sums|sv|svar|system|tables|tan|til|trim|type|uj|ujf|ungroup|union|update|upper|upsert|value|var|view|views|vs|wavg|where|while|within|wj|wj1|wsum|xasc|xbar|xcol|xcols|xdesc|xexp|xgroup|xkey|xlog|xprev|xrank)(?=(\\W|\\b))"
     },
     {
-      "name": "other.source.q",
-      "match": "(?=(\\W|\\b))([0-9]{4}\\.[0-9]{2}\\.[0-9]{2}[TD]?[0-9]{2}:[0-9]{2}:[0-9]{2}(:[0-9]{2})?(\\.[0-9]{3,6})?)(?=(\\W|\\b))",
-      "captures": {
-        "2": {
-          "name": "constant.numeric.complex.source.q"
-        }
-      }
+      "name": "constant.numeric.complex.timestamp.q",
+      "match": "(?=(\\W|\\b))([0-9]{4}\\.[0-9]{2}\\.[0-9]{2}D[0-9]{2}(:[0-5][0-9]){0,2}(\\.[0-9]{3}([a-zA-CE-SU-Z0-9]*[ABCEFGHIJKLMNOPQRSUVWXYZagklnopqrtuvwxy0-9])?|\\.[0-9]*|:)?)(?=(\\W|\\b))"
     },
     {
-      "name": "other.source.q",
-      "match": "(?=(\\W|\\b))([0-9]{4}\\.[0-9]{2}\\.[0-9]{2}[TD]?)(?=(\\W|\\b))",
-      "captures": {
-        "2": {
-          "name": "constant.numeric.complex.source.q"
-        }
-      }
+      "name": "constant.numeric.complex.datetime.q",
+      "match": "(?=(\\W|\\b))([0-9]{4}\\.[0-9]{2}\\.[0-9]{2}T[0-9]{2}(:[0-5][0-9]){0,2}(\\.[0-9]{3}([a-zA-CE-Z0-9]*[ABCEFGHIJKLMNOPQRSUVWXYZagklnopqrtuvwxy0-9])?|\\.[0-9]*|:)?)(?=(\\W|\\b))"
     },
     {
-      "name": "other.source.q",
-      "match": "(?=(\\W|\\b))([0-9]{2}:[0-9]{2}:[0-9]{2}(:[0-9]{2})?(\\.[0-9]{3,6})?)(?=(\\W|\\b))",
-      "captures": {
-        "2": {
-          "name": "constant.numeric.complex.source.q"
-        }
-      }
+      "name": "constant.numeric.complex.timespan.q",
+      "match": "(?=(\\W|\\b))(([0-9]{1,6}D([0-9]{1,2})((:[0-5][0-9]){0,2}|:)(\\.[0-9]{0,9}[a-zA-Z0-9]*[A-Zacgklnopqrtuvwxy0-9])?)|([0-9]{2}:[0-5][0-9](:[0-5][0-9]\\.[0-9]{4,}|:[0-5][0-9]\\.[0-9]{9,}[a-zA-Z0-9]*[ABCEFGHIJKLMNOPQRSUVWXYZagklnopqrtuvwxy0-9])|\\.[0-9]{8,}))(?=(\\W|\\b))"
     },
     {
-      "name": "other.source.q",
-      "match": "(?=(\\W|\\b))([-]?[0-9]+[bhijef]{0,1}(\\.[0-9]+[m]?)?|0x[a-f0-9]+)(?=(\\W|\\b))",
-      "captures": {
-        "2": {
-          "name": "constant.numeric.complex.source.q"
-        }
-      }
+      "name": "constant.numeric.complex.time.q",
+      "match": "(?=(\\W|\\b))([0-9]{2}:[0-5][0-9]((:[0-9]{2}(((([ABCEFGHIJKLMNOPQRSUVWXYZacgklnopqrtuvwxy0-9:]){1,2})?([0-5][0-9]){1,2})|\\.[0-9]{3}[ABCEFGHIJKLMNOPQRSUVWXYZacgklnopqrtuvwxy0-9]?|\\.[0-9]{0,3}))|\\.[0-9]{4,7}))(?=(\\W|\\b))"
+    },
+    {
+      "name": "constant.numeric.complex.second.q",
+      "match": "(?=(\\W|\\b))([0-9]{2}:[0-5][0-9]([0-5][0-9]([0-5][0-9])?|\\.[0-9]{2}|:[0-9]{2}|([a-zA-Z]){0,2}[0-5][0-9]))(?=(\\W|\\b))"
+    },
+    {
+      "name": "constant.numeric.complex.minute.q",
+      "match": "(?=(\\W|\\b))([0-9]{2}:([0-5][0-9]([ABCEFGHIJKLMNOPQRSUVWXYZacgklnopqrtuvwxy0-9:])?)?)(?=(\\W|\\b))"
+    },
+    {
+      "name": "constant.numeric.complex.date.q",
+      "match": "(?=(\\W|\\b))([0-9]{4}\\.[0-9]{2}\\.[0-9]{2})(?=(\\W|\\b))"
+    },
+    {
+      "name": "constant.numeric.complex.month.q",
+      "match": "(?=(\\W|\\b))([0-9]{4,}\\.([0][1-9]|[1][0-2])m)(?=(\\W|\\b))"
+    },
+    {
+      "name": "support.function.io.q",
+      "match": "0:|1:|2:"
+    },
+    {
+      "name": "constant.numeric.complex.q",
+      "match": "(?=(\\W|\\b))([-]?[0-9]+[bhijf]?(\\.[0-9]+[m]?)?|0x[a-fA-F0-9]+)(?=(\\W|\\b)|_)"
+    },
+    {
+      "name": "constant.numeric.complex.real.q",
+      "match": "(?=(\\W|\\b))([-]?[0-9]+e[-]?[0-9]+)(?=(\\W|\\b))"
+    },
+    {
+      "name": "constant.numeric.complex.null.q",
+      "match": "(?=(\\W|\\b))(0n|0N[ghijepmdznuvt]?)(?=(\\W|\\b))"
+    },
+    {
+      "name": "constant.numeric.complex.inf.q",
+      "match": "(?=(\\W|\\b))(0w|0W[hijepdznuvt]?)(?=(\\W|\\b))"
+    },
+    {
+      "name": "support.function.q",
+      "match": "[!$@\\\\/_#?|',`\\\\:]"
+    },
+    {
+      "name": "support.function.q",
+      "match": "\\.(?=\\W)"
     }
   ]
 }

data/grammars/source.qasm.json

@@ -0,0 +1,66 @@
+{
+  "name": "QASM",
+  "scopeName": "source.qasm",
+  "patterns": [
+    {
+      "name": "comment.line.double-slash",
+      "match": "\\/\\/.*$"
+    },
+    {
+      "name": "comment.line.number-sign",
+      "match": "#.*$"
+    },
+    {
+      "name": "entity.name.function",
+      "match": "^(?x)                                  # At beggining of line\n(\\.)                                  # Valid function name\n(\n  (?: [-a-zA-Z_0-9]|[^\\x00-\\x7F]     # Valid identifier characters\n    | \\\\(?:[0-9a-fA-F]{1,6}|.)       # Escape sequence\n  )+\n)                                      # Followed by either:\n(?= $                                  # - End of the line\n  | [\\s,.\\#)\\[:{\u003e+~|]               # - Another selector\n  | #                                  # - A comment\n)"
+    },
+    {
+      "name": "entity.name.section",
+      "match": "(?x)\\b(include|OPENQASM|version)\\b"
+    },
+    {
+      "name": "variable.language",
+      "match": "(?x)\\b(qubit|qubits|map)\\b"
+    },
+    {
+      "name": "constant.other",
+      "match": "(?\u003c=(\\w\\[)|(:))( *\\d *)(?=(\\s*\\])|(:))"
+    },
+    {
+      "name": "keyword.storage.modifier",
+      "match": "-\u003e"
+    },
+    {
+      "name": "constant.string.single",
+      "match": "('.*')"
+    },
+    {
+      "name": "constant.string.double",
+      "match": "\".*\""
+    },
+    {
+      "name": "storage.type",
+      "match": "(?x)^\\b(?:(qreg|creg)| (gate|opaque))\\b"
+    },
+    {
+      "name": "support.function",
+      "match": "(?x)\\b(?:(prep_x|prep_y|prep_z|error_model)| (measure_x|measure_y|measure_z|measure_all|measure_parity|measure)| (display|display_binary))\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?i)(?x)\\b(?:((i|h|x|y|z)| (rx|ry|rz)| (x90|y90|z90|rx90|ry90|rz90|mx90|my90|mz90)| (x180|y180|z180|rx180|ry180|rz180|mx180|my180|mz180)| (u1|u2|u3|cu1|cu2|cu3)| (s|sdag|t|tdag)| (cnot|cx|cz|cr|crk|toffoli|ccx|ccnot)| (swap) ))\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?i)(?x)\\bc-(?:((i|h|x|y|z)| (rx|ry|rz)| (x90|y90|z90|rx90|ry90|rz90|mx90|my90|mz90)| (x180|y180|z180|rx180|ry180|rz180|mx180|my180|mz180)| (u1|u2|u3)| (s|sdag|t|tdag)| (cnot|cx|cz|cr|crk|toffoli|ccx|ccnot)| (swap) ))\\b"
+    },
+    {
+      "name": "keyword.control",
+      "match": "(?i)(?x)\\b(?:(not )|(if(?=[( ])))\\b"
+    },
+    {
+      "name": "variable.language",
+      "match": "\\b(depolarizing_channel|load_state|barrier)\\b"
+    }
+  ]
+}

data/grammars/source.ql.json

@@ -0,0 +1,1408 @@
+{
+  "name": "QL",
+  "scopeName": "source.ql",
+  "patterns": [
+    {
+      "include": "#module-member"
+    }
+  ],
+  "repository": {
+    "abstract": {
+      "name": "storage.modifier.abstract.ql",
+      "match": "(?x)\\b(?:abstract)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "and": {
+      "name": "keyword.other.and.ql",
+      "match": "(?x)\\b(?:and)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "annotation": {
+      "patterns": [
+        {
+          "include": "#bindingset-annotation"
+        },
+        {
+          "include": "#language-annotation"
+        },
+        {
+          "include": "#pragma-annotation"
+        },
+        {
+          "include": "#annotation-keyword"
+        }
+      ]
+    },
+    "annotation-keyword": {
+      "patterns": [
+        {
+          "include": "#abstract"
+        },
+        {
+          "include": "#bindingset"
+        },
+        {
+          "include": "#cached"
+        },
+        {
+          "include": "#deprecated"
+        },
+        {
+          "include": "#external"
+        },
+        {
+          "include": "#final"
+        },
+        {
+          "include": "#language"
+        },
+        {
+          "include": "#library"
+        },
+        {
+          "include": "#override"
+        },
+        {
+          "include": "#pragma"
+        },
+        {
+          "include": "#private"
+        },
+        {
+          "include": "#query"
+        },
+        {
+          "include": "#transient"
+        }
+      ]
+    },
+    "any": {
+      "name": "keyword.quantifier.any.ql",
+      "match": "(?x)\\b(?:any)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "arithmetic-operator": {
+      "name": "keyword.operator.arithmetic.ql",
+      "match": "(?x)\\+|-|\\*|/|%"
+    },
+    "as": {
+      "name": "keyword.other.as.ql",
+      "match": "(?x)\\b(?:as)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "asc": {
+      "name": "keyword.order.asc.ql",
+      "match": "(?x)\\b(?:asc)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "at-lower-id": {
+      "match": "(?x)@[a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "avg": {
+      "name": "keyword.aggregate.avg.ql",
+      "match": "(?x)\\b(?:avg)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "bindingset": {
+      "name": "storage.modifier.bindingset.ql",
+      "match": "(?x)\\b(?:bindingset)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "bindingset-annotation": {
+      "name": "meta.block.bindingset-annotation.ql",
+      "begin": "(?x)((?:\\b(?:bindingset)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?! \\s | (?:// | /\\*) | \\[ ) | (?\u003c=\\])",
+      "patterns": [
+        {
+          "include": "#bindingset-annotation-body"
+        },
+        {
+          "include": "#non-context-sensitive"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#bindingset"
+            }
+          ]
+        }
+      }
+    },
+    "bindingset-annotation-body": {
+      "name": "meta.block.bindingset-annotation-body.ql",
+      "begin": "(?x)((?:\\[))",
+      "end": "(?x)((?:\\]))",
+      "patterns": [
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "variable.parameter.ql",
+          "match": "(?x)(?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#open-bracket"
+            }
+          ]
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#close-bracket"
+            }
+          ]
+        }
+      }
+    },
+    "boolean": {
+      "name": "keyword.type.boolean.ql",
+      "match": "(?x)\\b(?:boolean)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "by": {
+      "name": "keyword.order.by.ql",
+      "match": "(?x)\\b(?:by)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "cached": {
+      "name": "storage.modifier.cached.ql",
+      "match": "(?x)\\b(?:cached)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "class": {
+      "name": "keyword.other.class.ql",
+      "match": "(?x)\\b(?:class)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "class-body": {
+      "name": "meta.block.class-body.ql",
+      "begin": "(?x)((?:\\{))",
+      "end": "(?x)((?:\\}))",
+      "patterns": [
+        {
+          "include": "#class-member"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#open-brace"
+            }
+          ]
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#close-brace"
+            }
+          ]
+        }
+      }
+    },
+    "class-declaration": {
+      "name": "meta.block.class-declaration.ql",
+      "begin": "(?x)((?:\\b(?:class)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?\u003c= \\} | ; )",
+      "patterns": [
+        {
+          "include": "#class-body"
+        },
+        {
+          "include": "#extends-clause"
+        },
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "entity.name.type.class.ql",
+          "match": "(?x)(?:\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#class"
+            }
+          ]
+        }
+      }
+    },
+    "class-member": {
+      "patterns": [
+        {
+          "include": "#predicate-or-field-declaration"
+        },
+        {
+          "include": "#annotation"
+        },
+        {
+          "include": "#non-context-sensitive"
+        }
+      ]
+    },
+    "close-brace": {
+      "name": "punctuation.curlybrace.close.ql",
+      "match": "(?x)\\}"
+    },
+    "close-bracket": {
+      "name": "punctuation.squarebracket.close.ql",
+      "match": "(?x)\\]"
+    },
+    "close-paren": {
+      "name": "punctuation.parenthesis.close.ql",
+      "match": "(?x)\\)"
+    },
+    "comma": {
+      "name": "punctuation.separator.comma.ql",
+      "match": "(?x),"
+    },
+    "comment": {
+      "patterns": [
+        {
+          "name": "comment.block.documentation.ql",
+          "begin": "(?x)/\\*\\*",
+          "end": "(?x)\\*/",
+          "patterns": [
+            {
+              "begin": "(?x)(?\u003c=/\\*\\*)([^*]|\\*(?!/))*$",
+              "while": "(?x)(^|\\G)\\s*([^*]|\\*(?!/))(?=([^*]|[*](?!/))*$)",
+              "patterns": [
+                {
+                  "name": "keyword.tag.ql",
+                  "match": "(?x)\\G\\s* (@\\S+)"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "name": "comment.block.ql",
+          "begin": "(?x)/\\*",
+          "end": "(?x)\\*/"
+        },
+        {
+          "name": "comment.line.double-slash.ql",
+          "match": "(?x)//.*$"
+        }
+      ]
+    },
+    "comment-start": {
+      "match": "(?x)// | /\\*"
+    },
+    "comparison-operator": {
+      "name": "keyword.operator.comparison.ql",
+      "match": "(?x)=|\\!-"
+    },
+    "concat": {
+      "name": "keyword.aggregate.concat.ql",
+      "match": "(?x)\\b(?:concat)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "count": {
+      "name": "keyword.aggregate.count.ql",
+      "match": "(?x)\\b(?:count)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "date": {
+      "name": "keyword.type.date.ql",
+      "match": "(?x)\\b(?:date)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "deprecated": {
+      "name": "storage.modifier.deprecated.ql",
+      "match": "(?x)\\b(?:deprecated)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "desc": {
+      "name": "keyword.order.desc.ql",
+      "match": "(?x)\\b(?:desc)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "dont-care": {
+      "name": "variable.language.dont-care.ql",
+      "match": "(?x)\\b(?:_)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "dot": {
+      "name": "punctuation.accessor.ql",
+      "match": "(?x)\\."
+    },
+    "dotdot": {
+      "name": "punctuation.operator.range.ql",
+      "match": "(?x)\\.\\."
+    },
+    "else": {
+      "name": "keyword.other.else.ql",
+      "match": "(?x)\\b(?:else)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "end-of-as-clause": {
+      "match": "(?x)(?: (?\u003c=(?:[0-9A-Za-z_])) (?!(?:[0-9A-Za-z_])) (?\u003c!(?\u003c!(?:[0-9A-Za-z_]))as)) | (?=\\s* (?!(?:// | /\\*) | (?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))) \\S) | (?=\\s* (?:(?:(?:\\b(?:_)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:and)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:any)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:as)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:asc)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:avg)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:boolean)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:by)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:class)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:concat)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:count)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:date)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:desc)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:else)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:exists)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:extends)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:false)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:float)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:forall)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:forex)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:from)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:if)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:implies)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:import)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:in)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:instanceof)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:int)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:max)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:min)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:module)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:newtype)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:none)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:not)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:or)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:order)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:predicate)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:rank)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:result)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:select)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictconcat)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictcount)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictsum)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:string)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:sum)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:super)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:then)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:this)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:true)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:where)(?:(?!(?:[0-9A-Za-z_])))))))"
+    },
+    "end-of-id": {
+      "match": "(?x)(?!(?:[0-9A-Za-z_]))"
+    },
+    "exists": {
+      "name": "keyword.quantifier.exists.ql",
+      "match": "(?x)\\b(?:exists)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "expr-as-clause": {
+      "name": "meta.block.expr-as-clause.ql",
+      "begin": "(?x)((?:\\b(?:as)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?:(?: (?\u003c=(?:[0-9A-Za-z_])) (?!(?:[0-9A-Za-z_])) (?\u003c!(?\u003c!(?:[0-9A-Za-z_]))as)) | (?=\\s* (?!(?:// | /\\*) | (?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))) \\S) | (?=\\s* (?:(?:(?:\\b(?:_)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:and)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:any)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:as)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:asc)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:avg)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:boolean)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:by)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:class)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:concat)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:count)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:date)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:desc)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:else)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:exists)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:extends)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:false)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:float)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:forall)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:forex)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:from)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:if)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:implies)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:import)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:in)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:instanceof)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:int)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:max)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:min)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:module)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:newtype)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:none)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:not)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:or)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:order)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:predicate)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:rank)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:result)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:select)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictconcat)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictcount)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictsum)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:string)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:sum)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:super)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:then)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:this)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:true)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:where)(?:(?!(?:[0-9A-Za-z_]))))))))",
+      "patterns": [
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "variable.other.ql",
+          "match": "(?x)(?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#as"
+            }
+          ]
+        }
+      }
+    },
+    "extends": {
+      "name": "keyword.other.extends.ql",
+      "match": "(?x)\\b(?:extends)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "extends-clause": {
+      "name": "meta.block.extends-clause.ql",
+      "begin": "(?x)((?:\\b(?:extends)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?= \\{ )",
+      "patterns": [
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "entity.name.type.ql",
+          "match": "(?x)(?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))|(?:@[a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#extends"
+            }
+          ]
+        }
+      }
+    },
+    "external": {
+      "name": "storage.modifier.external.ql",
+      "match": "(?x)\\b(?:external)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "false": {
+      "name": "constant.language.boolean.false.ql",
+      "match": "(?x)\\b(?:false)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "final": {
+      "name": "storage.modifier.final.ql",
+      "match": "(?x)\\b(?:final)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "float": {
+      "name": "keyword.type.float.ql",
+      "match": "(?x)\\b(?:float)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "float-literal": {
+      "name": "constant.numeric.decimal.ql",
+      "match": "(?x)-?[0-9]+\\.[0-9]+(?![0-9])"
+    },
+    "forall": {
+      "name": "keyword.quantifier.forall.ql",
+      "match": "(?x)\\b(?:forall)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "forex": {
+      "name": "keyword.quantifier.forex.ql",
+      "match": "(?x)\\b(?:forex)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "from": {
+      "name": "keyword.other.from.ql",
+      "match": "(?x)\\b(?:from)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "from-section": {
+      "name": "meta.block.from-section.ql",
+      "begin": "(?x)((?:\\b(?:from)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?= (?:\\b(?:select)(?:(?!(?:[0-9A-Za-z_])))) | (?:\\b(?:where)(?:(?!(?:[0-9A-Za-z_])))) )",
+      "patterns": [
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "variable.parameter.ql",
+          "match": "(?x)(?:\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))(?=\\s*(?:,|(?:\\b(?:where)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:select)(?:(?!(?:[0-9A-Za-z_]))))|$))"
+        },
+        {
+          "include": "#module-qualifier"
+        },
+        {
+          "name": "entity.name.type.ql",
+          "match": "(?x)(?:\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))|(?:@[a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        },
+        {
+          "name": "variable.parameter.ql",
+          "match": "(?x)(?:\\b [a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#from"
+            }
+          ]
+        }
+      }
+    },
+    "id-character": {
+      "match": "(?x)[0-9A-Za-z_]"
+    },
+    "if": {
+      "name": "keyword.other.if.ql",
+      "match": "(?x)\\b(?:if)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "implies": {
+      "name": "keyword.other.implies.ql",
+      "match": "(?x)\\b(?:implies)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "import": {
+      "name": "keyword.other.import.ql",
+      "match": "(?x)\\b(?:import)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "import-as-clause": {
+      "name": "meta.block.import-as-clause.ql",
+      "begin": "(?x)((?:\\b(?:as)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?:(?: (?\u003c=(?:[0-9A-Za-z_])) (?!(?:[0-9A-Za-z_])) (?\u003c!(?\u003c!(?:[0-9A-Za-z_]))as)) | (?=\\s* (?!(?:// | /\\*) | (?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))) \\S) | (?=\\s* (?:(?:(?:\\b(?:_)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:and)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:any)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:as)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:asc)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:avg)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:boolean)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:by)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:class)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:concat)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:count)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:date)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:desc)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:else)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:exists)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:extends)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:false)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:float)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:forall)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:forex)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:from)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:if)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:implies)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:import)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:in)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:instanceof)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:int)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:max)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:min)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:module)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:newtype)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:none)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:not)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:or)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:order)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:predicate)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:rank)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:result)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:select)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictconcat)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictcount)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictsum)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:string)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:sum)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:super)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:then)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:this)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:true)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:where)(?:(?!(?:[0-9A-Za-z_]))))))))",
+      "patterns": [
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "entity.name.type.namespace.ql",
+          "match": "(?x)(?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#as"
+            }
+          ]
+        }
+      }
+    },
+    "import-directive": {
+      "name": "meta.block.import-directive.ql",
+      "begin": "(?x)((?:\\b(?:import)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_])))) (?!\\s*(\\.|\\:\\:))",
+      "patterns": [
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "entity.name.type.namespace.ql",
+          "match": "(?x)(?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#import"
+            }
+          ]
+        }
+      },
+      "endCaptures": {
+        "0": {
+          "name": "entity.name.type.namespace.ql"
+        }
+      }
+    },
+    "in": {
+      "name": "keyword.other.in.ql",
+      "match": "(?x)\\b(?:in)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "instanceof": {
+      "name": "keyword.other.instanceof.ql",
+      "match": "(?x)\\b(?:instanceof)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "int": {
+      "name": "keyword.type.int.ql",
+      "match": "(?x)\\b(?:int)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "int-literal": {
+      "name": "constant.numeric.decimal.ql",
+      "match": "(?x)-?[0-9]+(?![0-9])"
+    },
+    "keyword": {
+      "patterns": [
+        {
+          "include": "#dont-care"
+        },
+        {
+          "include": "#and"
+        },
+        {
+          "include": "#any"
+        },
+        {
+          "include": "#as"
+        },
+        {
+          "include": "#asc"
+        },
+        {
+          "include": "#avg"
+        },
+        {
+          "include": "#boolean"
+        },
+        {
+          "include": "#by"
+        },
+        {
+          "include": "#class"
+        },
+        {
+          "include": "#concat"
+        },
+        {
+          "include": "#count"
+        },
+        {
+          "include": "#date"
+        },
+        {
+          "include": "#desc"
+        },
+        {
+          "include": "#else"
+        },
+        {
+          "include": "#exists"
+        },
+        {
+          "include": "#extends"
+        },
+        {
+          "include": "#false"
+        },
+        {
+          "include": "#float"
+        },
+        {
+          "include": "#forall"
+        },
+        {
+          "include": "#forex"
+        },
+        {
+          "include": "#from"
+        },
+        {
+          "include": "#if"
+        },
+        {
+          "include": "#implies"
+        },
+        {
+          "include": "#import"
+        },
+        {
+          "include": "#in"
+        },
+        {
+          "include": "#instanceof"
+        },
+        {
+          "include": "#int"
+        },
+        {
+          "include": "#max"
+        },
+        {
+          "include": "#min"
+        },
+        {
+          "include": "#module"
+        },
+        {
+          "include": "#newtype"
+        },
+        {
+          "include": "#none"
+        },
+        {
+          "include": "#not"
+        },
+        {
+          "include": "#or"
+        },
+        {
+          "include": "#order"
+        },
+        {
+          "include": "#predicate"
+        },
+        {
+          "include": "#rank"
+        },
+        {
+          "include": "#result"
+        },
+        {
+          "include": "#select"
+        },
+        {
+          "include": "#strictconcat"
+        },
+        {
+          "include": "#strictcount"
+        },
+        {
+          "include": "#strictsum"
+        },
+        {
+          "include": "#string"
+        },
+        {
+          "include": "#sum"
+        },
+        {
+          "include": "#super"
+        },
+        {
+          "include": "#then"
+        },
+        {
+          "include": "#this"
+        },
+        {
+          "include": "#true"
+        },
+        {
+          "include": "#where"
+        }
+      ]
+    },
+    "language": {
+      "name": "storage.modifier.language.ql",
+      "match": "(?x)\\b(?:language)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "language-annotation": {
+      "name": "meta.block.language-annotation.ql",
+      "begin": "(?x)((?:\\b(?:language)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?! \\s | (?:// | /\\*) | \\[ ) | (?\u003c=\\])",
+      "patterns": [
+        {
+          "include": "#language-annotation-body"
+        },
+        {
+          "include": "#non-context-sensitive"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#language"
+            }
+          ]
+        }
+      }
+    },
+    "language-annotation-body": {
+      "name": "meta.block.language-annotation-body.ql",
+      "begin": "(?x)((?:\\[))",
+      "end": "(?x)((?:\\]))",
+      "patterns": [
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "storage.modifier.ql",
+          "match": "(?x)\\b(?:monotonicAggregates)(?:(?!(?:[0-9A-Za-z_])))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#open-bracket"
+            }
+          ]
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#close-bracket"
+            }
+          ]
+        }
+      }
+    },
+    "library": {
+      "name": "storage.modifier.library.ql",
+      "match": "(?x)\\b(?:library)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "literal": {
+      "patterns": [
+        {
+          "include": "#float-literal"
+        },
+        {
+          "include": "#int-literal"
+        },
+        {
+          "include": "#string-literal"
+        }
+      ]
+    },
+    "lower-id": {
+      "match": "(?x)\\b [a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "max": {
+      "name": "keyword.aggregate.max.ql",
+      "match": "(?x)\\b(?:max)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "min": {
+      "name": "keyword.aggregate.min.ql",
+      "match": "(?x)\\b(?:min)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "module": {
+      "name": "keyword.other.module.ql",
+      "match": "(?x)\\b(?:module)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "module-body": {
+      "name": "meta.block.module-body.ql",
+      "begin": "(?x)((?:\\{))",
+      "end": "(?x)((?:\\}))",
+      "patterns": [
+        {
+          "include": "#module-member"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#open-brace"
+            }
+          ]
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#close-brace"
+            }
+          ]
+        }
+      }
+    },
+    "module-declaration": {
+      "name": "meta.block.module-declaration.ql",
+      "begin": "(?x)((?:\\b(?:module)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?\u003c=\\}|;)",
+      "patterns": [
+        {
+          "include": "#module-body"
+        },
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "entity.name.type.namespace.ql",
+          "match": "(?x)(?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#module"
+            }
+          ]
+        }
+      }
+    },
+    "module-member": {
+      "patterns": [
+        {
+          "include": "#import-directive"
+        },
+        {
+          "include": "#import-as-clause"
+        },
+        {
+          "include": "#module-declaration"
+        },
+        {
+          "include": "#class-declaration"
+        },
+        {
+          "include": "#select-clause"
+        },
+        {
+          "include": "#predicate-or-field-declaration"
+        },
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "include": "#annotation"
+        }
+      ]
+    },
+    "module-qualifier": {
+      "name": "entity.name.type.namespace.ql",
+      "match": "(?x)(?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_])))) (?=\\s*\\:\\:)"
+    },
+    "newtype": {
+      "name": "keyword.other.newtype.ql",
+      "match": "(?x)\\b(?:newtype)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "newtype-branch": {
+      "name": "meta.block.newtype-branch.ql",
+      "begin": "(?x)(?:\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))",
+      "end": "(?x)(?\u003c=\\}) | (?! \\s | (?:// | /\\*) | \\{ )",
+      "patterns": [
+        {
+          "include": "#predicate-body"
+        },
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "entity.name.type.ql",
+          "match": "(?x)(?:\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "0": {
+          "name": "entity.name.type.ql"
+        }
+      }
+    },
+    "newtype-declaration": {
+      "name": "meta.block.newtype.ql",
+      "begin": "(?x)((?:\\b(?:newtype)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?! \\s | (?:\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_])))) | (?:// | /\\*) | \\= | \\( )",
+      "patterns": [
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "include": "#newtype-branch"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#newtype"
+            }
+          ]
+        }
+      }
+    },
+    "non-context-sensitive": {
+      "patterns": [
+        {
+          "include": "#comment"
+        },
+        {
+          "include": "#literal"
+        },
+        {
+          "include": "#operator-or-punctuation"
+        },
+        {
+          "include": "#keyword"
+        }
+      ]
+    },
+    "none": {
+      "name": "keyword.quantifier.none.ql",
+      "match": "(?x)\\b(?:none)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "not": {
+      "name": "keyword.other.not.ql",
+      "match": "(?x)\\b(?:not)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "open-brace": {
+      "name": "punctuation.curlybrace.open.ql",
+      "match": "(?x)\\{"
+    },
+    "open-bracket": {
+      "name": "punctuation.squarebracket.open.ql",
+      "match": "(?x)\\["
+    },
+    "open-paren": {
+      "name": "punctuation.parenthesis.open.ql",
+      "match": "(?x)\\("
+    },
+    "operator-or-punctuation": {
+      "patterns": [
+        {
+          "include": "#relational-operator"
+        },
+        {
+          "include": "#comparison-operator"
+        },
+        {
+          "include": "#arithmetic-operator"
+        },
+        {
+          "include": "#comma"
+        },
+        {
+          "include": "#semicolon"
+        },
+        {
+          "include": "#dot"
+        },
+        {
+          "include": "#dotdot"
+        },
+        {
+          "include": "#pipe"
+        },
+        {
+          "include": "#open-paren"
+        },
+        {
+          "include": "#close-paren"
+        },
+        {
+          "include": "#open-brace"
+        },
+        {
+          "include": "#close-brace"
+        },
+        {
+          "include": "#open-bracket"
+        },
+        {
+          "include": "#close-bracket"
+        }
+      ]
+    },
+    "or": {
+      "name": "keyword.other.or.ql",
+      "match": "(?x)\\b(?:or)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "order": {
+      "name": "keyword.order.order.ql",
+      "match": "(?x)\\b(?:order)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "override": {
+      "name": "storage.modifier.override.ql",
+      "match": "(?x)\\b(?:override)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "pipe": {
+      "name": "punctuation.separator.pipe.ql",
+      "match": "(?x)\\|"
+    },
+    "pragma": {
+      "name": "storage.modifier.pragma.ql",
+      "match": "(?x)\\b(?:pragma)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "pragma-annotation": {
+      "name": "meta.block.pragma-annotation.ql",
+      "begin": "(?x)((?:\\b(?:pragma)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?! \\s | (?:// | /\\*) | \\[ ) | (?\u003c=\\])",
+      "patterns": [
+        {
+          "include": "#pragma-annotation-body"
+        },
+        {
+          "include": "#non-context-sensitive"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#pragma"
+            }
+          ]
+        }
+      }
+    },
+    "pragma-annotation-body": {
+      "name": "meta.block.pragma-annotation-body.ql",
+      "begin": "(?x)((?:\\[))",
+      "end": "(?x)((?:\\]))",
+      "patterns": [
+        {
+          "name": "storage.modifier.ql",
+          "match": "(?x)\\b(?:inline|noinline|nomagic|noopt)\\b"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#open-bracket"
+            }
+          ]
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#close-bracket"
+            }
+          ]
+        }
+      }
+    },
+    "predicate": {
+      "name": "keyword.other.predicate.ql",
+      "match": "(?x)\\b(?:predicate)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "predicate-body": {
+      "name": "meta.block.predicate-body.ql",
+      "begin": "(?x)((?:\\{))",
+      "end": "(?x)((?:\\}))",
+      "patterns": [
+        {
+          "include": "#predicate-body-contents"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#open-brace"
+            }
+          ]
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#close-brace"
+            }
+          ]
+        }
+      }
+    },
+    "predicate-body-contents": {
+      "patterns": [
+        {
+          "include": "#expr-as-clause"
+        },
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "include": "#module-qualifier"
+        },
+        {
+          "name": "entity.name.function.ql",
+          "match": "(?x)(?:\\b [a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))\\s*(?:\\*|\\+)?\\s*(?=\\()"
+        },
+        {
+          "name": "variable.other.ql",
+          "match": "(?x)(?:\\b [a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        },
+        {
+          "name": "entity.name.type.ql",
+          "match": "(?x)(?:\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))|(?:@[a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ]
+    },
+    "predicate-or-field-declaration": {
+      "name": "meta.block.predicate-or-field-declaration.ql",
+      "begin": "(?x)(?:(?=(?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_])))))(?!(?:(?:(?:\\b(?:_)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:and)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:any)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:as)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:asc)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:avg)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:boolean)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:by)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:class)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:concat)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:count)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:date)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:desc)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:else)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:exists)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:extends)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:false)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:float)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:forall)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:forex)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:from)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:if)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:implies)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:import)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:in)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:instanceof)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:int)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:max)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:min)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:module)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:newtype)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:none)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:not)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:or)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:order)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:predicate)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:rank)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:result)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:select)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictconcat)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictcount)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:strictsum)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:string)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:sum)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:super)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:then)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:this)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:true)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:where)(?:(?!(?:[0-9A-Za-z_]))))))|(?:(?:(?:\\b(?:abstract)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:bindingset)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:cached)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:deprecated)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:external)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:final)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:language)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:library)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:override)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:pragma)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:private)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:query)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:transient)(?:(?!(?:[0-9A-Za-z_])))))))) | (?=(?:(?:(?:\\b(?:boolean)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:date)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:float)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:int)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:predicate)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:string)(?:(?!(?:[0-9A-Za-z_]))))))) | (?=(?:@[a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?\u003c=\\}|;)",
+      "patterns": [
+        {
+          "include": "#predicate-parameter-list"
+        },
+        {
+          "include": "#predicate-body"
+        },
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "include": "#module-qualifier"
+        },
+        {
+          "name": "variable.field.ql",
+          "match": "(?x)(?:\\b [a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))(?=\\s*;)"
+        },
+        {
+          "name": "entity.name.function.ql",
+          "match": "(?x)(?:\\b [a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        },
+        {
+          "name": "entity.name.type.ql",
+          "match": "(?x)(?:\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))|(?:@[a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ]
+    },
+    "predicate-parameter-list": {
+      "name": "meta.block.predicate-parameter-list.ql",
+      "begin": "(?x)((?:\\())",
+      "end": "(?x)((?:\\)))",
+      "patterns": [
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "variable.parameter.ql",
+          "match": "(?x)(?:\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))(?=\\s*(?:,|\\)))"
+        },
+        {
+          "include": "#module-qualifier"
+        },
+        {
+          "name": "entity.name.type.ql",
+          "match": "(?x)(?:\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))|(?:@[a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        },
+        {
+          "name": "variable.parameter.ql",
+          "match": "(?x)(?:\\b [a-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#open-paren"
+            }
+          ]
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#close-paren"
+            }
+          ]
+        }
+      }
+    },
+    "predicate-start-keyword": {
+      "patterns": [
+        {
+          "include": "#boolean"
+        },
+        {
+          "include": "#date"
+        },
+        {
+          "include": "#float"
+        },
+        {
+          "include": "#int"
+        },
+        {
+          "include": "#predicate"
+        },
+        {
+          "include": "#string"
+        }
+      ]
+    },
+    "private": {
+      "name": "storage.modifier.private.ql",
+      "match": "(?x)\\b(?:private)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "query": {
+      "name": "storage.modifier.query.ql",
+      "match": "(?x)\\b(?:query)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "rank": {
+      "name": "keyword.aggregate.rank.ql",
+      "match": "(?x)\\b(?:rank)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "relational-operator": {
+      "name": "keyword.operator.relational.ql",
+      "match": "(?x)\u003c=|\u003c|\u003e=|\u003e"
+    },
+    "result": {
+      "name": "variable.language.result.ql",
+      "match": "(?x)\\b(?:result)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "select": {
+      "name": "keyword.query.select.ql",
+      "match": "(?x)\\b(?:select)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "select-as-clause": {
+      "match": "(?x)meta.block.select-as-clause.ql",
+      "begin": "(?x)((?:\\b(?:as)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?\u003c=(?:[0-9A-Za-z_])(?:(?!(?:[0-9A-Za-z_]))))",
+      "patterns": [
+        {
+          "include": "#non-context-sensitive"
+        },
+        {
+          "name": "variable.other.ql",
+          "match": "(?x)(?:\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_]))))"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#as"
+            }
+          ]
+        }
+      }
+    },
+    "select-clause": {
+      "name": "meta.block.select-clause.ql",
+      "begin": "(?x)(?=(?:\\b(?:from)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:where)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:select)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?!(?:\\b(?:from)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:where)(?:(?!(?:[0-9A-Za-z_]))))|(?:\\b(?:select)(?:(?!(?:[0-9A-Za-z_])))))",
+      "patterns": [
+        {
+          "include": "#from-section"
+        },
+        {
+          "include": "#where-section"
+        },
+        {
+          "include": "#select-section"
+        }
+      ]
+    },
+    "select-section": {
+      "name": "meta.block.select-section.ql",
+      "begin": "(?x)((?:\\b(?:select)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?=\\n)",
+      "patterns": [
+        {
+          "include": "#predicate-body-contents"
+        },
+        {
+          "include": "#select-as-clause"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#select"
+            }
+          ]
+        }
+      }
+    },
+    "semicolon": {
+      "name": "punctuation.separator.statement.ql",
+      "match": "(?x);"
+    },
+    "simple-id": {
+      "match": "(?x)\\b [A-Za-z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "strictconcat": {
+      "name": "keyword.aggregate.strictconcat.ql",
+      "match": "(?x)\\b(?:strictconcat)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "strictcount": {
+      "name": "keyword.aggregate.strictcount.ql",
+      "match": "(?x)\\b(?:strictcount)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "strictsum": {
+      "name": "keyword.aggregate.strictsum.ql",
+      "match": "(?x)\\b(?:strictsum)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "string": {
+      "name": "keyword.type.string.ql",
+      "match": "(?x)\\b(?:string)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "string-escape": {
+      "name": "constant.character.escape.ql",
+      "match": "(?x)\\\\[\"\\\\nrt]"
+    },
+    "string-literal": {
+      "name": "string.quoted.double.ql",
+      "begin": "(?x)\"",
+      "end": "(?x)(\") | ((?:[^\\\\\\n])$)",
+      "patterns": [
+        {
+          "include": "#string-escape"
+        }
+      ],
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.ql"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.definition.string.end.ql"
+        },
+        "2": {
+          "name": "invalid.illegal.newline.ql"
+        }
+      }
+    },
+    "sum": {
+      "name": "keyword.aggregate.sum.ql",
+      "match": "(?x)\\b(?:sum)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "super": {
+      "name": "variable.language.super.ql",
+      "match": "(?x)\\b(?:super)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "then": {
+      "name": "keyword.other.then.ql",
+      "match": "(?x)\\b(?:then)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "this": {
+      "name": "variable.language.this.ql",
+      "match": "(?x)\\b(?:this)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "transient": {
+      "name": "storage.modifier.transient.ql",
+      "match": "(?x)\\b(?:transient)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "true": {
+      "name": "constant.language.boolean.true.ql",
+      "match": "(?x)\\b(?:true)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "upper-id": {
+      "match": "(?x)\\b [A-Z][0-9A-Za-z_]* (?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "where": {
+      "name": "keyword.query.where.ql",
+      "match": "(?x)\\b(?:where)(?:(?!(?:[0-9A-Za-z_])))"
+    },
+    "where-section": {
+      "name": "meta.block.where-section.ql",
+      "begin": "(?x)((?:\\b(?:where)(?:(?!(?:[0-9A-Za-z_])))))",
+      "end": "(?x)(?=(?:\\b(?:select)(?:(?!(?:[0-9A-Za-z_])))))",
+      "patterns": [
+        {
+          "include": "#predicate-body-contents"
+        }
+      ],
+      "beginCaptures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#where"
+            }
+          ]
+        }
+      }
+    }
+  }
+}