@codingame/monaco-editor-wrapper 4.0.0-next.3 → 4.0.1

package/dist/assets/justusadam.language-haskell-3.6.0.vsix/haskell.json

@@ -0,0 +1,2525 @@
+{
+  "fileTypes": [
+    "hs",
+    "hs-boot",
+    "hsig"
+  ],
+  "keyEquivalent": "^~H",
+  "name": "Haskell",
+  "patterns": [
+    {
+      "include": "#liquid_haskell"
+    },
+    {
+      "include": "#comment_like"
+    },
+    {
+      "include": "#numeric_literals"
+    },
+    {
+      "include": "#string_literal"
+    },
+    {
+      "include": "#char_literal"
+    },
+    {
+      "match": "(?<!@|#)-\\}",
+      "name": "invalid"
+    },
+    {
+      "match": "(\\()\\s*(\\))",
+      "name": "constant.language.unit.haskell",
+      "captures": {
+        "1": {
+          "name": "punctuation.paren.haskell"
+        },
+        "2": {
+          "name": "punctuation.paren.haskell"
+        }
+      }
+    },
+    {
+      "match": "(\\()(#)\\s*(#)(\\))",
+      "name": "constant.language.unit.unboxed.haskell",
+      "captures": {
+        "1": {
+          "name": "punctuation.paren.haskell"
+        },
+        "2": {
+          "name": "keyword.operator.hash.haskell"
+        },
+        "3": {
+          "name": "keyword.operator.hash.haskell"
+        },
+        "4": {
+          "name": "punctuation.paren.haskell"
+        }
+      }
+    },
+    {
+      "match": "(\\()\\s*,[\\s,]*(\\))",
+      "name": "support.constant.tuple.haskell",
+      "captures": {
+        "1": {
+          "name": "punctuation.paren.haskell"
+        },
+        "2": {
+          "name": "punctuation.paren.haskell"
+        }
+      }
+    },
+    {
+      "match": "(\\()(#)\\s*,[\\s,]*(#)(\\))",
+      "name": "support.constant.tuple.unboxed.haskell",
+      "captures": {
+        "1": {
+          "name": "punctuation.paren.haskell"
+        },
+        "2": {
+          "name": "keyword.operator.hash.haskell"
+        },
+        "3": {
+          "name": "keyword.operator.hash.haskell"
+        },
+        "4": {
+          "name": "punctuation.paren.haskell"
+        }
+      }
+    },
+    {
+      "match": "(\\[)\\s*(\\])",
+      "name": "constant.language.empty-list.haskell",
+      "captures": {
+        "1": {
+          "name": "punctuation.bracket.haskell"
+        },
+        "2": {
+          "name": "punctuation.bracket.haskell"
+        }
+      }
+    },
+    {
+      "begin": "(\\b(?<!')(module)|^(signature))(\\b(?!'))",
+      "beginCaptures": {
+        "2": {
+          "name": "keyword.other.module.haskell"
+        },
+        "3": {
+          "name": "keyword.other.signature.haskell"
+        }
+      },
+      "end": "(?=\\b(?<!')where\\b(?!'))",
+      "name": "meta.declaration.module.haskell",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#module_name"
+        },
+        {
+          "include": "#module_exports"
+        },
+        {
+          "match": "[a-z]+",
+          "name": "invalid"
+        }
+      ]
+    },
+    {
+      "include": "#ffi"
+    },
+    {
+      "begin": "^(\\s*)(class)(\\b(?!'))",
+      "beginCaptures": {
+        "2": {
+          "name": "keyword.other.class.haskell"
+        }
+      },
+      "end": "(?x) # Detect end of class declaration:\n         # 'where' keyword\n   (?=(?<!')\\bwhere\\b(?!'))  \n         # Decreasing indentation\n   |(?=\\}|;)      # Explicit indentation\n   |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n       \\1\\s+\\S    # - more indented, or\n     | \\s*        # - starts with whitespace, followed by:\n       (?: $      #   - the end of the line (i.e. empty line), or\n       |\\{-[^@]   #   - the start of a block comment, or\n       |--+       #   - the start of a single-line comment.\n          (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                  # The double dash may not be followed by other operator characters\n                  # (then it would be an operator, not a comment)\n     )",
+      "name": "meta.declaration.class.haskell",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#where"
+        },
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "begin": "(?x)\n  ^(\\s*)(data|newtype)(?:\\s+(instance))?\\s+\n  # Keep consuming characters until:\n  ((?:(?!\n  # the equals symbol or the start of a single-line comment, or\n    (?: \n      (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n      (?:=|--+)\n      (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])  # non-symbol\n    )\n  # the \"where\" or \"deriving\" keywords, or\n  | (?:\\b(?<!')(?:where|deriving)\\b(?!'))\n  # the start of a block comment.\n  | {-\n  #\n  ).)*)\n  (?=\\b(?<!'')where\\b(?!''))",
+      "beginCaptures": {
+        "2": {
+          "name": "keyword.other.$2.haskell"
+        },
+        "3": {
+          "name": "keyword.other.instance.haskell"
+        },
+        "4": {
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        }
+      },
+      "name": "meta.declaration.$2.generalized.haskell",
+      "end": "(?x) # Detect end of data declaration:\n         # Deriving clause\n   (?=(?<!')\\bderiving\\b(?!'))  \n         # Decreasing indentation\n   |(?=\\}|;)      # Explicit indentation\n   |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n       \\1\\s+\\S    # - more indented, or\n     | \\s*        # - starts with whitespace, followed by:\n       (?: $      #   - the end of the line (i.e. empty line), or\n       |\\{-[^@]   #   - the start of a block comment, or\n       |--+       #   - the start of a single-line comment.\n          (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                  # The double dash may not be followed by other operator characters\n                  # (then it would be an operator, not a comment)\n     )\n",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "begin": "(?x)\n  (?<!')\\b(where)\n  \\s*(\\{)(?!-)",
+          "end": "\\}",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.where.haskell"
+            },
+            "2": {
+              "name": "punctuation.brace.haskell"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.brace.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#gadt_constructor"
+            },
+            {
+              "match": ";",
+              "name": "punctuation.semicolon.haskell"
+            }
+          ]
+        },
+        {
+          "match": "\\b(?<!')(where)\\b(?!')",
+          "name": "keyword.other.where.haskell"
+        },
+        {
+          "include": "#deriving"
+        },
+        {
+          "include": "#gadt_constructor"
+        }
+      ]
+    },
+    {
+      "include": "#role_annotation"
+    },
+    {
+      "name": "meta.declaration.pattern.type.haskell",
+      "begin": "^(\\s*)(pattern)\\s+(.*?)\\s+(::|∷)(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])",
+      "beginCaptures": {
+        "2": {
+          "name": "keyword.other.pattern.haskell"
+        },
+        "3": {
+          "patterns": [
+            {
+              "include": "#comma"
+            },
+            {
+              "include": "#data_constructor"
+            }
+          ]
+        },
+        "4": {
+          "name": "keyword.operator.double-colon.haskell"
+        }
+      },
+      "end": "(?x) # Detect end of pattern type definition by decreasing indentation:\n  (?=\\}|;)       # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )\n",
+      "patterns": [
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "name": "meta.declaration.pattern.haskell",
+      "begin": "^\\s*(pattern)\\b(?!')",
+      "captures": {
+        "1": {
+          "name": "keyword.other.pattern.haskell"
+        }
+      },
+      "end": "(?x) # Detect end of pattern type definition by decreasing indentation:\n  (?=\\}|;)       # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )\n",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "begin": "(?x)\n  # Data declaration\n  ^(\\s*)(data|newtype)(?:\\s+(family|instance))?\\s+\n  # Keep consuming characters until:\n  (((?!\n  # the equals symbol or the start of a single-line comment, or\n    (?: \n      (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n      (?:=|--+)\n      (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])  # non-symbol\n    )\n  # the \"where\" or \"deriving\" keywords, or\n  | (?:\\b(?<!')(?:where|deriving)\\b(?!'))\n  # the start of a block comment.\n  | {-\n  #\n  ).)*)",
+      "beginCaptures": {
+        "2": {
+          "name": "keyword.other.$2.haskell"
+        },
+        "3": {
+          "name": "keyword.other.$3.haskell"
+        },
+        "4": {
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        }
+      },
+      "name": "meta.declaration.$2.algebraic.haskell",
+      "end": "(?x) # Detect end of data declaration: \n     # Decreasing indentation\n   (?=\\}|;)      # Explicit indentation\n   |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n       \\1\\s+\\S    # - more indented, or\n     | \\s*        # - starts with whitespace, followed by:\n       (?: $      #   - the end of the line (i.e. empty line), or\n       |\\{-[^@]   #   - the start of a block comment, or\n       |--+       #   - the start of a single-line comment.\n          (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                  # The double dash may not be followed by other operator characters\n                  # (then it would be an operator, not a comment)\n     )",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#deriving"
+        },
+        {
+          "include": "#forall"
+        },
+        {
+          "include": "#adt_constructor"
+        },
+        {
+          "include": "#data_context"
+        },
+        {
+          "include": "#record_decl"
+        },
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "name": "meta.declaration.type.family.haskell",
+      "begin": "(?x)\n  # Type family\n  ^(\\s*)(type)\\s+(family)\\b(?!')\n  # Keep consuming characters until:\n  (((?!\n  # the equals symbol or the start of a single-line comment, or\n    (?: \n      (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n      (?:=|--+)\n      (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])  # non-symbol\n    )\n  # the \"where\" keyword, or\n  | \\b(?<!')where\\b(?!')\n  # the start of a block comment.\n  | {-\n  #\n  ).)*)",
+      "beginCaptures": {
+        "2": {
+          "name": "keyword.other.type.haskell"
+        },
+        "3": {
+          "name": "keyword.other.family.haskell"
+        },
+        "4": {
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#where"
+            },
+            {
+              "include": "#type_signature"
+            }
+          ]
+        }
+      },
+      "end": "(?x) # Detect end of type family by decreasing indentation:\n  (?=\\}|;)       # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )\n",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#where"
+        },
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "name": "meta.declaration.type.haskell",
+      "begin": "(?x)\n  # Type declaration\n  ^(\\s*)(type)(?:\\s+(instance))?\\s+\n  # Keep consuming characters until:\n  (((?!\n  # the equals symbol, the start of a single-line comment, or a type signature\n    (?: \n      (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n      (?:=|--+|::|∷)\n      (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])  # non-symbol\n    )\n  # the start of a block comment.\n  | {-\n  #\n  ).)*)",
+      "beginCaptures": {
+        "2": {
+          "name": "keyword.other.type.haskell"
+        },
+        "3": {
+          "name": "keyword.other.instance.haskell"
+        },
+        "4": {
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        }
+      },
+      "end": "(?x) # Detect end of type definition by decreasing indentation:\n  (?=\\}|;)       # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )\n",
+      "patterns": [
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "begin": "^(\\s*)(instance)(\\b(?!'))",
+      "beginCaptures": {
+        "2": {
+          "name": "keyword.other.instance.haskell"
+        }
+      },
+      "end": "(?x) # Detect end of instance declaration:\n  # 'where' keyword\n  (?=\\b(?<!')(where)\\b(?!'))\n  # Decreasing indentation\n  |(?=\\}|;)      # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )\n",
+      "name": "meta.declaration.instance.haskell",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#where"
+        },
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "begin": "^(\\s*)(import)(\\b(?!'))",
+      "beginCaptures": {
+        "2": {
+          "name": "keyword.other.import.haskell"
+        }
+      },
+      "end": "(?x) # Detect end of import\n  # 'where' keyword\n  (?=\\b(?<!')(where)\\b(?!'))\n  # Decreasing indentation\n  |(?=\\}|;)      # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )\n",
+      "name": "meta.import.haskell",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#where"
+        },
+        {
+          "match": "(qualified|as|hiding)",
+          "captures": {
+            "1": {
+              "name": "keyword.other.$1.haskell"
+            }
+          }
+        },
+        {
+          "include": "#module_name"
+        },
+        {
+          "include": "#module_exports"
+        }
+      ]
+    },
+    {
+      "include": "#deriving"
+    },
+    {
+      "include": "#layout_herald"
+    },
+    {
+      "include": "#keyword"
+    },
+    {
+      "match": "^\\s*(infix[lr]?)\\s+(.*)",
+      "captures": {
+        "1": {
+          "name": "keyword.other.fixity.$1.haskell"
+        },
+        "2": {
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#integer_literals"
+            },
+            {
+              "match": ":[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*",
+              "name": "constant.other.operator.infix.haskell"
+            },
+            {
+              "include": "#infix_op"
+            }
+          ]
+        }
+      },
+      "name": "meta.fixity-declaration.haskell"
+    },
+    {
+      "include": "#start_type_signature"
+    },
+    {
+      "include": "#overloaded_label"
+    },
+    {
+      "include": "#type_application"
+    },
+    {
+      "include": "#reserved_symbol"
+    },
+    {
+      "include": "#fun_decl"
+    },
+    {
+      "include": "#qualifier"
+    },
+    {
+      "match": ":[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*",
+      "name": "constant.other.operator.infix.haskell"
+    },
+    {
+      "include": "#data_constructor"
+    },
+    {
+      "include": "#prefix_op"
+    },
+    {
+      "include": "#infix_op"
+    },
+    {
+      "begin": "(\\()(#)\\s",
+      "end": "(#)(\\))",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.paren.haskell"
+        },
+        "2": {
+          "name": "keyword.operator.hash.haskell"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "keyword.operator.hash.haskell"
+        },
+        "2": {
+          "name": "punctuation.paren.haskell"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#comma"
+        },
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "begin": "(\\()",
+      "end": "(\\))",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.paren.haskell"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.paren.haskell"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#comma"
+        },
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "include": "#quasi_quote"
+    },
+    {
+      "begin": "(\\[)",
+      "end": "(\\])",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.bracket.haskell"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.bracket.haskell"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#comma"
+        },
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    {
+      "include": "#record"
+    }
+  ],
+  "repository": {
+    "block_comment": {
+      "applyEndPatternLast": 1,
+      "begin": "\\{-",
+      "captures": {
+        "0": {
+          "name": "punctuation.definition.comment.haskell"
+        }
+      },
+      "end": "-\\}",
+      "name": "comment.block.haskell",
+      "patterns": [
+        {
+          "include": "#block_comment"
+        }
+      ]
+    },
+    "comments": {
+      "patterns": [
+        {
+          "begin": "^(\\s*)(--\\s[\\|\\$])",
+          "beginCaptures": {
+            "2": {
+              "name": "punctuation.whitespace.comment.leading.haskell"
+            }
+          },
+          "end": "(?=^(?!\\1--+(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])))",
+          "name": "comment.block.documentation.haskell"
+        },
+        {
+          "begin": "(^[ \\t]+)?(--\\s[\\^\\*])",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.whitespace.comment.leading.haskell"
+            }
+          },
+          "end": "\\n",
+          "name": "comment.line.documentation.haskell"
+        },
+        {
+          "applyEndPatternLast": 1,
+          "begin": "\\{-\\s?[\\|\\$\\*\\^]",
+          "captures": {
+            "0": {
+              "name": "punctuation.definition.comment.haskell"
+            }
+          },
+          "end": "-\\}",
+          "name": "comment.block.documentation.haskell",
+          "patterns": [
+            {
+              "include": "#block_comment"
+            }
+          ]
+        },
+        {
+          "begin": "(^[ \\t]+)?(?=--+(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]))",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.whitespace.comment.leading.haskell"
+            }
+          },
+          "comment": "Operators may begin with '--' as long as they are not entirely composed of '-' characters. This means comments can't be immediately followed by an allowable operator character.",
+          "end": "(?!\\G)",
+          "patterns": [
+            {
+              "begin": "--",
+              "beginCaptures": {
+                "0": {
+                  "name": "punctuation.definition.comment.haskell"
+                }
+              },
+              "end": "\\n",
+              "name": "comment.line.double-dash.haskell"
+            }
+          ]
+        },
+        {
+          "include": "#block_comment"
+        }
+      ]
+    },
+    "comment_like": {
+      "patterns": [
+        {
+          "include": "#cpp"
+        },
+        {
+          "include": "#pragma"
+        },
+        {
+          "include": "#comments"
+        }
+      ]
+    },
+    "cpp": {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.preprocessor.c"
+        }
+      },
+      "comment": "In addition to Haskell's \"native\" syntax, GHC permits the C preprocessor to be run on a source file.",
+      "match": "^(#).*$",
+      "name": "meta.preprocessor.c"
+    },
+    "where": {
+      "patterns": [
+        {
+          "begin": "(?x)\n  (?<!')\\b(where)\n  \\s*(\\{)(?!-)",
+          "end": "(\\})",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.where.haskell"
+            },
+            "2": {
+              "name": "punctuation.brace.haskell"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.brace.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "$self"
+            },
+            {
+              "match": ";",
+              "name": "punctuation.semicolon.haskell"
+            }
+          ]
+        },
+        {
+          "match": "\\b(?<!')(where)\\b(?!')",
+          "name": "keyword.other.where.haskell"
+        }
+      ]
+    },
+    "layout_herald": {
+      "begin": "(?x)\n  (?:(?<!')\\b(?:(where|let|m?do)|(of))|(\\\\\\s*case))\n  \\s*(\\{)(?!-)",
+      "end": "(\\})",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.$1.haskell"
+        },
+        "2": {
+          "name": "keyword.control.of.haskell"
+        },
+        "3": {
+          "name": "keyword.control.lambda-case.haskell"
+        },
+        "4": {
+          "name": "punctuation.brace.haskell"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.brace.haskell"
+        }
+      },
+      "patterns": [
+        {
+          "include": "$self"
+        },
+        {
+          "match": ";",
+          "name": "punctuation.semicolon.haskell"
+        }
+      ]
+    },
+    "keyword": {
+      "match": "\\b(?<!')(?:(where|let|in|default)|(m?do|if|then|else|case|of|proc|rec))\\b(?!')",
+      "captures": {
+        "1": {
+          "name": "keyword.other.$1.haskell"
+        },
+        "2": {
+          "name": "keyword.control.$2.haskell"
+        }
+      }
+    },
+    "deriving": {
+      "patterns": [
+        {
+          "begin": "^(\\s*)(deriving)\\s+(?:(via|stock|newtype|anyclass)\\s+)?",
+          "beginCaptures": {
+            "2": {
+              "name": "keyword.other.deriving.haskell"
+            },
+            "3": {
+              "name": "keyword.other.deriving.strategy.$3.haskell"
+            }
+          },
+          "end": "(?x) # Detect end of deriving statement\n  # Decreasing indentation\n   (?=\\}|;)      # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )",
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "match": "(?<!')\\b(instance)\\b(?!')",
+              "name": "keyword.other.instance.haskell"
+            },
+            {
+              "match": "(?<!')\\b(via|stock|newtype|anyclass)\\b(?!')",
+              "captures": {
+                "1": {
+                  "name": "keyword.other.deriving.strategy.$1.haskell"
+                }
+              }
+            },
+            {
+              "include": "#type_signature"
+            }
+          ],
+          "name": "meta.deriving.haskell"
+        },
+        {
+          "begin": "(deriving)(?:\\s+(stock|newtype|anyclass))?\\s*(\\()",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.deriving.haskell"
+            },
+            "2": {
+              "name": "keyword.other.deriving.strategy.$2.haskell"
+            },
+            "3": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "end": "(\\))",
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "name": "meta.deriving.haskell",
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        {
+          "match": "(?x)\n  (deriving)(?:\\s+(stock|newtype|anyclass))?\\s+\n    ([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n    (\\s+(via)\\s+(.*)$)?\n",
+          "captures": {
+            "1": {
+              "name": "keyword.other.deriving.haskell"
+            },
+            "2": {
+              "name": "keyword.other.deriving.strategy.$2.haskell"
+            },
+            "3": {
+              "patterns": [
+                {
+                  "include": "#type_signature"
+                }
+              ]
+            },
+            "5": {
+              "name": "keyword.other.deriving.strategy.via.haskell"
+            },
+            "6": {
+              "patterns": [
+                {
+                  "include": "#type_signature"
+                }
+              ]
+            }
+          },
+          "name": "meta.deriving.haskell"
+        },
+        {
+          "match": "(?<!')\\b(via)\\b(?!')",
+          "name": "keyword.other.deriving.strategy.via.haskell"
+        }
+      ]
+    },
+    "prefix_op": {
+      "patterns": [
+        {
+          "comment": "An operator cannot be composed entirely of '-' characters;  instead, it should be matched as a comment.\n",
+          "match": "(?x)\n  (\\()\\s*(?!(?:--+|\\.\\.)\\))(\\#+|[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+(?<!\\#))\\s*(\\))",
+          "captures": {
+            "1": {
+              "name": "punctuation.paren.haskell"
+            },
+            "2": {
+              "name": "entity.name.function.infix.haskell"
+            },
+            "3": {
+              "name": "punctuation.paren.haskell"
+            }
+          }
+        }
+      ]
+    },
+    "infix_op": {
+      "patterns": [
+        {
+          "match": "(?x)\n  ((?:(?<!'')('')?[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'']*\\.)*)\n    (\\#+|[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+(?<!\\#))",
+          "comment": "In case this regex seems overly general, note that Haskell permits  the definition of new operators which can be nearly any string of  punctuation characters, such as $%^&*.\n",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "2": {
+              "name": "entity.name.namespace.haskell"
+            },
+            "3": {
+              "name": "keyword.operator.infix.haskell"
+            }
+          }
+        },
+        {
+          "match": "(`)((?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'']*\\.)*)([\\p{Ll}\\p{Lu}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'']*)(`)",
+          "captures": {
+            "1": {
+              "name": "punctuation.backtick.haskell"
+            },
+            "2": {
+              "name": "entity.name.namespace.haskell"
+            },
+            "3": {
+              "patterns": [
+                {
+                  "include": "#data_constructor"
+                }
+              ]
+            },
+            "4": {
+              "name": "punctuation.backtick.haskell"
+            }
+          },
+          "comment": "In case this regex seems unusual for an infix operator, note that Haskell\nallows any ordinary function application (elem 4 [1..10]) to be rewritten\nas an infix expression (4 `elem` [1..10]).\n",
+          "name": "keyword.operator.function.infix.haskell"
+        }
+      ]
+    },
+    "module_exports": {
+      "begin": "\\(",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.paren.haskell"
+        }
+      },
+      "end": "\\)",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.paren.haskell"
+        }
+      },
+      "applyEndPatternLast": 1,
+      "name": "meta.declaration.exports.haskell",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "match": "\\b(?<!')(module)\\b(?!')",
+          "captures": {
+            "1": {
+              "name": "keyword.other.module.haskell"
+            }
+          }
+        },
+        {
+          "include": "#comma"
+        },
+        {
+          "include": "#export_constructs"
+        },
+        {
+          "begin": "\\(",
+          "beginCaptures": {
+            "0": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "end": "\\)",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#record_wildcard"
+            },
+            {
+              "match": "(\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\\s*(\\))",
+              "name": "constant.other.operator.prefix.haskell"
+            },
+            {
+              "include": "#export_constructs"
+            },
+            {
+              "include": "#comma"
+            }
+          ]
+        }
+      ]
+    },
+    "export_constructs": {
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "begin": "\\b(?<!')(pattern)\\b(?!')",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.pattern.haskell"
+            }
+          },
+          "end": "(?x)\n   # Data constructor\n   ([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n   # Prefix form of symbolic constructor\n   | (\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*(\\))",
+          "endCaptures": {
+            "1": {
+              "name": "constant.other.haskell"
+            },
+            "2": {
+              "name": "punctuation.paren.haskell"
+            },
+            "3": {
+              "name": "constant.other.operator.prefix.haskell"
+            },
+            "4": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#comment_like"
+            }
+          ]
+        },
+        {
+          "begin": "\\b(?<!')(type)\\b(?!')",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.type.haskell"
+            }
+          },
+          "end": "(?x)\n   # Type name\n   ([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n   # Prefix form of type operator\n   | (\\()\\s*([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*(\\))",
+          "endCaptures": {
+            "1": {
+              "name": "storage.type.haskell"
+            },
+            "2": {
+              "name": "punctuation.paren.haskell"
+            },
+            "3": {
+              "name": "storage.type.operator.haskell"
+            },
+            "4": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#comment_like"
+            }
+          ]
+        },
+        {
+          "include": "#record_wildcard"
+        },
+        {
+          "include": "#reserved_symbol"
+        },
+        {
+          "match": "(\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\\s*(\\))",
+          "name": "storage.type.operator.haskell"
+        },
+        {
+          "match": "(?<!')\\b[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+          "name": "entity.name.function.haskell"
+        },
+        {
+          "match": "(?<!')\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+          "name": "storage.type.haskell"
+        },
+        {
+          "include": "#prefix_op"
+        }
+      ]
+    },
+    "comma": {
+      "match": ",",
+      "name": "punctuation.separator.comma.haskell"
+    },
+    "module_name": {
+      "match": "(?<conid>[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(\\.\\g<conid>)?)",
+      "name": "entity.name.namespace.haskell"
+    },
+    "pragma": {
+      "begin": "\\{-#",
+      "end": "#-\\}",
+      "name": "meta.preprocessor.haskell",
+      "patterns": [
+        {
+          "include": "#comments"
+        },
+        {
+          "begin": "(?xi) \\b(?<!')(LANGUAGE)\\b(?!')",
+          "end": "(?=#-\\})",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.preprocessor.pragma.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#comments"
+            },
+            {
+              "match": "(?x)\n  \\b(?<!')\n  (?:No)?\n  (?:AutoDeriveTypeable|DatatypeContexts|DoRec|IncoherentInstances|MonadFailDesugaring|MonoPatBinds|NullaryTypeClasses|OverlappingInstances|PatternSignatures|RecordPuns|RelaxedPolyRec)\n  \\b(?!')",
+              "name": "invalid.deprecated"
+            },
+            {
+              "match": "(?x)\n  \\b(?<!')\n  (\n  (?:No)?\n  (?:AllowAmbiguousTypes|AlternativeLayoutRuleTransitional|AlternativeLayoutRule|Arrows|BangPatterns|BinaryLiterals|CApiFFI|CPP|CUSKs|ConstrainedClassMethods|ConstraintKinds|DataKinds|DefaultSignatures|DeriveAnyClass|DeriveDataTypeable|DeriveFoldable|DeriveFunctor|DeriveGeneric|DeriveLift|DeriveTraversable|DerivingStrategies|DerivingVia|DisambiguateRecordFields|DoAndIfThenElse|BlockArguments|DuplicateRecordFields|EmptyCase|EmptyDataDecls|EmptyDataDeriving|ExistentialQuantification|ExplicitForAll|ExplicitNamespaces|ExtendedDefaultRules|FlexibleContexts|FlexibleInstances|ForeignFunctionInterface|FunctionalDependencies|GADTSyntax|GADTs|GHCForeignImportPrim|Generali(?:s|z)edNewtypeDeriving|ImplicitParams|ImplicitPrelude|ImportQualifiedPost|ImpredicativeTypes|TypeFamilyDependencies|InstanceSigs|ApplicativeDo|InterruptibleFFI|JavaScriptFFI|KindSignatures|LambdaCase|LexicalNegation|LiberalTypeSynonyms|LinearTypes|MagicHash|MonadComprehensions|MonoLocalBinds|MonomorphismRestriction|MultiParamTypeClasses|MultiWayIf|NumericUnderscores|NPlusKPatterns|NamedFieldPuns|NamedWildCards|NegativeLiterals|HexFloatLiterals|NondecreasingIndentation|NumDecimals|OverloadedLabels|OverloadedLists|OverloadedStrings|PackageImports|ParallelArrays|ParallelListComp|PartialTypeSignatures|PatternGuards|PatternSynonyms|PolyKinds|PolymorphicComponents|QualifiedDo|QuantifiedConstraints|PostfixOperators|QuasiQuotes|Rank2Types|RankNTypes|RebindableSyntax|RecordWildCards|RecursiveDo|RelaxedLayout|RoleAnnotations|ScopedTypeVariables|StandaloneDeriving|StarIsType|StaticPointers|StrictData|Strict|TemplateHaskellQuotes|TemplateHaskell|StandaloneKindSignatures|TraditionalRecordSyntax|TransformListComp|TupleSections|TypeApplications|TypeInType|TypeFamilies|TypeOperators|TypeSynonymInstances|UnboxedTuples|UnboxedSums|UndecidableInstances|UndecidableSuperClasses|UnicodeSyntax|UnliftedFFITypes|UnliftedNewtypes|ViewPatterns|UnliftedDatatypes|OverloadedRecordDot|OverloadedRecordUpdate|FieldSelectors)\n  )\n  \\b(?!')",
+              "captures": {
+                "1": {
+                  "name": "keyword.other.preprocessor.extension.haskell"
+                }
+              }
+            },
+            {
+              "include": "#comma"
+            }
+          ]
+        },
+        {
+          "begin": "(?xi)\n  \\b(?<!')(SPECIALI(?:S|Z)E)\n  (?:\n  \\s*( \\[ [^\\[\\]]* \\])?\\s*\n  |\\s+\n  )\n  (instance)\\b(?!')",
+          "end": "(?=#-\\})",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.preprocessor.pragma.haskell"
+            },
+            "2": {
+              "patterns": [
+                {
+                  "include": "#inline_phase"
+                }
+              ]
+            },
+            "3": {
+              "name": "keyword.other.instance.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        {
+          "begin": "(?xi)\n  \\b(?<!')(SPECIALI(?:S|Z)E)\\b(?!')\n  (?:\\s+(INLINE)\\b(?!'))?\n  (?:\\s*(\\[ [^\\[\\]]* \\])?)\n  \\s*",
+          "end": "(?=#-\\})",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.preprocessor.pragma.haskell"
+            },
+            "2": {
+              "name": "keyword.other.preprocessor.pragma.haskell"
+            },
+            "3": {
+              "patterns": [
+                {
+                  "include": "#inline_phase"
+                }
+              ]
+            }
+          },
+          "patterns": [
+            {
+              "include": "$self"
+            }
+          ]
+        },
+        {
+          "match": "(?xi) \\b(?<!')\n  (LANGUAGE|OPTIONS_GHC|OPTIONS_HADDOCK|OPTIONS|INCLUDE\n  |MINIMAL|UNPACK|OVERLAPS|INCOHERENT\n  |NOUNPACK|SOURCE|OVERLAPPING|OVERLAPPABLE|INLINE\n  |NOINLINE|INLINE?ABLE|CONLIKE|LINE|COLUMN|RULES\n  |COMPLETE)\\b(?!')",
+          "name": "keyword.other.preprocessor.haskell"
+        },
+        {
+          "begin": "(?i)\\b(DEPRECATED|WARNING)\\b",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.preprocessor.pragma.haskell"
+            }
+          },
+          "end": "(?=#-\\})",
+          "patterns": [
+            {
+              "include": "#comments"
+            },
+            {
+              "include": "#string_literal"
+            }
+          ]
+        }
+      ]
+    },
+    "liquid_haskell": {
+      "name": "block.liquidhaskell.haskell",
+      "begin": "\\{-@",
+      "end": "@-\\}",
+      "patterns": [
+        {
+          "include": "$self"
+        }
+      ]
+    },
+    "data_context": {
+      "match": "(?x)\n  (.*)\n  (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n  (=>|⇒)\n  (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n",
+      "captures": {
+        "1": {
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#forall"
+            },
+            {
+              "begin": "(?='?\\()",
+              "end": "(?=\\))",
+              "patterns": [
+                {
+                  "include": "#type_signature"
+                }
+              ]
+            },
+            {
+              "begin": "(?='?\\[)",
+              "end": "(?=\\])",
+              "patterns": [
+                {
+                  "include": "#type_signature"
+                }
+              ]
+            },
+            {
+              "match": "(?x)\n  (\\S*)\\s*\n  (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n  (::|∷|=)\n  (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])",
+              "captures": {
+                "1": {
+                  "patterns": [
+                    {
+                      "include": "#comment_like"
+                    },
+                    {
+                      "include": "#forall"
+                    },
+                    {
+                      "include": "#record_decl_field"
+                    }
+                  ]
+                },
+                "2": {
+                  "patterns": [
+                    {
+                      "include": "#reserved_symbol"
+                    }
+                  ]
+                },
+                "3": {
+                  "patterns": [
+                    {
+                      "include": "#type_signature"
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        "2": {
+          "name": "keyword.operator.big-arrow.haskell"
+        }
+      }
+    },
+    "data_constructor": {
+      "patterns": [
+        {
+          "match": "\\b(?<!')[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*(?![\\.'\\w])",
+          "name": "constant.other.haskell"
+        },
+        {
+          "match": "(\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\\s*(\\))",
+          "name": "constant.other.operator.haskell"
+        }
+      ]
+    },
+    "qualifier": {
+      "match": "\\b(?<!')[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.",
+      "name": "entity.name.namespace.haskell"
+    },
+    "record_decl": {
+      "begin": "({)(?!-)",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.brace.haskell"
+        }
+      },
+      "end": "(?<!-)(})",
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.brace.haskell"
+        }
+      },
+      "name": "meta.record.definition.haskell",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#record_decl_field"
+        }
+      ]
+    },
+    "record": {
+      "begin": "({)(?!-)",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.brace.haskell"
+        }
+      },
+      "end": "(?<!-)(})",
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.brace.haskell"
+        }
+      },
+      "name": "meta.record.haskell",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#record_field"
+        }
+      ]
+    },
+    "record_decl_field": {
+      "begin": "(?x)\n  (?:([\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n    |(\\()\\s*([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*(\\))\n  )\n",
+      "end": "(,)|(?=})",
+      "beginCaptures": {
+        "1": {
+          "name": "variable.other.member.definition.haskell"
+        },
+        "2": {
+          "name": "punctuation.paren.haskell"
+        },
+        "3": {
+          "name": "variable.other.member.definition.haskell"
+        },
+        "4": {
+          "name": "punctuation.paren.haskell"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.comma.haskell"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#comma"
+        },
+        {
+          "include": "#double_colon"
+        },
+        {
+          "include": "#type_signature"
+        },
+        {
+          "include": "#record_decl_field"
+        }
+      ]
+    },
+    "record_wildcard": {
+      "match": "(?x)\n  (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n  (\\.\\.)\n  (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])",
+      "captures": {
+        "1": {
+          "name": "variable.other.member.wildcard.haskell"
+        }
+      }
+    },
+    "record_field": {
+      "patterns": [
+        {
+          "begin": "(?x)\n  (?:([\\p{Ll}\\p{Lu}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\.']*)\n    |(\\()\\s*([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*(\\))\n  )\n",
+          "end": "(,)|(?=})",
+          "beginCaptures": {
+            "1": {
+              "name": "variable.other.member.haskell",
+              "patterns": [
+                {
+                  "include": "#qualifier"
+                }
+              ]
+            },
+            "2": {
+              "name": "punctuation.paren.haskell"
+            },
+            "3": {
+              "name": "variable.other.member.haskell"
+            },
+            "4": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.comma.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#comma"
+            },
+            {
+              "include": "$self"
+            }
+          ]
+        },
+        {
+          "include": "#record_wildcard"
+        }
+      ]
+    },
+    "role_annotation": {
+      "patterns": [
+        {
+          "begin": "^(\\s*)(type)\\s+(role)\\b(?!')",
+          "beginCaptures": {
+            "2": {
+              "name": "keyword.other.type.haskell"
+            },
+            "3": {
+              "name": "keyword.other.role.haskell"
+            }
+          },
+          "end": "(?x) # Detect end of block by decreasing indentation:\n  (?=\\}|;)       # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )",
+          "name": "meta.role-annotation.haskell",
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#type_constructor"
+            },
+            {
+              "match": "\\b(?<!')(nominal|representational|phantom)\\b(?!')",
+              "captures": {
+                "1": {
+                  "name": "keyword.other.role.$1.haskell"
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "fun_decl": {
+      "begin": "(?x)^(\\s*)\n  (?<fn>\n    (?:\n      [\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\#*\n    | \\(\\s*\n        (?!--+\\))\n        [\\p{S}\\p{P}&&[^(),:;\\[\\]`{}_\"']]\n        [\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*\n      \\s*\\)\n    )\n    (?:\\s*,\\s*\\g<fn>)?\n  )\n  \\s*(?<![\\p{S}\\p{P}&&[^\\),;\\]`}_\"']])(::|∷)(?![\\p{S}\\p{P}&&[^\\(,;\\[`{_\"']])\n",
+      "beginCaptures": {
+        "2": {
+          "name": "entity.name.function.haskell",
+          "patterns": [
+            {
+              "include": "#reserved_symbol"
+            },
+            {
+              "include": "#prefix_op"
+            }
+          ]
+        },
+        "3": {
+          "name": "keyword.operator.double-colon.haskell"
+        }
+      },
+      "name": "meta.function.type-declaration.haskell",
+      "patterns": [
+        {
+          "include": "#type_signature"
+        }
+      ],
+      "end": "(?x)\n  # End of type annotation:\n    # To the left of a reserved symbolic keyword such as = or <-\n  (?= \n      # non-symbolic character\n      (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n      # symbolic keyword except (->)\n      ((<-|←)|(=)|(-<|↢)|(-<<|⤛))\n      # non-symbolic character\n      ([(),;\\[\\]`{}_\"']|[^\\p{S}\\p{P}])\n  )\n  # Decreasing indentation:\n  |(?=\\}|;)      # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )\n"
+    },
+    "adt_constructor": {
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "begin": "(?x)\n  (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n  (?:(=)|(\\|))\n  (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])  # non-symbol",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.eq.haskell"
+            },
+            "2": {
+              "name": "keyword.operator.pipe.haskell"
+            }
+          },
+          "end": "(?x)\n  (?: # Infix data constructor\n    # First argument\n    (?:\n    # Simple type\n      (?<!')\\b((?:[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'\\.])+)\n    # Type inside balanced parentheses\n    | ('? # Optional promotion tick\n        (?<paren>\n          \\(          # Opening parenthesis\n          (?:\n            [^\\(\\)]*  # Match non-parentheses\n          | \\g<paren> # or recurse into further depth\n          )*\n          \\)          # Closing parenthesis\n        )\n      )\n    # Type inside balanced brackets\n    | ('? # Optional promotion tick\n        (?<brac>\n          \\[          # Opening bracket\n          (?:\n            [^\\[\\]]*  # Match non-brackets\n          | \\g<brac>  # or recurse into further depth\n          )*\n          \\]          # Closing bracket\n        )\n      )\n    )\n    # Then either\n    \\s*\n      # - a symbolic infix constructor, or\n    (?:(?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\n      # - an alphabetic infix constructor\n    | (`)([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)(`)\n    )\n  ) # Otherwise, prefix data constructor, either:\n  | # - an alphabetic data constructor e.g. \"Cons_123\"\n    (?:(?<!')\\b([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*))\n  | # - a symbolic (prefix) data constructor\n    (\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\\s*(\\))\n  | # Otherwise, try to fail early to avoid excessive backtracking (https://github.com/JustusAdam/language-haskell/issues/161)\n      # Fail when detecting a lowercase identifier and then something not starting with a tick or colon\n      (?=\\b(?<!')(?!(?:forall|deriving)\\s)[\\p{Ll}_]\\S+\\s+[^`:])\n      # Fail when seeing another equal signs or pipe symbol\n     |(?=\n        (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]) # non-symbol\n        (?:=|\\|)\n        (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])  # non-symbol\n      )",
+          "endCaptures": {
+            "1": {
+              "patterns": [
+                {
+                  "include": "#type_signature"
+                }
+              ]
+            },
+            "2": {
+              "patterns": [
+                {
+                  "include": "#type_signature"
+                }
+              ]
+            },
+            "4": {
+              "patterns": [
+                {
+                  "include": "#type_signature"
+                }
+              ]
+            },
+            "6": {
+              "name": "constant.other.operator.infix.haskell"
+            },
+            "7": {
+              "name": "punctuation.backtick.haskell"
+            },
+            "8": {
+              "name": "constant.other.infix.haskell"
+            },
+            "9": {
+              "name": "punctuation.backtick.haskell"
+            },
+            "10": {
+              "name": "constant.other.haskell"
+            },
+            "11": {
+              "name": "punctuation.paren.haskell"
+            },
+            "12": {
+              "name": "constant.other.operator.prefix.haskell"
+            },
+            "13": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#deriving"
+            },
+            {
+              "include": "#record_decl"
+            },
+            {
+              "include": "#forall"
+            },
+            {
+              "include": "#data_context"
+            },
+            {
+              "include": "#type_signature"
+            }
+          ]
+        }
+      ]
+    },
+    "gadt_constructor": {
+      "patterns": [
+        {
+          "begin": "(?x)\n   ^(\\s*)\n      (?:\n        (\\b(?<!')[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n      |(\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\\s*(\\))\n      )",
+          "beginCaptures": {
+            "2": {
+              "name": "constant.other.haskell"
+            },
+            "3": {
+              "name": "punctuation.paren.haskell"
+            },
+            "4": {
+              "name": "constant.other.operator.prefix.haskell"
+            },
+            "5": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "end": "(?x)\n  # GADT constructor ends\n  (?=\\b(?<!'')deriving\\b(?!'))  \n        # Decreasing indentation\n  |(?=\\}|;)      # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )\n",
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#deriving"
+            },
+            {
+              "include": "#double_colon"
+            },
+            {
+              "include": "#record_decl"
+            },
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        {
+          "begin": "(?x)\n  (\\b(?<!')[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}]*) # named constructor\n |(\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\\s*(\\))    # prefix operator",
+          "beginCaptures": {
+            "1": {
+              "name": "constant.other.haskell"
+            },
+            "2": {
+              "name": "punctuation.paren.haskell"
+            },
+            "3": {
+              "name": "constant.other.operator.prefix.haskell"
+            },
+            "4": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "end": "(?=;|\\}|$)",
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#deriving"
+            },
+            {
+              "include": "#double_colon"
+            },
+            {
+              "include": "#record_decl"
+            },
+            {
+              "include": "#type_signature"
+            }
+          ]
+        }
+      ]
+    },
+    "type_application": {
+      "patterns": [
+        {
+          "begin": "(?<=[\\s,;\\[\\]{}\"])(@)(')?(\\()",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.prefix.at.haskell"
+            },
+            "2": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "3": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "end": "\\)",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "name": "meta.type-application.haskell",
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        {
+          "begin": "(?<=[\\s,;\\[\\]{}\"])(@)(')?(\\[)",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.prefix.at.haskell"
+            },
+            "2": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "3": {
+              "name": "punctuation.bracket.haskell"
+            }
+          },
+          "end": "\\]",
+          "name": "meta.type-application.haskell",
+          "endCaptures": {
+            "0": {
+              "name": "punctuation.bracket.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        {
+          "begin": "(?<=[\\s,;\\[\\]{}\"])(@)(?=\\\")",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.prefix.at.haskell"
+            }
+          },
+          "end": "(?<=\\\")",
+          "name": "meta.type-application.haskell",
+          "patterns": [
+            {
+              "include": "#string_literal"
+            }
+          ]
+        },
+        {
+          "begin": "(?<=[\\s,;\\[\\]{}\"])(@)(?=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.prefix.at.haskell"
+            }
+          },
+          "end": "(?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])",
+          "name": "meta.type-application.haskell",
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        }
+      ]
+    },
+    "type_signature": {
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "match": "(')?(\\()\\s*(\\))",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "2": {
+              "name": "punctuation.paren.haskell"
+            },
+            "3": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "name": "support.constant.unit.haskell"
+        },
+        {
+          "match": "(\\()(#)\\s*(#)(\\))",
+          "name": "support.constant.unit.unboxed.haskell",
+          "captures": {
+            "1": {
+              "name": "punctuation.paren.haskell"
+            },
+            "2": {
+              "name": "keyword.operator.hash.haskell"
+            },
+            "3": {
+              "name": "keyword.operator.hash.haskell"
+            },
+            "4": {
+              "name": "punctuation.paren.haskell"
+            }
+          }
+        },
+        {
+          "match": "(')?(\\()\\s*,[\\s,]*(\\))",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "2": {
+              "name": "punctuation.paren.haskell"
+            },
+            "3": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "name": "support.constant.tuple.haskell"
+        },
+        {
+          "match": "(\\()(#)\\s*(#)(\\))",
+          "name": "support.constant.unit.unboxed.haskell",
+          "captures": {
+            "1": {
+              "name": "punctuation.paren.haskell"
+            },
+            "2": {
+              "name": "keyword.operator.hash.haskell"
+            },
+            "3": {
+              "name": "keyword.operator.hash.haskell"
+            },
+            "4": {
+              "name": "punctuation.paren.haskell"
+            }
+          }
+        },
+        {
+          "match": "(\\()(#)\\s*,[\\s,]*(#)(\\))",
+          "captures": {
+            "1": {
+              "name": "punctuation.paren.haskell"
+            },
+            "2": {
+              "name": "keyword.operator.hash.haskell"
+            },
+            "3": {
+              "name": "keyword.operator.hash.haskell"
+            },
+            "4": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "name": "support.constant.tuple.unboxed.haskell"
+        },
+        {
+          "match": "(')?(\\[)\\s*(\\])",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "2": {
+              "name": "punctuation.bracket.haskell"
+            },
+            "3": {
+              "name": "punctuation.bracket.haskell"
+            }
+          },
+          "name": "support.constant.empty-list.haskell"
+        },
+        {
+          "include": "#integer_literals"
+        },
+        {
+          "match": "(::|∷)(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])",
+          "name": "keyword.operator.double-colon.haskell"
+        },
+        {
+          "include": "#forall"
+        },
+        {
+          "match": "=>|⇒",
+          "name": "keyword.operator.big-arrow.haskell"
+        },
+        {
+          "include": "#string_literal"
+        },
+        {
+          "match": "'[^']'",
+          "name": "invalid"
+        },
+        {
+          "include": "#type_application"
+        },
+        {
+          "include": "#reserved_symbol"
+        },
+        {
+          "include": "#type_operator"
+        },
+        {
+          "include": "#type_constructor"
+        },
+        {
+          "begin": "(\\()(#)",
+          "end": "(#)(\\))",
+          "beginCaptures": {
+            "1": {
+              "name": "punctuation.paren.haskell"
+            },
+            "2": {
+              "name": "keyword.operator.hash.haskell"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "keyword.operator.hash.haskell"
+            },
+            "2": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#comma"
+            },
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        {
+          "begin": "(')?(\\()",
+          "end": "(\\))",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "2": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.paren.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#comma"
+            },
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        {
+          "begin": "(')?(\\[)",
+          "end": "(\\])",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "2": {
+              "name": "punctuation.bracket.haskell"
+            }
+          },
+          "endCaptures": {
+            "1": {
+              "name": "punctuation.bracket.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "include": "#comma"
+            },
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        {
+          "include": "#type_variable"
+        }
+      ]
+    },
+    "double_colon": {
+      "match": "\\s*(::|∷)(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\\s*",
+      "captures": {
+        "1": {
+          "name": "keyword.operator.double-colon.haskell"
+        }
+      }
+    },
+    "start_type_signature": {
+      "patterns": [
+        {
+          "begin": "^(\\s*)(::|∷)(?![\\p{S}\\p{P}&&[^\\(,;\\[`{_\"']])\\s*",
+          "beginCaptures": {
+            "2": {
+              "name": "keyword.operator.double-colon.haskell"
+            }
+          },
+          "end": "(?x)\n  # End type annotation when seeing one of:\n  (?=\n    \\#?\\)                             # closing parenthesis\n    |\\]                               # closing bracket\n    |,                                # comma\n    |(?<!')\\b(in|then|else|of)\\b(?!') # keyword\n    |                                 # symbolic keyword except (->)\n      (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n      (?:\n         (\\\\|λ)\n        |(<-|←)\n        |(=)\n        |(-<|↢)\n        |(-<<|⤛)\n      )\n      ([(),;\\[\\]`{}_\"']|[^\\p{S}\\p{P}])\n    |(\\#|@)-\\}                             # End of annotation block (LiquidHaskell or pragma)\n    # Decreasing indentation:\n    | (?=\\}|;)     # Explicit indentation\n    |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n        \\1\\s*\\S    # - equally indented, or\n      | \\s*        # - starts with whitespace, followed by:\n        (?: $      #   - the end of the line (i.e. empty line), or\n        |\\{-[^@]   #   - the start of a block comment, or\n        |--+       #   - the start of a single-line comment.\n           (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                   # The double dash may not be followed by other operator characters\n                   # (then it would be an operator, not a comment)\n      )\n  )",
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ],
+          "name": "meta.type-declaration.haskell"
+        },
+        {
+          "begin": "(?<![\\p{S}\\p{P}&&[^\\(,;\\[`{_\"']])(::|∷)(?![\\p{S}\\p{P}&&[^\\(,;\\[`{_\"']])",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.double-colon.haskell"
+            }
+          },
+          "end": "(?x)\n  # End type annotation when seeing one of:\n  (?=\n    \\#?\\)                             # closing parenthesis\n    |\\]                               # closing bracket\n    |,                                # comma\n    |\\b(?<!')(in|then|else|of)\\b(?!') # keyword\n    |(\\#|@)-\\}                        # End of annotation block (LiquidHaskell or pragma)\n    |                                 # symbolic keyword except (->)\n      (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n      (?:\n         (\\\\|λ)\n        |(<-|←)\n        |(=)\n        |(-<|↢)\n        |(-<<|⤛)\n      )\n      ([(),;\\[\\]`{}_\"']|[^\\p{S}\\p{P}])\n    # Indentation \n    |(?=\\}|;)      # Explicit indentation\n    |$             # End of line\n  )",
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        }
+      ]
+    },
+    "type_variable": {
+      "match": "\\b(?<!')(?!(?:forall|deriving)\\b(?!'))[\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*",
+      "name": "variable.other.generic-type.haskell"
+    },
+    "type_constructor": {
+      "patterns": [
+        {
+          "match": "(?x)\n  # Optional promotion tick\n    (')?\n  # Optional qualified name\n    ((?:\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.)*)\n  # Type constructor proper\n    (\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "2": {
+              "name": "entity.name.namespace.haskell"
+            },
+            "3": {
+              "name": "storage.type.haskell"
+            }
+          }
+        },
+        {
+          "match": "(?x)\n  # Optional promotion tick\n    (')?\n  # Opening parenthesis\n    (\\()\\s*\n  # Optional qualified name\n    ((?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.)*)\n  # Type operator proper\n    ([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\n  # Closing parenthesis\n    \\s*(\\))",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "2": {
+              "name": "punctuation.paren.haskell"
+            },
+            "3": {
+              "name": "entity.name.namespace.haskell"
+            },
+            "4": {
+              "name": "storage.type.operator.haskell"
+            },
+            "5": {
+              "name": "punctuation.paren.haskell"
+            }
+          }
+        }
+      ]
+    },
+    "overloaded_label": {
+      "patterns": [
+        {
+          "match": "(?x) \n  (?<![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\p{S}\\p{P}&&[^(,;\\[`{]]) # Disallow closing characters\n  (\\#)\n    (?:\n    # String\n    (\"(?:\\\\\"|[^\"])*\")\n    # Sequence of allowed label identifiers\n    |[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'\\.]+\n    )",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.prefix.hash.haskell"
+            },
+            "2": {
+              "patterns": [
+                {
+                  "include": "#string_literal"
+                }
+              ]
+            }
+          },
+          "name": "entity.name.label.haskell"
+        }
+      ]
+    },
+    "reserved_symbol": {
+      "patterns": [
+        {
+          "match": "(?x)\n  (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"'']])\n  (?:\n     (\\.\\.)\n    |(:)\n    |(=)\n    |(\\\\)     # λ not reserved as it is a letter\n    |(\\|)\n    |(<-|←)\n    |(->|→)\n    |(-<|↢)\n    |(-<<|⤛)\n    |(>-|⤚)\n    |(>>-|⤜)\n  )\n  (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"'']])",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.double-dot.haskell"
+            },
+            "2": {
+              "name": "keyword.operator.colon.haskell"
+            },
+            "3": {
+              "name": "keyword.operator.eq.haskell"
+            },
+            "4": {
+              "name": "keyword.operator.lambda.haskell"
+            },
+            "5": {
+              "name": "keyword.operator.pipe.haskell"
+            },
+            "6": {
+              "name": "keyword.operator.arrow.left.haskell"
+            },
+            "7": {
+              "name": "keyword.operator.arrow.haskell"
+            },
+            "8": {
+              "name": "keyword.operator.arrow.left.tail.haskell"
+            },
+            "9": {
+              "name": "keyword.operator.arrow.left.tail.double.haskell"
+            },
+            "10": {
+              "name": "keyword.operator.arrow.tail.haskell"
+            },
+            "11": {
+              "name": "keyword.operator.arrow.tail.double.haskell"
+            }
+          }
+        },
+        {
+          "match": "(?x)\n  (?<=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\p{S}\\p{P}&&[^\\#,;\\[`{]]) # Require closing characters\n  (\\#+)\n  (?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\p{S}\\p{P}&&[^),;\\]`}]])   # Disallow opening character",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.postfix.hash.haskell"
+            }
+          }
+        },
+        {
+          "match": "(?x)\n  (?<=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'\\)\\}\\]]) # Require closing characters\n  (@)\n  (?=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'\\(\\[\\{]) # Require opening character",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.infix.tight.at.haskell"
+            }
+          }
+        },
+        {
+          "match": "(?x)\n  (?<![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}\\p{S}\\p{P}&&[^(,;\\[`{]])  # Disallow closing characters\n  (?:(~)|(!)|(-)|(\\$\\$)|(\\$)|(%))\n  (?=[\\p{Ll}_'\\p{Lu}\\p{Lt}\\p{Nd}\\(\\{\\[]) # Require opening character (non operator symbol)",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.prefix.tilde.haskell"
+            },
+            "2": {
+              "name": "keyword.operator.prefix.bang.haskell"
+            },
+            "3": {
+              "name": "keyword.operator.prefix.minus.haskell"
+            },
+            "4": {
+              "name": "keyword.operator.prefix.double-dollar.haskell"
+            },
+            "5": {
+              "name": "keyword.operator.prefix.dollar.haskell"
+            },
+            "6": {
+              "name": "keyword.operator.prefix.modifier.haskell"
+            }
+          }
+        }
+      ]
+    },
+    "type_operator": {
+      "patterns": [
+        {
+          "match": "(?x)\n  # Optional promotion tick\n    (?:(?<!')('))?\n  # Optional qualified name\n    ((?:\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.)*)\n  # Type operator proper\n    (?![#@]?-})(\\#+|[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+(?<!\\#))\n    #((?:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']&&[^#@]]|[@#](?!-}))+)",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "2": {
+              "name": "entity.name.namespace.haskell"
+            },
+            "3": {
+              "name": "storage.type.operator.infix.haskell"
+            }
+          }
+        },
+        {
+          "match": "(?x)\n  # Optional promotion tick\n    (')?\n  # Opening backtick\n    (\\`)\n  # Optional qualified name\n    ((?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.)*)\n  # Type constructor proper\n    ([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\n  # Closing backtick\n    (`)",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.promotion.haskell"
+            },
+            "2": {
+              "name": "punctuation.backtick.haskell"
+            },
+            "3": {
+              "name": "entity.name.namespace.haskell"
+            },
+            "4": {
+              "name": "storage.type.infix.haskell"
+            },
+            "5": {
+              "name": "punctuation.backtick.haskell"
+            }
+          }
+        }
+      ]
+    },
+    "forall": {
+      "begin": "(?x)\n  # Alphabetic forall\n  (?:\n  \\b(?<!')\n  (forall)\n  \\b(?!')\n  )\n  |\n  # Symbolic forall\n  (?:\n  # Not preceded by a symbol except reserved symbols\n  (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"'']])\n  (∀)\n  # Not followed by a symbol except reserved symbols\n  (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"'']])\n  )",
+      "end": "(\\.)|(->|→)",
+      "beginCaptures": {
+        "1": {
+          "name": "keyword.other.forall.haskell"
+        },
+        "2": {
+          "name": "keyword.other.forall.haskell"
+        }
+      },
+      "endCaptures": {
+        "1": {
+          "name": "keyword.operator.period.haskell"
+        },
+        "2": {
+          "name": "keyword.operator.arrow.haskell"
+        }
+      },
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#type_variable"
+        },
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    "string_literal": {
+      "begin": "\"",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.begin.haskell"
+        }
+      },
+      "end": "\"",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.definition.string.end.haskell"
+        }
+      },
+      "name": "string.quoted.double.haskell",
+      "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.haskell"
+        },
+        {
+          "match": "\\\\o[0-7]+|\\\\x[0-9A-Fa-f]+|\\\\[0-9]+",
+          "name": "constant.character.escape.octal.haskell"
+        },
+        {
+          "match": "\\\\\\^[A-Z@\\[\\]\\\\\\^_]",
+          "name": "constant.character.escape.control.haskell"
+        },
+        {
+          "begin": "\\\\\\s",
+          "beginCaptures": {
+            "0": {
+              "name": "constant.character.escape.begin.haskell"
+            }
+          },
+          "end": "\\\\",
+          "endCaptures": {
+            "0": {
+              "name": "constant.character.escape.end.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "match": "\\S+",
+              "name": "invalid.illegal.character-not-allowed-here.haskell"
+            }
+          ]
+        }
+      ]
+    },
+    "char_literal": {
+      "captures": {
+        "1": {
+          "name": "punctuation.definition.string.begin.haskell"
+        },
+        "2": {
+          "name": "constant.character.escape.haskell"
+        },
+        "3": {
+          "name": "constant.character.escape.octal.haskell"
+        },
+        "4": {
+          "name": "constant.character.escape.hexadecimal.haskell"
+        },
+        "5": {
+          "name": "constant.character.escape.control.haskell"
+        },
+        "6": {
+          "name": "punctuation.definition.string.end.haskell"
+        }
+      },
+      "match": "(?x)\n  (?<![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}'])\n  (')\n  (?:\n    [\\ -\\[\\]-~]                         # Basic Char\n  | (\\\\(?:NUL|SOH|STX|ETX|EOT|ENQ|ACK|BEL|BS|HT|LF|VT|FF|CR|SO|SI|DLE\n       |DC1|DC2|DC3|DC4|NAK|SYN|ETB|CAN|EM|SUB|ESC|FS|GS|RS\n       |US|SP|DEL|[abfnrtv\\\\\\\"'\\\\&]))   # Escapes\n  | (\\\\o[0-7]+)                         # Octal Escapes\n  | (\\\\x[0-9A-Fa-f]+)                   # Hexadecimal Escapes\n  | (\\\\\\^[A-Z@\\[\\]\\\\\\^_])                 # Control Chars\n  )\n  (')\n",
+      "name": "string.quoted.single.haskell"
+    },
+    "float_literals": {
+      "comment": "Floats are decimal or hexadecimal",
+      "match": "(?x)\n  \\b(?<!')\n  (?:  # Decimal\n    ([0-9][_0-9]*\\.[0-9][_0-9]*(?:[eE][-+]?[0-9][_0-9]*)?\n    |[0-9][_0-9]*[eE][-+]?[0-9][_0-9]*\n    )\n  |    # Hexadecimal\n    (0[xX]_*[0-9a-fA-F][_0-9a-fA-F]*\\.[0-9a-fA-F][_0-9a-fA-F]*(?:[pP][-+]?[0-9][_0-9]*)?\n    |0[xX]_*[0-9a-fA-F][_0-9a-fA-F]*[pP][-+]?[0-9][_0-9]*\n    )\n  )\\b(?!')",
+      "captures": {
+        "1": {
+          "name": "constant.numeric.floating.decimal.haskell"
+        },
+        "2": {
+          "name": "constant.numeric.floating.hexadecimal.haskell"
+        }
+      }
+    },
+    "integer_literals": {
+      "match": "(?x)\n  \\b(?<!')\n  (?:\n    ([0-9][_0-9]*)                    # Decimal integer\n  | (0[xX]_*[0-9a-fA-F][_0-9a-fA-F]*) # Hexadecimal integer\n  | (0[oO]_*[0-7][_0-7]*)             # Octal integer\n  | (0[bB]_*[01][_01]*)               # Binary integer\n  )\n  \\b(?!')",
+      "captures": {
+        "1": {
+          "name": "constant.numeric.integral.decimal.haskell"
+        },
+        "2": {
+          "name": "constant.numeric.integral.hexadecimal.haskell"
+        },
+        "3": {
+          "name": "constant.numeric.integral.octal.haskell"
+        },
+        "4": {
+          "name": "constant.numeric.integral.binary.haskell"
+        }
+      }
+    },
+    "numeric_literals": {
+      "patterns": [
+        {
+          "include": "#float_literals"
+        },
+        {
+          "include": "#integer_literals"
+        }
+      ]
+    },
+    "ffi": {
+      "begin": "^(\\s*)(foreign)\\s+(import|export)\\s+",
+      "beginCaptures": {
+        "2": {
+          "name": "keyword.other.foreign.haskell"
+        },
+        "3": {
+          "name": "keyword.other.$3.haskell"
+        }
+      },
+      "name": "meta.$3.foreign.haskell",
+      "end": "(?x) # Detect end of FFI block by decreasing indentation:\n  (?=\\}|;)       # Explicit indentation\n  |^(?!          # Implicit indentation: end match on newline *unless* the new line is either:\n      \\1\\s+\\S    # - more indented, or\n    | \\s*        # - starts with whitespace, followed by:\n      (?: $      #   - the end of the line (i.e. empty line), or\n      |\\{-[^@]   #   - the start of a block comment, or\n      |--+       #   - the start of a single-line comment.\n         (?![\\p{S}\\p{P}&&[^(),;\\[\\]{}`_\"']]).*$) # non-symbol\n                 # The double dash may not be followed by other operator characters\n                 # (then it would be an operator, not a comment)\n    )\n",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "match": "\\b(?<!')(ccall|cplusplus|dotnet|jvm|stdcall|prim|capi)\\s+",
+          "captures": {
+            "1": {
+              "name": "keyword.other.calling-convention.$1.haskell"
+            }
+          }
+        },
+        {
+          "begin": "(?=\")|(?=\\b(?<!')([\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\\b(?!'))",
+          "end": "(?=(::|∷)(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]))",
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "match": "(?x)\n  \\b(?<!')(safe|unsafe|interruptible)\\b(?!')\n  \\s*\n  (\"(?:\\\\\"|[^\"])*\")?\n  \\s*\n  (?:\n    (?:\\b(?<!'')([\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\\b(?!'))\n   |(?:\\(\\s*(?!--+\\))([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*\\))\n  )\n",
+              "captures": {
+                "1": {
+                  "name": "keyword.other.safety.$1.haskell"
+                },
+                "2": {
+                  "name": "entity.name.foreign.haskell",
+                  "patterns": [
+                    {
+                      "include": "#string_literal"
+                    }
+                  ]
+                },
+                "3": {
+                  "name": "entity.name.function.haskell"
+                },
+                "4": {
+                  "name": "entity.name.function.infix.haskell"
+                }
+              }
+            },
+            {
+              "match": "(?x)\n  \\b(?<!')(safe|unsafe|interruptible)\\b(?!')\n  \\s*\n  (\"(?:\\\\\"|[^\"])*\")?\n  \\s*$\n",
+              "captures": {
+                "1": {
+                  "name": "keyword.other.safety.$1.haskell"
+                },
+                "2": {
+                  "name": "entity.name.foreign.haskell",
+                  "patterns": [
+                    {
+                      "include": "#string_literal"
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              "match": "(?x)\n  \"(?:\\\\\"|[^\"])*\"",
+              "captures": {
+                "0": {
+                  "name": "entity.name.foreign.haskell",
+                  "patterns": [
+                    {
+                      "include": "#string_literal"
+                    }
+                  ]
+                }
+              }
+            },
+            {
+              "match": "(?x)\n   (?:\\b(?<!'')([\\p{Ll}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*)\\b(?!'))\n  |(?:(\\()\\s*(?!--+\\))([\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]+)\\s*(\\)))\n",
+              "captures": {
+                "1": {
+                  "name": "entity.name.function.haskell"
+                },
+                "2": {
+                  "name": "punctuation.paren.haskell"
+                },
+                "3": {
+                  "name": "entity.name.function.infix.haskell"
+                },
+                "4": {
+                  "name": "punctuation.paren.haskell"
+                }
+              }
+            }
+          ]
+        },
+        {
+          "include": "#double_colon"
+        },
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    "inline_phase": {
+      "begin": "\\[",
+      "beginCaptures": {
+        "0": {
+          "name": "punctuation.bracket.haskell"
+        }
+      },
+      "end": "\\]",
+      "endCaptures": {
+        "0": {
+          "name": "punctuation.bracket.haskell"
+        }
+      },
+      "name": "meta.inlining-phase.haskell",
+      "patterns": [
+        {
+          "match": "~",
+          "name": "punctuation.tilde.haskell"
+        },
+        {
+          "include": "#integer_literals"
+        },
+        {
+          "match": "\\w*",
+          "name": "invalid"
+        }
+      ]
+    },
+    "quasi_quote": {
+      "patterns": [
+        {
+          "begin": "(?x)\n  (\\[)\n  (e|d|p)?\n  (\\|(?:\\|(?!\\]))?)",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.quasi-quotation.begin.haskell"
+            },
+            "2": {
+              "name": "entity.name.quasi-quoter.haskell"
+            },
+            "3": {
+              "name": "keyword.operator.quasi-quotation.begin.haskell"
+            }
+          },
+          "end": "\\3\\]",
+          "endCaptures": {
+            "0": {
+              "name": "keyword.operator.quasi-quotation.end.haskell"
+            }
+          },
+          "name": "meta.quasi-quotation.haskell",
+          "patterns": [
+            {
+              "include": "$self"
+            }
+          ]
+        },
+        {
+          "begin": "(?x)\n  (\\[)\n  (t)\n  (\\|(?:\\|(?!\\]))?)",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.quasi-quotation.begin.haskell"
+            },
+            "2": {
+              "name": "entity.name.quasi-quoter.haskell"
+            },
+            "3": {
+              "name": "keyword.operator.quasi-quotation.begin.haskell"
+            }
+          },
+          "end": "\\3\\]",
+          "endCaptures": {
+            "0": {
+              "name": "keyword.operator.quasi-quotation.end.haskell"
+            }
+          },
+          "name": "meta.quasi-quotation.haskell",
+          "patterns": [
+            {
+              "include": "#type_signature"
+            }
+          ]
+        },
+        {
+          "begin": "(?x)\n  (\\[)\n  (?:(\\$\\$)|(\\$))?\n  (?!'\\|')                                             # Don't parse ['|'...] as a quasi quotation\n  ((?:[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Nd}']*\\.)*) # Optional qualifier\n  ((?:[^\\s\\p{S}\\p{P}]|['_])*)                          # Quasi-quoter\n  (\\|)",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.quasi-quotation.begin.haskell"
+            },
+            "2": {
+              "name": "keyword.operator.prefix.double-dollar.haskell"
+            },
+            "3": {
+              "name": "keyword.operator.prefix.dollar.haskell"
+            },
+            "4": {
+              "name": "entity.name.namespace.haskell"
+            },
+            "5": {
+              "name": "entity.name.quasi-quoter.haskell"
+            },
+            "6": {
+              "name": "keyword.operator.quasi-quotation.begin.haskell"
+            }
+          },
+          "end": "\\|\\]",
+          "endCaptures": {
+            "0": {
+              "name": "keyword.operator.quasi-quotation.end.haskell"
+            }
+          },
+          "name": "meta.quasi-quotation.haskell meta.embedded.block.$5"
+        }
+      ]
+    }
+  },
+  "scopeName": "source.haskell",
+  "uuid": "5C034675-1F6D-497E-8073-369D37E2FD7D"
+}