github-linguist 4.8.2 → 4.8.3

data/grammars/source.dmf.json

@@ -0,0 +1,99 @@
+{
+  "fileTypes": [
+    "dmf"
+  ],
+  "name": "Dream Maker Interface",
+  "patterns": [
+    {
+      "match": "((#?\\b[0-9a-fA-F]*)|\\b(([0-9]+(,|x)?[0-9]*)|(\\.[0-9]+)))\\b",
+      "name": "constant.numeric.dm"
+    },
+    {
+      "match": "(^(macro|menu)|(\\b(window|elem)))\\b",
+      "name": "storage.type.dm"
+    },
+    {
+      "match": "\\b(true|false|none)\\b",
+      "name": "variable.language.dm"
+    },
+    {
+      "match": "\\b([A-Z_]+)\\b",
+      "name": "constant.language.dm"
+    },
+    {
+      "begin": "\"",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.dm"
+        }
+      },
+      "end": "\"",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.dm"
+        }
+      },
+      "name": "string.quoted.double.dm",
+      "patterns": [
+        {
+          "include": "#string_escaped_char"
+        },
+        {
+          "include": "#string_embedded_expression"
+        }
+      ]
+    },
+    {
+      "begin": "'",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.dm"
+        }
+      },
+      "end": "'",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.dm"
+        }
+      },
+      "name": "string.quoted.single.dm",
+      "patterns": [
+        {
+          "include": "#string_escaped_char"
+        }
+      ]
+    },
+    {
+      "begin": "(?x)\n    \t\t(?:  ^                                 # begin-of-line\n    \t\t  |\n    \t\t     (?: (?= \\s )           (?<!else|new|return) (?<=\\w)      #  or word + space before name\n    \t\t       | (?= \\s*[A-Za-z_] ) (?<!&&)       (?<=[*&>])   #  or type modifier before name\n    \t\t     )\n    \t\t)\n    \t\t(\\s*) (?!(while|for|do|if|else|switch|catch|enumerate|return|r?iterate)\\s*\\()\n    \t\t(\n    \t\t\t(?: [A-Za-z_][A-Za-z0-9_]*+ | :: )++ |                  # actual name\n    \t\t\t(?: (?<=operator) (?: [-*&<>=+!]+ | \\(\\) | \\[\\] ) )  # if it is a C++ operator\n    \t\t)\n    \t\t \\s*(?=\\()",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.whitespace.function.leading.dm"
+        },
+        "3": {
+          "name": "entity.name.function.dm"
+        },
+        "4": {
+          "name": "punctuation.definition.parameters.dm"
+        }
+      },
+      "end": "(?<=\\})|(?=#)|(;)?",
+      "name": "meta.function.dm",
+      "patterns": [
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#parens"
+        },
+        {
+          "match": "\\bconst\\b",
+          "name": "storage.modifier.dm"
+        },
+        {
+          "include": "#block"
+        }
+      ]
+    }
+  ],
+  "scopeName": "source.dmf"
+}

data/grammars/source.graphql.json

@@ -0,0 +1,219 @@
+{
+  "scopeName": "source.graphql",
+  "name": "GraphQL",
+  "fileTypes": [
+    "graphql",
+    "GraphQL"
+  ],
+  "foldingStartMarker": "{([",
+  "foldingStopMarker": "})]",
+  "patterns": [
+    {
+      "include": "#comment"
+    },
+    {
+      "name": "meta.fragment",
+      "comment": "a fragment definintion",
+      "match": "(fragment)\\s*([_A-Za-z][_0-9A-Za-z]*)\\s*(on)\\s*([_A-Za-z][_0-9A-Za-z]*)",
+      "captures": {
+        "1": {
+          "name": "storage.type"
+        },
+        "2": {
+          "name": "variable.other"
+        },
+        "3": {
+          "name": "keyword.operator"
+        },
+        "4": {
+          "name": "support.constant"
+        }
+      }
+    },
+    {
+      "name": "meta.operation",
+      "comment": "an operation definition",
+      "match": "(query|mutation)\\s*([_A-Za-z][_0-9A-Za-z]*)",
+      "captures": {
+        "1": {
+          "name": "storage.type"
+        },
+        "2": {
+          "name": "variable.other"
+        }
+      }
+    },
+    {
+      "include": "#arguments"
+    },
+    {
+      "include": "#selections"
+    }
+  ],
+  "repository": {
+    "string": {
+      "name": "string.quoted.double",
+      "begin": "\"",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin"
+        }
+      },
+      "end": "\"",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#escapedChar"
+        }
+      ]
+    },
+    "variable": {
+      "name": "constant.other.symbol",
+      "match": "\\$[_A-Za-z][_0-9A-Za-z]*"
+    },
+    "boolean": {
+      "name": "constant.language.boolean",
+      "match": "true|false"
+    },
+    "number": {
+      "name": "constant.numeric",
+      "match": "\\d+\\.?\\d*[eE]?[\\+\\-]?\\d*"
+    },
+    "directive": {
+      "name": "storage.modifier",
+      "match": "@[a-z]+"
+    },
+    "argument": {
+      "name": "variable.parameter",
+      "match": "[_A-Za-z][_0-9A-Za-z]*:"
+    },
+    "enum": {
+      "name": "support.constant.enum",
+      "match": "[_A-Za-z][_0-9A-Za-z]*"
+    },
+    "fragmentSpread": {
+      "match": "(\\.\\.\\.)\\s*([_A-Za-z][_0-9A-Za-z]*)\\s*(on)?",
+      "captures": {
+        "1": {
+          "name": "keyword.operator"
+        },
+        "2": {
+          "name": "variable.other"
+        }
+      }
+    },
+    "inlineFragment": {
+      "match": "(\\.\\.\\.)\\s*(on)\\s*([_A-Za-z][_0-9A-Za-z]*)",
+      "captures": {
+        "1": {
+          "name": "keyword.operator"
+        },
+        "2": {
+          "name": "keyword.operator"
+        },
+        "3": {
+          "name": "support.constant"
+        }
+      }
+    },
+    "arguments": {
+      "name": "meta.arguments",
+      "begin": "\\(",
+      "beginCaptures": {
+        "0": {
+          "name": "meta.brace.round.graphql"
+        }
+      },
+      "end": "\\)",
+      "endCaptures": {
+        "0": {
+          "name": "meta.brace.round.graphql"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#argument"
+        },
+        {
+          "include": "#string"
+        },
+        {
+          "include": "#boolean"
+        },
+        {
+          "include": "#variable"
+        },
+        {
+          "include": "#number"
+        },
+        {
+          "include": "#enum"
+        },
+        {
+          "include": "#comment"
+        }
+      ]
+    },
+    "selections": {
+      "name": "meta.selections",
+      "begin": "\\{",
+      "beginCaptures": {
+        "0": {
+          "name": "meta.brace.curly.graphql"
+        }
+      },
+      "end": "\\}",
+      "endCaptures": {
+        "0": {
+          "name": "meta.brace.curly.graphql"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#fieldAlias"
+        },
+        {
+          "include": "#inlineFragment"
+        },
+        {
+          "include": "#fragmentSpread"
+        },
+        {
+          "include": "#directive"
+        },
+        {
+          "include": "#arguments"
+        },
+        {
+          "include": "#comment"
+        },
+        {
+          "include": "#selections"
+        },
+        {
+          "include": "#builtInField"
+        }
+      ]
+    },
+    "comment": {
+      "name": "comment.line.number-sign.graphql",
+      "match": "#.*$"
+    },
+    "builtInField": {
+      "match": "__schema|__typename|__type",
+      "name": "keyword.other.graphql"
+    },
+    "escapedChar": {
+      "match": "\\\\(?:u[\\da-fA-f]{4}|.)",
+      "name": "constant.character.escape.graphql"
+    },
+    "fieldAlias": {
+      "match": "[_A-Za-z][_0-9A-Za-z]*:",
+      "name": "variable.other.alias.graphql"
+    }
+  }
+}

data/grammars/source.idris.json

@@ -0,0 +1,537 @@
+{
+  "fileTypes": [
+    "idr"
+  ],
+  "name": "Idris",
+  "patterns": [
+    {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.entity.idris"
+        },
+        "2": {
+          "name": "punctuation.definition.entity.idris"
+        }
+      },
+      "comment": "Infix function application",
+      "match": "(`)[\\w']*?(`)",
+      "name": "keyword.operator.function.infix.idris"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.other.idris"
+        }
+      },
+      "match": "^(module)\\s+([a-zA-Z._']+)$",
+      "name": "meta.declaration.module.idris"
+    },
+    {
+      "captures": {
+        "1": {
+          "name": "keyword.other.idris"
+        }
+      },
+      "match": "^(import)\\s+([a-zA-Z._']+)$",
+      "name": "meta.import.idris"
+    },
+    {
+      "match": "\\b([0-9]+\\.[0-9]+([eE][+-]?[0-9]+)?|[0-9]+[eE][+-]?[0-9]+)\\b",
+      "name": "constant.numeric.float.idris"
+    },
+    {
+      "match": "\\b([0-9]+|0([xX][0-9a-fA-F]+|[oO][0-7]+))\\b",
+      "name": "constant.numeric.idris"
+    },
+    {
+      "match": "^\\b(public|abstract|private)\\b",
+      "name": "storage.modifier.export.idris"
+    },
+    {
+      "match": "\\b(total|partial)\\b",
+      "name": "storage.modifier.totality.idris"
+    },
+    {
+      "match": "^\\b(implicit)\\b",
+      "name": "storage.modifier.idris"
+    },
+    {
+      "begin": "\\\"",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.idris"
+        }
+      },
+      "end": "\\\"",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.idris"
+        }
+      },
+      "name": "string.quoted.double.idris",
+      "patterns": [
+        {
+          "include": "#escape_characters"
+        }
+      ]
+    },
+    {
+      "begin": "(?<!\\w)\\'",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.idris"
+        }
+      },
+      "end": "\\'",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.idris"
+        }
+      },
+      "name": "string.quoted.single.idris",
+      "patterns": [
+        {
+          "include": "#escape_characters"
+        },
+        {
+          "match": "\\n",
+          "name": "invalid.illegal.idris"
+        }
+      ]
+    },
+    {
+      "begin": "\\b(class)\\b",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.idris"
+        }
+      },
+      "end": "\\b(where)\\b|$",
+      "endCaptures": {
+        "1": {
+          "name": "keyword.other.idris"
+        }
+      },
+      "name": "meta.declaration.class.idris",
+      "patterns": [
+        {
+          "include": "#prelude_class"
+        },
+        {
+          "include": "#prelude_type"
+        }
+      ]
+    },
+    {
+      "begin": "\\b(instance)\\b",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.idris"
+        }
+      },
+      "end": "\\b(where)\\b|$",
+      "endCaptures": {
+        "1": {
+          "name": "keyword.other.idris"
+        }
+      },
+      "name": "meta.declaration.instance.idris",
+      "patterns": [
+        {
+          "include": "#prelude_class"
+        },
+        {
+          "include": "#prelude_type"
+        },
+        {
+          "include": "#context_signature"
+        },
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "begin": "\\b(data)\\s+([\\w']+)\\s*(:)?",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.idris"
+        },
+        "2": {
+          "name": "entity.name.type.idris"
+        },
+        "3": {
+          "name": "keyword.operator.colon.idris"
+        }
+      },
+      "end": "\\b(where)\\b|(=)",
+      "endCaptures": {
+        "1": {
+          "name": "keyword.other.idris"
+        },
+        "2": {
+          "name": "keyword.operator.idris"
+        }
+      },
+      "name": "meta.declaration.data.idris",
+      "patterns": [
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "include": "#function_signature"
+    },
+    {
+      "include": "#directive"
+    },
+    {
+      "include": "#comments"
+    },
+    {
+      "include": "#language_const"
+    },
+    {
+      "include": "#language_keyword"
+    },
+    {
+      "include": "#prelude"
+    },
+    {
+      "match": "\\b[A-Z][A-Za-z_'0-9]*",
+      "name": "constant.other.idris"
+    },
+    {
+      "match": "[|&!%$?~+:\\-.=</>\\\\*]+",
+      "name": "keyword.operator.idris"
+    },
+    {
+      "match": ",",
+      "name": "punctuation.separator.comma.idris"
+    }
+  ],
+  "repository": {
+    "block_comment": {
+      "begin": "\\{-(?!#)",
+      "captures": {
+        "0": {
+          "name": "punctuation.definition.comment.idris"
+        }
+      },
+      "end": "-\\}",
+      "name": "comment.block.idris",
+      "patterns": [
+        {
+          "include": "#block_comment"
+        }
+      ]
+    },
+    "comments": {
+      "patterns": [
+        {
+          "captures": {
+            "1": {
+              "name": "punctuation.definition.comment.idris"
+            }
+          },
+          "match": "(--).*$\\n?",
+          "name": "comment.line.double-dash.idris"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "punctuation.definition.comment.idris"
+            }
+          },
+          "match": "(\\|\\|\\|).*$\\n?",
+          "name": "comment.line.triple-bar.idris"
+        },
+        {
+          "include": "#block_comment"
+        }
+      ]
+    },
+    "context_signature": {
+      "patterns": [
+        {
+          "captures": {
+            "1": {
+              "name": "entity.other.inherited-class.idris"
+            },
+            "2": {
+              "name": "entity.other.attribute-name.idris"
+            },
+            "4": {
+              "name": "keyword.operator.double-arrow.idris"
+            }
+          },
+          "match": "([\\w._']+)((\\s+[\\w_']+)+)\\s*(=>)",
+          "name": "meta.context-signature.idris"
+        },
+        {
+          "begin": "(\\()((?=.*\\)\\s*=>)|(?=[^)]*$))",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.context.begin.idris"
+            }
+          },
+          "comment": "For things like '(Eq a, Show b) =>' It begins with '(' either followed by ') =>' on the same line, or anything but ')' until the end of line.",
+          "end": "(\\))\\s*(=>)",
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.context.end.idris"
+            },
+            "2": {
+              "name": "keyword.operator.double-arrow.idris"
+            }
+          },
+          "name": "meta.context-signature.idris",
+          "patterns": [
+            {
+              "captures": {
+                "1": {
+                  "name": "entity.other.inherited-class.idris"
+                },
+                "2": {
+                  "name": "entity.other.attribute-name.idris"
+                }
+              },
+              "match": "([\\w']+)\\s+([\\w']+)",
+              "name": "meta.class-constraint.idris"
+            }
+          ]
+        }
+      ]
+    },
+    "directive": {
+      "patterns": [
+        {
+          "captures": {
+            "1": {
+              "name": "keyword.other.directive.idris"
+            },
+            "2": {
+              "name": "keyword.other.language-extension.idris"
+            }
+          },
+          "match": "^%(language)\\s+(.*)$",
+          "name": "meta.directive.language-extension.idris"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "keyword.other.directive.idris"
+            },
+            "2": {
+              "name": "keyword.other.totality.idris"
+            }
+          },
+          "match": "^%(default)\\s+(total|partial)$",
+          "name": "meta.directive.totality.idris"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "keyword.other.directive.idris"
+            },
+            "2": {
+              "name": "keyword.other.idris"
+            }
+          },
+          "match": "^%(provide)\\s+.*\\s+(with)\\s+.*$",
+          "name": "meta.directive.type-provider.idris"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "keyword.other.directive.idris"
+            },
+            "2": {
+              "name": "storage.modifier.export.idris"
+            }
+          },
+          "match": "^%(access)\\s+(public|abstract|private)$",
+          "name": "meta.directive.export.idris"
+        },
+        {
+          "captures": {
+            "1": {
+              "name": "keyword.other.directive.idris"
+            }
+          },
+          "match": "^%([\\w]+)\\b",
+          "name": "meta.directive.idris"
+        }
+      ]
+    },
+    "escape_characters": {
+      "patterns": [
+        {
+          "match": "\\\\(NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE|DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS|US|SP|DEL|[abfnrtv\\\\\\\"'\\&])",
+          "name": "constant.character.escape.ascii.idris"
+        },
+        {
+          "match": "\\\\o[0-7]+|\\\\x[0-9A-Fa-f]+|\\\\[0-9]+",
+          "name": "constant.character.escape.octal.idris"
+        },
+        {
+          "match": "\\^[A-Z@\\[\\]\\\\\\^_]",
+          "name": "constant.character.escape.control.idris"
+        }
+      ]
+    },
+    "function_signature": {
+      "begin": "(([\\w']+)|\\(([|!%$+\\-.,=</>:]+)\\))\\s*(:)(?!:)",
+      "beginCaptures": {
+        "2": {
+          "name": "entity.name.function.idris"
+        },
+        "3": {
+          "name": "entity.name.function.idris"
+        },
+        "4": {
+          "name": "keyword.operator.colon.idris"
+        }
+      },
+      "comment": "The end patterm is a bit tricky. It's either ';' or something, at the end of the line, but not '->', because a type signature can be multiline. Though, it doesn't help, if you break the signature before arrows.",
+      "end": "(;|(?<=[^\\s>])\\s*(?!->)\\s*$)",
+      "name": "meta.function.type-signature.idris",
+      "patterns": [
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    "language_const": {
+      "patterns": [
+        {
+          "match": "\\(\\)",
+          "name": "constant.language.unit.idris"
+        },
+        {
+          "match": "_\\|_",
+          "name": "constant.language.bottom.idris"
+        },
+        {
+          "match": "\\b_\\b",
+          "name": "constant.language.underscore.idris"
+        }
+      ]
+    },
+    "language_keyword": {
+      "patterns": [
+        {
+          "comment": "I'm not sure that these are all keywords, but don't know where to check it",
+          "match": "\\b(infix[lr]?|let|where|of|with)\\b",
+          "name": "keyword.other.idris"
+        },
+        {
+          "match": "\\b(do|if|then|else|case|in)\\b",
+          "name": "keyword.control.idris"
+        }
+      ]
+    },
+    "parameter_type": {
+      "comment": "Parameter types in a type signature",
+      "patterns": [
+        {
+          "include": "#prelude_type"
+        },
+        {
+          "begin": "\\(([\\w']+)\\s*:(?!:)",
+          "beginCaptures": {
+            "1": {
+              "name": "entity.name.tag.idris"
+            }
+          },
+          "comment": "(x : Nat)",
+          "end": "\\)",
+          "name": "meta.parameter.named.idris",
+          "patterns": [
+            {
+              "include": "#prelude_type"
+            }
+          ]
+        },
+        {
+          "begin": "\\{((auto|default .+)\\s+)?([\\w']+)\\s*:(?!:)",
+          "beginCaptures": {
+            "1": {
+              "name": "storage.modifier.idris"
+            },
+            "3": {
+              "name": "entity.name.tag.idris"
+            }
+          },
+          "comment": "{auto p : a = b}",
+          "end": "\\}",
+          "name": "meta.parameter.implicit.idris",
+          "patterns": [
+            {
+              "include": "#prelude_type"
+            }
+          ]
+        }
+      ]
+    },
+    "prelude": {
+      "patterns": [
+        {
+          "include": "#prelude_class"
+        },
+        {
+          "include": "#prelude_type"
+        },
+        {
+          "include": "#prelude_function"
+        },
+        {
+          "include": "#prelude_const"
+        }
+      ]
+    },
+    "prelude_class": {
+      "comment": "These should be more or less all classes defined in Prelude (checked)",
+      "match": "\\b(Eq|Ord|Num|MinBound|MaxBound|Integral|Applicative|Alternative|Cast|Foldable|Functor|Monad|Traversable|Uninhabited|Semigroup|VerifiedSemigroup|Monoid|VerifiedMonoid|Group|VerifiedGroup|AbelianGroup|VerifiedAbelianGroup|Ring|VerifiedRing|RingWithUnity|VerifiedRingWithUnity|JoinSemilattice|VerifiedJoinSemilattice|MeetSemilattice|VerifiedMeetSemilattice|BoundedJoinSemilattice|VerifiedBoundedJoinSemilattice|BoundedMeetSemilattice|VerifiedBoundedMeetSemilattice|Lattice|VerifiedLattice|BoundedLattice|VerifiedBoundedLattice)\\b",
+      "name": "support.class.prelude.idris"
+    },
+    "prelude_const": {
+      "patterns": [
+        {
+          "match": "\\b(Just|Nothing|Left|Right|True|False|LT|EQ|GT)\\b",
+          "name": "support.constant.prelude.idris"
+        }
+      ]
+    },
+    "prelude_function": {
+      "comment": "TODO review it; these are just Haskell prelude functions",
+      "match": "\\b(abs|acos|acosh|all|and|any|appendFile|applyM|asTypeOf|asin|asinh|atan|atan2|atanh|break|catch|ceiling|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|div|divMod|drop|dropWhile|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromEnum|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|head|id|init|interact|ioError|isDenormalized|isIEEE|isInfinite|isNaN|isNegativeZero|iterate|last|lcm|length|lex|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|odd|or|otherwise|pi|pred|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|read|readFile|readIO|readList|readLn|readParen|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showList|showParen|showString|shows|showsPrec|significand|signum|sin|sinh|snd|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|toEnum|toInteger|toRational|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\\b",
+      "name": "support.function.prelude.idris"
+    },
+    "prelude_type": {
+      "comment": "These should be more or less all types defined in Prelude and some synonyms (checked)",
+      "match": "\\b(Type|Exists|World|IO|IntTy|FTy|Foreign|File|Mode|Dec|Bool|so|Ordering|Either|Fin|IsJust|List|Maybe|Nat|LTE|GTE|GT|LT|Stream|StrM|Vect|Not|Lazy|Inf|FalseElim)\\b",
+      "name": "support.type.prelude.idris"
+    },
+    "type_signature": {
+      "patterns": [
+        {
+          "include": "#context_signature"
+        },
+        {
+          "include": "#parameter_type"
+        },
+        {
+          "include": "#language_const"
+        },
+        {
+          "match": "->",
+          "name": "keyword.operator.arrow.idris"
+        }
+      ]
+    }
+  },
+  "scopeName": "source.idris",
+  "uuid": "8957eeb1-b492-4497-85b8-b86e511e87eb"
+}