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/language-detect.test.ts b/src/renderer/src/lib/language-detect.test.ts
index b8cd6e45353..96b1ca0e689 100644
--- a/src/renderer/src/lib/language-detect.test.ts
+++ b/src/renderer/src/lib/language-detect.test.ts
@@ -2,6 +2,15 @@ import { describe, expect, it } from 'vitest'
 import { detectLanguage } from './language-detect'
 
 describe('detectLanguage', () => {
+  it.each([
+    'src/Main.hs',
+    'src/Main.hsig',
+    'src/Main.hs-boot',
+    'C:\\src\\MAIN.HS',
+    '/remote folder/Main.hsig'
+  ])('maps Haskell source %s to the haskell language id', (filePath) => {
+    expect(detectLanguage(filePath)).toBe('haskell')
+  })
   it('maps .vue files to the custom vue language id', () => {
     expect(detectLanguage('src/components/App.vue')).toBe('vue')
   })
diff --git a/src/renderer/src/lib/language-detect.ts b/src/renderer/src/lib/language-detect.ts
index b90b5a36ae2..405f4ea98ea 100644
--- a/src/renderer/src/lib/language-detect.ts
+++ b/src/renderer/src/lib/language-detect.ts
@@ -94,6 +94,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/src/renderer/src/lib/monaco-languages/register-haskell.test.ts b/src/renderer/src/lib/monaco-languages/register-haskell.test.ts
new file mode 100644
index 00000000000..59e4b2aa151
--- /dev/null
+++ b/src/renderer/src/lib/monaco-languages/register-haskell.test.ts
@@ -0,0 +1,93 @@
+// @vitest-environment happy-dom
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js'
+import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
+import { loadHaskellTextMateGrammar, registerHaskellLanguage } from './register-haskell'
+import type { TextMateTokensProviderOptions } from './textmate-token-provider'
+import type * as TextMateProvider from './textmate-token-provider'
+import { loadNodeOniguruma } from './textmate-oniguruma-fixture'
+
+const providerRequests = vi.hoisted(() => vi.fn())
+const disposers: (() => void)[] = []
+
+vi.mock('./textmate-token-provider', async (importOriginal) => {
+  const actual = await importOriginal<typeof TextMateProvider>()
+  return {
+    ...actual,
+    createTextMateTokensProvider: (options: TextMateTokensProviderOptions) => {
+      providerRequests()
+      return actual.createTextMateTokensProvider({ ...options, loadOniguruma: loadNodeOniguruma })
+    }
+  }
+})
+
+beforeAll(() => {
+  const registration = vi.spyOn(monaco.languages, 'register')
+  const configuration = vi.spyOn(monaco.languages, 'setLanguageConfiguration')
+  const factory = vi.spyOn(monaco.languages, 'registerTokensProviderFactory')
+  registerHaskellLanguage(monaco)
+  expect(providerRequests).not.toHaveBeenCalled()
+  registerHaskellLanguage(monaco)
+  expect(registration).toHaveBeenCalledTimes(1)
+  for (const call of [...configuration.mock.results, ...factory.mock.results]) {
+    if (call.type === 'return') {
+      disposers.push(() => call.value.dispose())
+    }
+  }
+})
+
+afterAll(() => {
+  for (const dispose of disposers.splice(0).toReversed()) {
+    dispose()
+  }
+  vi.restoreAllMocks()
+})
+
+describe('Haskell through the installed Monaco tokenizer', () => {
+  it('lazily colors recognized source, types, numbers, strings, and comments', async () => {
+    const source = [
+      'module Main where',
+      '-- comment',
+      'answer :: Int',
+      'answer = 42',
+      'main = putStrLn "hello"'
+    ].join('\n')
+    await monaco.editor.colorize(source, 'haskell', {})
+    expect(providerRequests).toHaveBeenCalledTimes(1)
+    const tokens = monaco.editor.tokenize(source, 'haskell')
+    const scopes = (line: number) => tokens[line].map((token) => token.type)
+
+    expect(scopes(0)).toContain('keyword.other.module.haskell')
+    expect(new Set(scopes(1))).toEqual(new Set(['comment.haskell']))
+    expect(scopes(2)).toEqual(expect.arrayContaining(['type.identifier.haskell', 'type.haskell']))
+    expect(scopes(3)).toContain('number.haskell')
+    expect(scopes(4)).toContain('string.quoted.double.haskell')
+    expect(monaco.languages.getLanguages().find(({ id }) => id === 'haskell')?.extensions).toEqual([
+      '.hs',
+      '.hsig',
+      '.hs-boot'
+    ])
+  })
+
+  it('keeps nested comments active and returns to code after both closers', async () => {
+    const source = [
+      '{- outer {- inner',
+      '-} still outer',
+      '-}',
+      'answer = 42',
+      'text = "-- literal"'
+    ].join('\n')
+    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')
+  })
+
+  it('does not load a grammar for an unrelated scope', async () => {
+    await expect(loadHaskellTextMateGrammar('source.python')).resolves.toBeNull()
+  })
+})
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..16b92806a2e
--- /dev/null
+++ b/src/renderer/src/lib/monaco-languages/register-haskell.ts
@@ -0,0 +1,74 @@
+import type * as Monaco from 'monaco-editor'
+import type { IRawGrammar } from 'vscode-textmate'
+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(scopeName: string): Promise<IRawGrammar | null> {
+  if (scopeName !== HASKELL_SCOPE) {
+    return null
+  }
+  // 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.
+  return grammarModule.default as unknown as IRawGrammar
+}
+
+export function registerHaskellLanguage(monaco: Pick<typeof Monaco, 'languages'>): void {
+  registerTextMateLanguage(monaco, {
+    language: {
+      id: 'haskell',
+      extensions: ['.hs', '.hsig', '.hs-boot'],
+      aliases: ['Haskell', 'haskell']
+    },
+    configuration: haskellLanguageConfiguration,
+    scopeName: HASKELL_SCOPE,
+    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 da5cd3c956a..9f74984cbe3 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
@@ -15,6 +15,7 @@ export type TextMateLanguageRegistration = {
   configuration?: Monaco.languages.LanguageConfiguration
   scopeName: string
   loadGrammar: TextMateGrammarLoader
+  mapTokenScopes?: (scopes: readonly string[]) => string
   loadProviderModule?: () => Promise<TextMateTokenProviderModule>
 }
 
@@ -48,7 +49,8 @@ export function registerTextMateLanguage(
       )().then(({ createTextMateTokensProvider }) =>
         createTextMateTokensProvider({
           scopeName: registration.scopeName,
-          loadGrammar: registration.loadGrammar
+          loadGrammar: registration.loadGrammar,
+          ...(registration.mapTokenScopes ? { mapTokenScopes: registration.mapTokenScopes } : {})
         })
       )
       return tokensProviderPromise
diff --git a/src/renderer/src/lib/monaco-languages/textmate-oniguruma-fixture.ts b/src/renderer/src/lib/monaco-languages/textmate-oniguruma-fixture.ts
new file mode 100644
index 00000000000..b41a3729b43
--- /dev/null
+++ b/src/renderer/src/lib/monaco-languages/textmate-oniguruma-fixture.ts
@@ -0,0 +1,16 @@
+import { createRequire } from 'node:module'
+import { readFile } from 'node:fs/promises'
+import { createOnigScanner, createOnigString, loadWASM } from 'vscode-oniguruma'
+import type { IOnigLib } from 'vscode-textmate'
+
+const require = createRequire(import.meta.url)
+let nodeOnigurumaPromise: Promise<IOnigLib> | undefined
+
+export function loadNodeOniguruma(): Promise<IOnigLib> {
+  nodeOnigurumaPromise ??= (async () => {
+    const bytes = await readFile(require.resolve('vscode-oniguruma/release/onig.wasm'))
+    await loadWASM(new Uint8Array(bytes))
+    return { createOnigScanner, createOnigString }
+  })()
+  return nodeOnigurumaPromise
+}
diff --git a/src/renderer/src/lib/monaco-languages/textmate-token-provider.test.ts b/src/renderer/src/lib/monaco-languages/textmate-token-provider.test.ts
index 86b5d0c8604..7c1d3dff6a9 100644
--- a/src/renderer/src/lib/monaco-languages/textmate-token-provider.test.ts
+++ b/src/renderer/src/lib/monaco-languages/textmate-token-provider.test.ts
@@ -1,30 +1,9 @@
-import { createRequire } from 'node:module'
-import { readFile } from 'node:fs/promises'
 import { describe, expect, it } from 'vitest'
-import { createOnigScanner, createOnigString, loadWASM } from 'vscode-oniguruma'
-import type { IOnigLib, IRawGrammar } from 'vscode-textmate'
+import type { IRawGrammar } from 'vscode-textmate'
 import nimGrammar from './textmate-grammars/nim.tmLanguage.json'
 import { loadTypstTextMateGrammar } from './register-typst'
 import { createTextMateTokensProvider } from './textmate-token-provider'
-
-const require = createRequire(import.meta.url)
-
-let nodeOnigurumaPromise: Promise<IOnigLib> | undefined
-
-async function loadNodeOniguruma(): Promise<IOnigLib> {
-  nodeOnigurumaPromise ??= (async () => {
-    const wasmPath = require.resolve('vscode-oniguruma/release/onig.wasm')
-    const wasmBytes = await readFile(wasmPath)
-    const wasmBuffer = wasmBytes.buffer.slice(
-      wasmBytes.byteOffset,
-      wasmBytes.byteOffset + wasmBytes.byteLength
-    )
-    await loadWASM(wasmBuffer)
-    return { createOnigScanner, createOnigString }
-  })()
-
-  return nodeOnigurumaPromise
-}
+import { loadNodeOniguruma } from './textmate-oniguruma-fixture'
 
 describe('createTextMateTokensProvider', () => {
   it('tokenizes Nim with the vendored TextMate grammar', async () => {
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 ace5ca9966e..3b28e3983ab 100644
--- a/src/renderer/src/lib/monaco-languages/textmate-token-provider.ts
+++ b/src/renderer/src/lib/monaco-languages/textmate-token-provider.ts
@@ -10,6 +10,7 @@ export type TextMateGrammarLoader = (scopeName: string) => Promise<IRawGrammar |
 export type TextMateTokensProviderOptions = {
   scopeName: string
   loadGrammar: TextMateGrammarLoader
+  mapTokenScopes?: (scopes: readonly string[]) => string
   loadOniguruma?: () => Promise<IOnigLib>
 }
 
@@ -47,7 +48,8 @@ class TextMateTokenizerState implements Monaco.languages.IState {
 
 function createTokensProvider(
   grammar: IGrammar,
-  fallbackScopeName: string
+  fallbackScopeName: string,
+  mapTokenScopes?: (scopes: readonly string[]) => string
 ): TextMateTokensProvider {
   return {
     getInitialState() {
@@ -64,7 +66,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
         }))
       }
     }
@@ -94,5 +96,5 @@ export async function createTextMateTokensProvider(
     throw new Error(`No TextMate grammar registered for scope ${options.scopeName}`)
   }
 
-  return createTokensProvider(grammar, options.scopeName)
+  return createTokensProvider(grammar, options.scopeName, options.mapTokenScopes)
 }
diff --git a/src/renderer/src/lib/monaco-setup.ts b/src/renderer/src/lib/monaco-setup.ts
index 5c2c69d24cb..f3357a4d3fc 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 { registerShellMarkdownAliases } from './monaco-languages/register-shell-markdown-aliases'
 import { registerSvelteLanguage } from './monaco-languages/register-svelte'
@@ -83,6 +84,7 @@ runMonacoSetupSteps([
   ['Svelte language registration', () => registerSvelteLanguage(monaco)],
   ['Astro language registration', () => registerAstroLanguage(monaco)],
   ['Nim language registration', () => registerNimLanguage(monaco)],
+  ['Haskell language registration', () => registerHaskellLanguage(monaco)],
   ['Typst language registration', () => registerTypstLanguage(monaco)],
   ['JSONL language registration', () => registerJsonlLanguage(monaco)],
   ['shell Markdown alias registration', () => registerShellMarkdownAliases(monaco)],
diff --git a/tests/e2e/editor-haskell-highlighting.spec.ts b/tests/e2e/editor-haskell-highlighting.spec.ts
new file mode 100644
index 00000000000..a387a48b992
--- /dev/null
+++ b/tests/e2e/editor-haskell-highlighting.spec.ts
@@ -0,0 +1,99 @@
+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) }
+  )
+  const sourceEditor = orcaPage.locator('.monaco-editor').first()
+  await expectHighlighted(sourceEditor)
+  await expect
+    .poll(() => orcaPage.evaluate(() => window.__monacoEditorE2E?.snapshot().valueLength))
+    .toBe(source.length)
+  await orcaPage.screenshot({ path: testInfo.outputPath('haskell-source.png') })
+
+  await orcaPage
+    .locator('[data-testid="source-control-entry"]')
+    .filter({ hasText: 'Main.hs' })
+    .click()
+  await expectHighlighted(orcaPage.locator('.modified-in-monaco-diff-editor'))
+  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') })
+})