feat: dart language support

src/index.ts

@@ -4,6 +4,7 @@ import { Clojure } from './languages/clojure';
 import { CPP } from './languages/cpp';
 import { CS } from './languages/cs';
 import { CSS } from './languages/css';
+import { Dart } from './languages/dart';
 import { Dockerfile } from './languages/dockerfile';
 import { Elixir } from './languages/elixir';
 import { Go } from './languages/go';
@@ -31,6 +32,7 @@ const languages: Record<string, LanguagePattern[]> = {
   'C++': CPP,
   'C#': CS,
   CSS,
+  Dart,
   Dockerfile,
   Elixir,
   Go,

src/languages/c.ts

@@ -48,4 +48,6 @@ export const C: LanguagePattern[] = [
   },
   // Avoiding Lua confusion
   { pattern: /local\s(function|\w+)?/, type: 'not' },
+  // Avoiding Dart confusion
+  { pattern: /^(void\s)?main\(\)\s(async\s)?{/, type: 'not' },
 ];

src/languages/cpp.ts

@@ -53,4 +53,6 @@ export const CPP: LanguagePattern[] = [
     type: 'not',
   },
   { pattern: /(const)?(\s+)?val(\s+)(.*)(:(\s)(.*)(\?)?)?(\s+)=(\s+)/, type: 'not' },
+  // Avoiding Dart confusion
+  { pattern: /^(void\s)?main\(\)\s(async\s)?{/, type: 'not' },
 ];

src/languages/cs.ts

@@ -39,4 +39,6 @@ export const CS: LanguagePattern[] = [
   { pattern: /System\.(in|out)\.\w+/, type: 'not' },
   // Avoiding Ruby confusion
   { pattern: /\bmodule\s\S/, type: 'not' },
+  // Avoiding Dart confusion
+  { pattern: /^import\s("|')dart:\w+("|')/, type: 'not' },
 ];

src/languages/dart.ts

@@ -0,0 +1,44 @@
+import type { LanguagePattern } from '../types';
+
+export const Dart: LanguagePattern[] = [
+  // Variable declaration
+  {
+    pattern:
+      /^\s*(const|final|var|dynamic|late)?\s*(int|double|String|bool|List<[A-Za-z [\](),]+>|HashMap<[A-Za-z [\](),]+>|Iterator<[A-Za-z [\](),]+>|Set<[A-Za-z [\](),]+>)?(\?)?\s\w+(\s=\s.+)?(;|,)$/,
+    type: 'keyword.variable',
+  },
+  { pattern: /\bstdout.write\(.+\);/, type: 'keyword.print' },
+  { pattern: /\bprint\(.+\);/, type: 'keyword.print' },
+  { pattern: /^import\s("|')dart:\w+("|')/, type: 'meta.import', nearTop: true },
+  { pattern: /^import\s("|')package:\w+("|')/, type: 'meta.import', nearTop: true },
+  { pattern: /^library\s\w+;/, type: 'meta.module', nearTop: true },
+  { pattern: /^(void\s)?main\(\)\s(async\s)?{/, type: 'keyword.function' },
+  // function with type definition
+  {
+    pattern:
+      /^\s*(List<[A-Za-z [\](),]+>|HashMap<[A-Za-z [\](),]+>|int|double|String|bool|void|Iterator<[A-Za-z [\](),]+>|Set<[A-Za-z [\](),]+>)\s\w+\(.+\)\s*\{$/,
+    type: 'keyword.function',
+  },
+  // arrow function
+  {
+    pattern:
+      /^\s*(int|double|String|bool|List<[A-Za-z [\](),]+>|HashMap<[A-Za-z [\](),]+>|Iterator<[A-Za-z [\](),]+>|Set<[A-Za-z [\](),]+>)\s\w+\(.+\)\s=>/,
+    type: 'keyword.function',
+  },
+  { pattern: /\bnew\s(List|Map|Iterator|HashMap|Set)<\w+>\(\);$/, type: 'keyword.variable' },
+  {
+    pattern: /^(abstract\s)?class\s\w+\s(extends\s\w+\s)?(with\s\w+\s)?(implements\s\w+\s)?{(})?$/,
+    type: 'keyword.control',
+  },
+  { pattern: /\bget\s\w+=>\w+/, type: 'keyword.control' },
+  { pattern: /^\s*@override$/, type: 'keyword.control' },
+  { pattern: /\bset\s\w+\(.+\)/, type: 'keyword.control' },
+  { pattern: /^\s*Future<w+>\s\w+\(.+\)\sasync/, type: 'keyword.control' },
+  { pattern: /^\s*await\sfor/, type: 'keyword.control' },
+  { pattern: /^\s*typedef\s.+\s=/, type: 'keyword.control' },
+  // Avoiding confusion with C
+  { pattern: /\blong\b/, type: 'not' },
+  { pattern: /\s*function\b/, type: 'not' },
+  // Avoiding confusion with Java
+  { pattern: /\bArrayList/, type: 'not' },
+];

src/languages/java.ts

@@ -32,7 +32,7 @@ export const Java: LanguagePattern[] = [
   // while loop
   { pattern: /while\s+\(.+\)/, type: 'keyword.control' },
   // void keyword
-  { pattern: /void/g, type: 'keyword.other' },
+  { pattern: /void/, type: 'keyword.other' },
   // const
   { pattern: /const\s*\w+/, type: 'not' },
   // pointer
@@ -53,4 +53,6 @@ export const Java: LanguagePattern[] = [
   { pattern: /fun main\((.*)?\) {/, type: 'not' },
   { pattern: /(inline(\s+))?fun(\s+)([A-Za-z0-9_])(\s+)?\((.*)\)(\s+)({|=)/, type: 'not' },
   { pattern: /(const)?(\s+)?val(\s+)(.*)(:(\s)(.*)(\?)?)?(\s+)=(\s+)/, type: 'not' },
+  // Avoiding Dart confusion
+  { pattern: /^(void\s)?main\(\)\s{/, type: 'not' },
 ];

src/languages/javascript.ts

@@ -45,4 +45,6 @@ export const Javascript: LanguagePattern[] = [
   { pattern: /fun main\((.*)?\) {/, type: 'not' },
   { pattern: /(inline(\s+))?fun(\s+)([A-Za-z0-9_])(\s+)?\((.*)\)(\s+)({|=)/, type: 'not' },
   { pattern: /(const)?(\s+)?val(\s+)(.*)(:(\s)(.*)(\?)?)?(\s+)=(\s+)/, type: 'not' },
+  // Avoiding Dart confusion
+  { pattern: /^(void\s)?main()\s{/, type: 'not' },
 ];