diff --git a/resources/licenses/language-haskell/LICENSE.txt b/resources/licenses/language-haskell/LICENSE.txt
new file mode 100644
index 00000000000..d071fb9ef84
--- /dev/null
+++ b/resources/licenses/language-haskell/LICENSE.txt
@@ -0,0 +1,30 @@
+Copyright (c) 2017 Justus Adam
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Justus Adam nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/resources/licenses/language-haskell/UPSTREAM.txt b/resources/licenses/language-haskell/UPSTREAM.txt
new file mode 100644
index 00000000000..131f49c16f2
--- /dev/null
+++ b/resources/licenses/language-haskell/UPSTREAM.txt
@@ -0,0 +1,4 @@
+Source: https://github.com/haskell/language-haskell
+Version: 3.8.0 (commit 417bdaf7d997b8561d8d52066120faca395a1ec7)
+Grammar: syntaxes/haskell.YAML-tmLanguage, converted to JSON without changing its content.
+License: BSD-3-Clause; the full upstream license is in LICENSE.txt.
diff --git a/src/renderer/src/lib/monaco-languages/haskell-highlighting.test.ts b/src/renderer/src/lib/monaco-languages/haskell-highlighting.test.ts
new file mode 100644
index 00000000000..1860ea748f6
--- /dev/null
+++ b/src/renderer/src/lib/monaco-languages/haskell-highlighting.test.ts
@@ -0,0 +1,70 @@
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from 'vitest'
+import { loadNodeOniguruma } from '../syntax-highlighting/oniguruma-test-harness'
+import { monaco } from '../monaco-setup'
+import { detectLanguage } from '../../../../shared/editor-language/editor-language-detect'
+
+vi.mock('../syntax-highlighting/oniguruma', () => ({ loadOniguruma: loadNodeOniguruma }))
+
+describe('Haskell highlighting through production Monaco setup', () => {
+  it.each(['Main.hs', 'Signature.hsig', 'Main.hs-boot', 'C:\\folder workspace\\MAIN.HSIG'])(
+    'recognizes and tokenizes %s through production Monaco setup',
+    async (filename) => {
+      const language = detectLanguage(filename)
+      expect(language).toBe('haskell')
+      const source =
+        'module Main where\n-- comment\nanswer :: Int\nanswer = 42\nmain = putStrLn "hello"'
+      await monaco.editor.colorize(source, language, {})
+      const tokens = monaco.editor.tokenize(source, language)
+      expect(tokens[0].map((token) => token.type)).toContain('keyword.other.module.haskell')
+      expect(new Set(tokens[1].map((token) => token.type))).toEqual(new Set(['comment.haskell']))
+      expect(tokens[2].map((token) => token.type)).toEqual(
+        expect.arrayContaining(['type.identifier.haskell', 'type.haskell'])
+      )
+      expect(tokens[3].map((token) => token.type)).toContain('number.haskell')
+      expect(tokens[4].map((token) => token.type)).toContain('string.quoted.double.haskell')
+    }
+  )
+
+  it('highlights a signature module in an hsig model', async () => {
+    const source = 'signature Example where\nanswer :: Int'
+    const language = detectLanguage('Example.hsig')
+    await monaco.editor.colorize(source, language, {})
+    const tokens = monaco.editor.tokenize(source, language)
+    expect(tokens[0].map((token) => token.type)).toContain('keyword.other.signature.haskell')
+    expect(tokens[1].map((token) => token.type)).toContain('type.haskell')
+  })
+
+  it('retains the tokenization limit and leaves unknown following state plain', async () => {
+    const source = `${'x'.repeat(1001)}\nanswer = 42`
+    await monaco.editor.colorize(source, 'haskell', {})
+    const tokens = monaco.editor.tokenize(source, 'haskell')
+    expect(tokens.map((line) => line.map((token) => token.type))).toEqual([
+      ['source.haskell'],
+      ['source.haskell']
+    ])
+  })
+
+  it('keeps unrelated built-in language highlighting intact', async () => {
+    await monaco.editor.colorize('const answer = 42', 'typescript', {})
+    expect(
+      monaco.editor.tokenize('const answer = 42', 'typescript')[0].map((token) => token.type)
+    ).toEqual(expect.arrayContaining(['keyword.ts', 'number.ts']))
+    await monaco.editor.colorize('answer = 42 # comment', 'python', {})
+    expect(
+      monaco.editor.tokenize('answer = 42 # comment', 'python')[0].map((token) => token.type)
+    ).toEqual(expect.arrayContaining(['number.python', 'comment.python']))
+  })
+
+  it('carries nested comments across lines and returns to code after both closers', async () => {
+    const source = '{- outer {- inner\n-} still outer\n-}\nanswer = 42\ntext = "-- literal"'
+    await monaco.editor.colorize(source, 'haskell', {})
+    const tokens = monaco.editor.tokenize(source, 'haskell')
+    expect(new Set(tokens[0].map((token) => token.type))).toEqual(new Set(['comment.haskell']))
+    expect(new Set(tokens[1].map((token) => token.type))).toEqual(new Set(['comment.haskell']))
+    expect(tokens[3].map((token) => token.type)).toContain('number.haskell')
+    expect(tokens[3].map((token) => token.type)).not.toContain('comment.haskell')
+    expect(tokens[4].map((token) => token.type)).toContain('string.quoted.double.haskell')
+    expect(tokens[4].map((token) => token.type)).not.toContain('comment.haskell')
+  })
+})
diff --git a/src/renderer/src/lib/monaco-languages/register-haskell.ts b/src/renderer/src/lib/monaco-languages/register-haskell.ts
new file mode 100644
index 00000000000..3325b7697ab
--- /dev/null
+++ b/src/renderer/src/lib/monaco-languages/register-haskell.ts
@@ -0,0 +1,71 @@
+import type * as Monaco from 'monaco-editor'
+import type { LanguageRegistration } from 'shiki/core'
+import { registerTextMateLanguage } from './textmate-language-registration'
+
+const HASKELL_SCOPE = 'source.haskell'
+
+export const haskellLanguageConfiguration: Monaco.languages.LanguageConfiguration = {
+  comments: { lineComment: '--', blockComment: ['{-', '-}'] },
+  brackets: [
+    ['{', '}'],
+    ['[', ']'],
+    ['(', ')']
+  ],
+  autoClosingPairs: [
+    { open: '{', close: '}' },
+    { open: '[', close: ']' },
+    { open: '(', close: ')' },
+    { open: '"', close: '"', notIn: ['string', 'comment'] }
+  ],
+  surroundingPairs: [
+    { open: '{', close: '}' },
+    { open: '[', close: ']' },
+    { open: '(', close: ')' },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ]
+}
+
+function mapHaskellTokenScopes(scopes: readonly string[]): string {
+  if (scopes.some((scope) => scope.startsWith('comment.'))) {
+    return 'comment.haskell'
+  }
+  const scope = scopes.at(-1) ?? HASKELL_SCOPE
+  if (scope.startsWith('constant.numeric.')) {
+    return 'number.haskell'
+  }
+  if (scope.startsWith('constant.character.escape.')) {
+    return 'string.escape.haskell'
+  }
+  if (scope.startsWith('entity.name.function.')) {
+    return 'type.identifier.haskell'
+  }
+  if (scope.startsWith('storage.type.')) {
+    return 'type.haskell'
+  }
+  if (scope.startsWith('variable.other.generic-type.')) {
+    return 'variable.parameter.haskell'
+  }
+  return scope
+}
+
+export async function loadHaskellTextMateGrammar(): Promise<LanguageRegistration> {
+  // BSD-3-Clause grammar; provenance and license ship in resources/licenses/language-haskell.
+  const grammarModule = await import('./textmate-grammars/haskell.tmLanguage.json')
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: TextMate adds the required $self/$base repository entries; real tokenizer tests validate this generated upstream grammar.
+  const grammar = grammarModule.default as unknown as LanguageRegistration
+  return { ...grammar, name: 'haskell' }
+}
+
+export function registerHaskellLanguage(monaco: Pick<typeof Monaco, 'languages'>): void {
+  registerTextMateLanguage(monaco, {
+    language: {
+      id: 'haskell',
+      extensions: ['.hs', '.hsig', '.hs-boot'],
+      aliases: ['Haskell', 'haskell']
+    },
+    configuration: haskellLanguageConfiguration,
+    loadGrammar: loadHaskellTextMateGrammar,
+    mapTokenScopes: mapHaskellTokenScopes
+  })
+}
diff --git a/src/renderer/src/lib/monaco-languages/textmate-grammars/haskell.tmLanguage.json b/src/renderer/src/lib/monaco-languages/textmate-grammars/haskell.tmLanguage.json
new file mode 100644
index 00000000000..804aad899c5
--- /dev/null
+++ b/src/renderer/src/lib/monaco-languages/textmate-grammars/haskell.tmLanguage.json
@@ -0,0 +1,2639 @@
+{
+  "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*)|(?<!')\\b)(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*)|(?<!')\\b)(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": "(?x)\n(?:^(\\s*)|(?<!')\\b)(pattern)\\b\\s+\n(?<pat>\n  (?:\n    [\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nd}']*\n  | \\(\\s*\n      :[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*\n    \\s*\\)\n  )\n  (?:\\s*,\\s*\\g<pat>)?\n)\n\\s+(::|∷)(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"'']])\n",
+      "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*)|(?<!')\\b)(pattern)\\b(?!')",
+      "beginCaptures": {
+        "2": {
+          "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*)|(?<!')\\b)(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     # 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     )",
+      "patterns": [
+        {
+          "include": "#comment_like"
+        },
+        {
+          "include": "#deriving"
+        },
+        {
+          "include": "#forall"
+        },
+        {
+          "include": "#adt_constructor"
+        },
+        {
+          "include": "#record_decl"
+        },
+        {
+          "include": "#data_context"
+        },
+        {
+          "include": "#type_signature"
+        }
+      ]
+    },
+    {
+      "name": "meta.declaration.type.family.haskell",
+      "begin": "(?x)\n  # Type family\n  (?:^(\\s*)|(?<!')\\b)(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, or\n  | {-\n  # explicit indentation.\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*)|(?<!')\\b)(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*)|(?<!')\\b)(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*)|(?<!')\\b)(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": "(\")([^\"]+)(\")",
+          "name": "string.quoted.double.package.haskell",
+          "captures": {
+            "1": {
+              "name": "punctuation.definition.string.begin.haskell"
+            },
+            "2": {
+              "name": "entity.name.package.haskell"
+            },
+            "3": {
+              "name": "punctuation.definition.string.end.haskell"
+            }
+          }
+        },
+        {
+          "match": "\\b(?<!')(qualified|as|hiding)\\b(?!')",
+          "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*)|(?<!')\\b)(--\\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"
+        }
+      ]
+    },
+    "explicit_layout_block": {
+      "begin": "(\\{)(?!-)",
+      "beginCaptures": {
+        "1": {
+          "name": "punctuation.brace.haskell"
+        }
+      },
+      "end": "(\\})",
+      "endCaptures": {
+        "1": {
+          "name": "punctuation.brace.haskell"
+        }
+      },
+      "patterns": [
+        {
+          "include": "$self"
+        },
+        {
+          "match": ";",
+          "name": "punctuation.semicolon.haskell"
+        }
+      ]
+    },
+    "layout_herald": {
+      "patterns": [
+        {
+          "begin": "(?x)\n  (?:(?<!')\\b(?:(where|let|m?do)|(of))|(\\\\\\s*case(?:s)?))\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"
+            }
+          ]
+        },
+        {
+          "begin": "(?x)\n  (?<!')\\b(?:(where|let)|(m?do)|(of))\\b(?!')\n  (?=\\s*(?:--+(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])|\\{-|$))",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.$1.haskell"
+            },
+            "2": {
+              "name": "keyword.control.$2.haskell"
+            },
+            "3": {
+              "name": "keyword.control.of.haskell"
+            }
+          },
+          "end": "(?x)\n  ^(?=\\s*(?!\\{|--+(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]))\\S)",
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#explicit_layout_block"
+            }
+          ]
+        }
+      ]
+    },
+    "keyword": {
+      "match": "\\b(?<!')(?:(where|let|in|default)|(m?do|if|then|else|case(?:s)?|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{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\p{Nd}'']*\\.)*)([\\p{Ll}\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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|data)\\b(?!')",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.other.$1.haskell"
+            }
+          },
+          "end": "(?x)\n   # Data constructor\n   ([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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": "(?=,|\\))",
+          "patterns": [
+            {
+              "include": "#comment_like"
+            },
+            {
+              "include": "#reserved_symbol"
+            },
+            {
+              "include": "#type_constructor"
+            },
+            {
+              "include": "#type_operator"
+            }
+          ]
+        },
+        {
+          "include": "#record_wildcard"
+        },
+        {
+          "include": "#reserved_symbol"
+        },
+        {
+          "match": "(\\()\\s*(:[\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]*)\\s*(\\))",
+          "name": "storage.type.operator.haskell"
+        },
+        {
+          "match": "(?<!')\\b[\\p{Ll}_\\p{Lm}\\p{Lo}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nd}']*",
+          "name": "entity.name.function.haskell"
+        },
+        {
+          "match": "(?<!')\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\p{Nd}']*(\\.\\g<conid>)?)",
+      "name": "entity.name.namespace.haskell"
+    },
+    "pragma": {
+      "begin": "\\{-#",
+      "end": "#-\\}",
+      "name": "meta.preprocessor.haskell",
+      "patterns": [
+        {
+          "include": "#comments"
+        },
+        {
+          "include": "#string_literal"
+        },
+        {
+          "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|PolymorphicComponents|Rank2Types|RecordPuns|RelaxedPolyRec|TypeInType)\n  \\b(?!')",
+              "name": "invalid.deprecated"
+            },
+            {
+              "match": "(?x)\n  \\b(?<!')\n  (Haskell98|Haskell2010|GHC2021|GHC2024)\n  \\b(?!')",
+              "captures": {
+                "1": {
+                  "name": "keyword.other.preprocessor.language-standard.haskell"
+                }
+              }
+            },
+            {
+              "match": "(?x)\n  \\b(?<!')\n  (\n  (?:No)?\n  (?:AllowAmbiguousTypes|AlternativeLayoutRuleTransitional|AlternativeLayoutRule|ApplicativeDo|Arrows|BangPatterns|BinaryLiterals|BlockArguments|CApiFFI|CPP|CUSKs|ConstrainedClassMethods|ConstraintKinds|DataKinds|DefaultSignatures|DeepSubsumption|DeriveAnyClass|DeriveDataTypeable|DeriveFoldable|DeriveFunctor|DeriveGeneric|DeriveLift|DeriveTraversable|DerivingStrategies|DerivingVia|DisambiguateRecordFields|DoAndIfThenElse|DuplicateRecordFields|EmptyCase|EmptyDataDecls|EmptyDataDeriving|ExistentialQuantification|ExplicitForAll|ExplicitLevelImports|ExplicitNamespaces|ExtendedDefaultRules|ExtendedLiterals|FieldSelectors|FlexibleContexts|FlexibleInstances|ForeignFunctionInterface|FunctionalDependencies|GADTSyntax|GADTs|GHCForeignImportPrim|Generali(?:s|z)edNewtypeDeriving|HexFloatLiterals|ImplicitParams|ImplicitPrelude|ImplicitStagePersistence|ImportQualifiedPost|ImpredicativeTypes|InstanceSigs|InterruptibleFFI|JavaScriptFFI|KindSignatures|LambdaCase|LexicalNegation|LiberalTypeSynonyms|LinearTypes|ListTuplePuns|MagicHash|Modifiers|MonadComprehensions|MonoLocalBinds|MonomorphismRestriction|MultiParamTypeClasses|MultiWayIf|MultilineStrings|NPlusKPatterns|NamedDefaults|NamedFieldPuns|NamedWildCards|NegativeLiterals|NondecreasingIndentation|NumDecimals|NumericUnderscores|OrPatterns|OverloadedLabels|OverloadedLists|OverloadedRecordDot|OverloadedRecordUpdate|OverloadedStrings|PackageImports|ParallelArrays|ParallelListComp|PartialTypeSignatures|PatternGuards|PatternSynonyms|PolyKinds|PostfixOperators|QualifiedDo|QualifiedStrings|QuantifiedConstraints|QuasiQuotes|RankNTypes|RebindableSyntax|RecordWildCards|RecursiveDo|RelaxedLayout|RequiredTypeArguments|RoleAnnotations|ScopedTypeVariables|StandaloneDeriving|StandaloneKindSignatures|StarIsType|StaticPointers|StrictData|Strict|TemplateHaskellQuotes|TemplateHaskell|TraditionalRecordSyntax|TransformListComp|TupleSections|TypeAbstractions|TypeApplications|TypeData|TypeFamilies|TypeFamilyDependencies|TypeOperators|TypeSynonymInstances|UnboxedSums|UnboxedTuples|UndecidableInstances|UndecidableSuperClasses|UnicodeSyntax|UnliftedDatatypes|UnliftedFFITypes|UnliftedNewtypes|ViewPatterns)\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     (?!\\{)\n     (?!--(?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']]))\n     [^({]\n    |\n     (?<paren>\n       \\(\n       (?:\n         \\g<paren> # Recurse first: consume nested parens before trying non-paren chars\n       | [^()]++   # Non-parens (possessive: no backtracking into consumed chars)\n       )*\n       \\)\n     )\n    |\n     \\{-(?:[^-]|-(?!\\}))*-\\}\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"
+            }
+          ]
+        },
+        "3": {
+          "name": "keyword.operator.big-arrow.haskell"
+        }
+      }
+    },
+    "data_constructor": {
+      "patterns": [
+        {
+          "match": "\\b(?<!')[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\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{Lm}\\p{Lo}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lt}\\p{Lm}\\p{Lo}_][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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*)|(?<!')\\b)(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"
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "string_escapes": {
+      "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": "\\\\x[0-9A-Fa-f]+",
+          "name": "constant.character.escape.hexadecimal.haskell"
+        },
+        {
+          "match": "\\\\o[0-7]+",
+          "name": "constant.character.escape.octal.haskell"
+        },
+        {
+          "match": "\\\\[0-9]+",
+          "name": "constant.character.escape.decimal.haskell"
+        },
+        {
+          "match": "\\\\\\^[A-Z@\\[\\]\\\\\\^_]",
+          "name": "constant.character.escape.control.haskell"
+        }
+      ]
+    },
+    "fun_decl": {
+      "begin": "(?x)^(\\s*)\n  (?<fn>\n    (?:\n      [\\p{Ll}_\\p{Lm}\\p{Lo}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\p{Nd}'\\.])+)\n    # Type inside balanced parentheses\n    | ('? # Optional promotion tick\n        (?<paren>\n          \\(           # Opening parenthesis\n          (?:\n            \\g<paren>  # Recurse first: consume nested parens before trying non-paren chars\n          | [^\\(\\)]++  # Non-parentheses (possessive: no backtracking into consumed chars)\n          )*\n          \\)           # Closing parenthesis\n        )\n      )\n    # Type inside balanced brackets\n    | ('? # Optional promotion tick\n        (?<brac>\n          \\[           # Opening bracket\n          (?:\n            \\g<brac>   # Recurse first: consume nested brackets before trying non-bracket chars\n          | [^\\[\\]]++  # Non-brackets (possessive: no backtracking into consumed chars)\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{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\p{Nd}']*))\n    # Reject if this looks like a qualified type, e.g. \"C args =>\"\n    (?!\n      (?: # Match allowed intermediate tokens between the word and the '=>'\n          # Note: we don't use inner '+' quantifier, to avoid excessive backtracking.\n\n        # Valid characters: letters, digits, allowed symbols, spaces, and tabs\n        [\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nd}'\\., \\t]\n\n        # OR a newline, but ONLY if strictly followed by indentation (tabs or spaces)\n        # (This prevents the lookahead from bleeding into unindented top-level declarations)\n        | \\r?\\n[ \\t]+\n\n        # OR a multiline block comment: {- ... -}\n        | \\{-(?:[^-]|-(?!\\}))*-\\}\n\n      )*\n\n      # ... and a constraint arrow '=>' (not part of a larger custom operator such as '==>')\n      (?<![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n      (=>|⇒)\n      (?![\\p{S}\\p{P}&&[^(),;\\[\\]`{}_\"']])\n    )\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/haskell/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}_\\p{Lm}\\p{Lo}]\\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"
+            },
+            "12": {
+              "name": "punctuation.paren.haskell"
+            },
+            "13": {
+              "name": "constant.other.operator.prefix.haskell"
+            },
+            "14": {
+              "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{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\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": [
+        {
+          "match": "(?<=[\\s,;\\[\\]{}\"])(@)(\\(\\s*\\))",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.prefix.at.haskell"
+            },
+            "2": {
+              "name": "support.constant.unit.haskell"
+            }
+          },
+          "name": "meta.type-application.haskell"
+        },
+        {
+          "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{Lm}\\p{Lo}\\p{Nd}'])",
+          "beginCaptures": {
+            "1": {
+              "name": "keyword.operator.prefix.at.haskell"
+            }
+          },
+          "end": "(?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lm}\\p{Lo}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\p{Nd}']*\\.)*)\n  # Type constructor proper\n    (\\b[\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\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  # Require a preceding final operator character\n  (?<=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nd}\\p{S}\\p{P}&&[^\\#(,;\\[`{]])\n  (\\#+)\n  # Disallow a following operator character, but allow parentheses\n  # to handle e.g. 'Solo#(..)'.\n  (?![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nd}\\p{S}\\p{P}&&[^(),;\\[\\]`{}]])",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.postfix.hash.haskell"
+            }
+          }
+        },
+        {
+          "match": "(?x)\n  (?<=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nd}'\\)\\}\\]]) # Require closing characters\n  (@)\n  (?=[\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nd}'\\(\\[\\{]) # Require opening character",
+          "captures": {
+            "1": {
+              "name": "keyword.operator.infix.tight.at.haskell"
+            }
+          }
+        },
+        {
+          "match": "(?x)\n  (?<![\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\p{Nd}\\p{S}\\p{P}&&[^(,;\\[`{]])  # Disallow closing characters\n  (?:(~)|(!)|(-)|(\\$\\$)|(\\$)|(%))\n  (?=[\\p{Ll}_'\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\p{Nd}']*\\.)*)\n  # Type constructor proper\n    ([\\p{Lu}\\p{Lt}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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": [
+        {
+          "include": "#string_escapes"
+        },
+        {
+          "begin": "\\\\(?=[\\p{Zs}\\t\\v\\f])",
+          "beginCaptures": {
+            "0": {
+              "name": "constant.character.escape.begin.haskell"
+            }
+          },
+          "end": "(?<=[\\s\\p{Zs}])\\\\|(?=\")",
+          "endCaptures": {
+            "0": {
+              "name": "constant.character.escape.end.haskell"
+            }
+          },
+          "patterns": [
+            {
+              "begin": "(?=[^\\s\\\\])",
+              "end": "(?=\")",
+              "patterns": [
+                {
+                  "match": "[^\\s\\\\\"]+",
+                  "name": "invalid.illegal.character-not-allowed-here.haskell"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "begin": "\\\\$",
+          "beginCaptures": {
+            "0": {
+              "name": "constant.character.escape.begin.haskell"
+            }
+          },
+          "end": "\\\\|(?=[^\\s\\\\])",
+          "endCaptures": {
+            "0": {
+              "name": "constant.character.escape.end.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{Lm}\\p{Lo}\\p{Nd}'])\n  (')\n  (?:\n    [^\\\\'\\p{Cc}]                        # Basic Char (not control, ' or \\)\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*)|(?<!')\\b)(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": "(?<=((^|foreign|import|export|ccall|cplusplus|dotnet|jvm|stdcall|prim|capi|safe|unsafe|interruptible)\\s*))((?=\")|(?=\\b(?<!')([\\p{Ll}_\\p{Lm}\\p{Lo}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lm}\\p{Lo}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lm}\\p{Lo}][\\p{Ll}_\\p{Lu}\\p{Lt}\\p{Lm}\\p{Lo}\\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{Lm}\\p{Lo}\\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"
+}
diff --git a/src/renderer/src/lib/monaco-languages/textmate-language-registration.ts b/src/renderer/src/lib/monaco-languages/textmate-language-registration.ts
index c1088a54379..d32651e7be7 100644
--- a/src/renderer/src/lib/monaco-languages/textmate-language-registration.ts
+++ b/src/renderer/src/lib/monaco-languages/textmate-language-registration.ts
@@ -4,7 +4,7 @@ import type {
   TextMateGrammarLoader
 } from './textmate-token-provider'
 
-type MonacoModule = typeof Monaco
+type MonacoModule = Pick<typeof Monaco, 'languages'>
 type TextMateTokensProvider = Monaco.languages.TokensProvider
 type TextMateTokenProviderModule = {
   createTextMateTokensProvider: typeof createTextMateTokensProviderType
@@ -14,6 +14,7 @@ export type TextMateLanguageRegistration = {
   language: Monaco.languages.ILanguageExtensionPoint
   configuration?: Monaco.languages.LanguageConfiguration
   loadGrammar: TextMateGrammarLoader
+  mapTokenScopes?: (scopes: readonly string[]) => string
   loadProviderModule?: () => Promise<TextMateTokenProviderModule>
 }
 
@@ -45,7 +46,10 @@ export function registerTextMateLanguage(
       tokensProviderPromise ??= (
         registration.loadProviderModule ?? loadDefaultProviderModule
       )().then(({ createTextMateTokensProvider }) =>
-        createTextMateTokensProvider({ loadGrammar: registration.loadGrammar })
+        createTextMateTokensProvider({
+          loadGrammar: registration.loadGrammar,
+          ...(registration.mapTokenScopes ? { mapTokenScopes: registration.mapTokenScopes } : {})
+        })
       )
       return tokensProviderPromise
     }
diff --git a/src/renderer/src/lib/monaco-languages/textmate-token-provider.ts b/src/renderer/src/lib/monaco-languages/textmate-token-provider.ts
index 3838ec85206..9150bb97e45 100644
--- a/src/renderer/src/lib/monaco-languages/textmate-token-provider.ts
+++ b/src/renderer/src/lib/monaco-languages/textmate-token-provider.ts
@@ -14,6 +14,7 @@ export type TextMateGrammarLoader = () => Promise<LanguageRegistration>
 
 export type TextMateTokensProviderOptions = {
   loadGrammar: TextMateGrammarLoader
+  mapTokenScopes?: (scopes: readonly string[]) => string
 }
 
 let editorCorePromise: Promise<TextMateCore> | undefined
@@ -49,7 +50,8 @@ class TextMateTokenizerState implements Monaco.languages.IState {
 function createTokensProvider(
   { textmate }: TextMateCore,
   grammar: Grammar,
-  fallbackScopeName: string
+  fallbackScopeName: string,
+  mapTokenScopes?: (scopes: readonly string[]) => string
 ): TextMateTokensProvider {
   const plain = (state: TextMateTokenizerState): Monaco.languages.ILineTokens => ({
     endState: state,
@@ -78,7 +80,7 @@ function createTokensProvider(
           startIndex: token.startIndex,
           // Why: Monaco themes match a single token scope; TextMate returns a
           // scope stack, and the final entry is the most specific reusable one.
-          scopes: token.scopes.at(-1) ?? fallbackScopeName
+          scopes: mapTokenScopes?.(token.scopes) ?? token.scopes.at(-1) ?? fallbackScopeName
         }))
       }
     }
@@ -93,6 +95,7 @@ export async function createTextMateTokensProvider(
   return createTokensProvider(
     editorCore,
     editorCore.core.getLanguage(registration.name),
-    registration.scopeName
+    registration.scopeName,
+    options.mapTokenScopes
   )
 }
diff --git a/src/renderer/src/lib/monaco-setup.ts b/src/renderer/src/lib/monaco-setup.ts
index be9b001adf4..f98dfbc5e57 100644
--- a/src/renderer/src/lib/monaco-setup.ts
+++ b/src/renderer/src/lib/monaco-setup.ts
@@ -10,6 +10,7 @@ import htmlWorker from 'monaco-editor/esm/vs/language/html/html.worker?worker'
 import tsWorker from 'monaco-editor/esm/vs/language/typescript/ts.worker?worker'
 import { registerAstroLanguage } from './monaco-languages/register-astro'
 import { registerJsonlLanguage } from './monaco-languages/register-jsonl'
+import { registerHaskellLanguage } from './monaco-languages/register-haskell'
 import { registerNimLanguage } from './monaco-languages/register-nim'
 import { registerQuartoLanguage } from './monaco-languages/register-quarto'
 import { registerShellMarkdownAliases } from './monaco-languages/register-shell-markdown-aliases'
@@ -83,6 +84,7 @@ runMonacoSetupSteps([
   ['Vue language registration', () => registerVueLanguage(monaco)],
   ['Svelte language registration', () => registerSvelteLanguage(monaco)],
   ['Astro language registration', () => registerAstroLanguage(monaco)],
+  ['Haskell language registration', () => registerHaskellLanguage(monaco)],
   ['Nim language registration', () => registerNimLanguage(monaco)],
   ['Typst language registration', () => registerTypstLanguage(monaco)],
   ['JSONL language registration', () => registerJsonlLanguage(monaco)],
diff --git a/src/shared/editor-language/editor-language-detect.ts b/src/shared/editor-language/editor-language-detect.ts
index a58c0e8e5c7..443fd907eb5 100644
--- a/src/shared/editor-language/editor-language-detect.ts
+++ b/src/shared/editor-language/editor-language-detect.ts
@@ -99,6 +99,8 @@ const EXT_TO_LANGUAGE: Record<string, string> = {
   '.erl': 'erlang',
   '.hrl': 'erlang',
   '.hs': 'haskell',
+  '.hsig': 'haskell',
+  '.hs-boot': 'haskell',
   '.clj': 'clojure',
   // Why: Monaco registers Solidity under the id 'sol'; 'solidity' is only an alias.
   '.sol': 'sol',
diff --git a/tests/e2e/editor-haskell-highlighting.spec.ts b/tests/e2e/editor-haskell-highlighting.spec.ts
new file mode 100644
index 00000000000..ec33d8f0921
--- /dev/null
+++ b/tests/e2e/editor-haskell-highlighting.spec.ts
@@ -0,0 +1,104 @@
+import { writeFileSync } from 'node:fs'
+import path from 'node:path'
+import type { Locator } from '@stablyai/playwright-test'
+import { detectLanguage } from '../../src/renderer/src/lib/language-detect'
+import { test, expect } from './helpers/orca-app'
+import {
+  cleanupGoldenWorktree,
+  createGoldenWorktree,
+  openGoldenSourceControl
+} from './helpers/golden-source-control'
+import { waitForSessionReady } from './helpers/store'
+
+const source = [
+  'module Main where',
+  '-- A comment',
+  'answer :: Int',
+  'answer = 42',
+  'main = putStrLn "hello"',
+  ''
+].join('\n')
+
+async function colors(editor: Locator): Promise<Record<string, string | null>> {
+  return editor.locator('.view-lines:not(.line-delete)').evaluate((lines) => {
+    const colorOf = (text: string) => {
+      const span = [...lines.querySelectorAll('span[class*="mtk"]')].find((entry) =>
+        entry.textContent?.includes(text)
+      )
+      return span ? getComputedStyle(span).color : null
+    }
+    return {
+      keyword: colorOf('module'),
+      comment: colorOf('comment'),
+      type: colorOf('Int'),
+      number: colorOf('42'),
+      string: colorOf('hello')
+    }
+  })
+}
+
+async function expectHighlighted(editor: Locator): Promise<void> {
+  await expect(editor.locator('.view-lines:not(.line-delete)')).toContainText('module Main where')
+  await expect
+    .poll(
+      async () => {
+        const painted = await colors(editor)
+        return (
+          Object.values(painted).every((color) => color !== null) &&
+          new Set(Object.values(painted)).size >= 4
+        )
+      },
+      { timeout: 25_000 }
+    )
+    .toBe(true)
+}
+
+test('highlights recognized Haskell source and an untracked file diff', async ({
+  orcaPage,
+  testRepoPath,
+  registerPostElectronShutdownCleanup
+}, testInfo) => {
+  const fixture = createGoldenWorktree(testRepoPath, 'haskell-highlighting')
+  registerPostElectronShutdownCleanup(async () => cleanupGoldenWorktree(testRepoPath, fixture))
+  const filePath = path.join(fixture.worktreePath, 'Main.hs')
+  writeFileSync(filePath, source)
+
+  await waitForSessionReady(orcaPage)
+  await openGoldenSourceControl(orcaPage, testRepoPath, fixture)
+  await orcaPage.evaluate(
+    ({ filePath, language }) => {
+      const store = window.__store
+      const worktreeId = store?.getState().activeWorktreeId
+      if (!store || !worktreeId) {
+        throw new Error('Haskell fixture worktree unavailable')
+      }
+      store
+        .getState()
+        .openFile({ filePath, relativePath: 'Main.hs', worktreeId, language, mode: 'edit' })
+    },
+    { filePath, language: detectLanguage(filePath) }
+  )
+  await orcaPage.evaluate(() => window.__store?.getState().updateSettings({ theme: 'light' }))
+  const sourceEditor = orcaPage.locator('.monaco-editor.vs').first()
+  await expectHighlighted(sourceEditor)
+  await expect
+    .poll(() => orcaPage.evaluate(() => window.__monacoEditorE2E?.snapshot().valueLength))
+    .toBe(source.length)
+  await orcaPage.screenshot({ path: testInfo.outputPath('haskell-source-light.png') })
+  await orcaPage.evaluate(() => window.__store?.getState().updateSettings({ theme: 'dark' }))
+  await expectHighlighted(orcaPage.locator('.monaco-editor.vs-dark').first())
+  await orcaPage.screenshot({ path: testInfo.outputPath('haskell-source-dark.png') })
+  await orcaPage.evaluate(() => window.__store?.getState().updateSettings({ theme: 'light' }))
+
+  await orcaPage
+    .locator('[data-testid="source-control-entry"]')
+    .filter({ hasText: 'Main.hs' })
+    .click()
+  await expectHighlighted(orcaPage.locator('.modified-in-monaco-diff-editor.vs'))
+  await orcaPage.screenshot({ path: testInfo.outputPath('haskell-diff.png') })
+
+  await orcaPage.evaluate(() => window.__store?.getState().updateSettings({ theme: 'dark' }))
+  const darkDiff = orcaPage.locator('.modified-in-monaco-diff-editor.vs-dark')
+  await expectHighlighted(darkDiff)
+  await orcaPage.screenshot({ path: testInfo.outputPath('haskell-diff-dark.png') })
+})