presently 0.1.0

data/public/_components/@socketry/syntax/test/Syntax/Language/json.js

@@ -0,0 +1,101 @@
+import Syntax from '../../../Syntax.js';
+import registerJSON from '../../../Syntax/Language/json.js';
+import {strictEqual, ok} from 'node:assert';
+import test from 'node:test';
+
+async function getLanguage() {
+	const syntax = new Syntax();
+	registerJSON(syntax);
+	return await syntax.getLanguage('json');
+}
+
+function typesFrom(matches) {
+	return matches.map(m => m.expression.type);
+}
+
+test('JSON language can be registered', async () => {
+	const language = await getLanguage();
+	strictEqual(language.name, 'json');
+});
+
+test('JSON: true, false, null constants', async () => {
+	const language = await getLanguage();
+	const code = 'true false null';
+	const matches = await language.getMatches(Syntax.default, code);
+	const constants = matches.filter(m => m.expression.type === 'constant');
+	strictEqual(constants.length, 3);
+});
+
+test('JSON: integer numbers', async () => {
+	const language = await getLanguage();
+	const code = '0 42 -17 999';
+	const matches = await language.getMatches(Syntax.default, code);
+	const numbers = matches.filter(m => m.expression.type === 'constant' && /^-?\d/.test(m.value));
+	ok(numbers.length >= 4);
+});
+
+test('JSON: float numbers', async () => {
+	const language = await getLanguage();
+	const code = '3.14 -0.5 123.456';
+	const matches = await language.getMatches(Syntax.default, code);
+	const numbers = matches.filter(m => m.expression.type === 'constant' && m.value.includes('.'));
+	ok(numbers.length >= 3);
+});
+
+test('JSON: scientific notation', async () => {
+	const language = await getLanguage();
+	const code = '1e10 2.5e-3 -1.23E+5';
+	const matches = await language.getMatches(Syntax.default, code);
+	const numbers = matches.filter(m => m.expression.type === 'constant' && /e/i.test(m.value));
+	ok(numbers.length >= 3);
+});
+
+test('JSON: strings', async () => {
+	const language = await getLanguage();
+	const code = '"hello" "world" "with \\"escaped\\" quotes"';
+	const matches = await language.getMatches(Syntax.default, code);
+	const strings = matches.filter(m => m.expression.type === 'string');
+	ok(strings.length >= 3);
+});
+
+test('JSON: object keys', async () => {
+	const language = await getLanguage();
+	const code = '{"name": "value", "age": 42}';
+	const matches = await language.getMatches(Syntax.default, code);
+	const keys = matches.filter(m => m.expression.type === 'key');
+	ok(keys.length >= 2);
+});
+
+test('JSON: structural operators', async () => {
+	const language = await getLanguage();
+	const code = '{} [] , : ';
+	const matches = await language.getMatches(Syntax.default, code);
+	const operators = matches.filter(m => m.expression.type === 'operator');
+	ok(operators.length >= 4);
+});
+
+test('JSON: nested object', async () => {
+	const language = await getLanguage();
+	const code = '{"user": {"name": "John", "age": 30}}';
+	const matches = await language.getMatches(Syntax.default, code);
+	const keys = matches.filter(m => m.expression.type === 'key');
+	ok(keys.length >= 3);
+});
+
+test('JSON: array', async () => {
+	const language = await getLanguage();
+	const code = '[1, 2, "three", true, null]';
+	const matches = await language.getMatches(Syntax.default, code);
+	const types = typesFrom(matches);
+	ok(types.includes('constant'));
+	ok(types.includes('string'));
+	ok(types.includes('operator'));
+});
+
+test('JSON: complex structure', async () => {
+	const language = await getLanguage();
+	const code = '{"items": [{"id": 1, "active": true}, {"id": 2, "active": false}]}';
+	const matches = await language.getMatches(Syntax.default, code);
+	const keys = matches.filter(m => m.expression.type === 'key');
+	ok(keys.length >= 5);
+});

data/public/_components/@socketry/syntax/test/Syntax/Language/lisp.js

@@ -0,0 +1,224 @@
+/**
+ * Tests for Lisp language syntax highlighting
+ */
+
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {JSDOM} from 'jsdom';
+import Syntax from '../../../Syntax.js';
+
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+global.window = dom.window;
+global.document = dom.window.document;
+global.HTMLElement = dom.window.HTMLElement;
+global.customElements = dom.window.customElements;
+
+const syntax = new Syntax();
+
+test('Lisp language can be registered', async () => {
+	const language = await syntax.getResource('lisp');
+	assert.ok(language);
+	assert.equal(language.name, 'lisp');
+});
+
+test('Lisp can match parentheses operators', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '(+ 1 2)');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '('));
+	assert.ok(operators.some(m => m.value === ')'));
+});
+
+test('Lisp can match single semicolon comments', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '; This is a comment');
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.some(m => m.value === '; This is a comment'));
+});
+
+test('Lisp can match double semicolon comments', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, ';; This is a comment');
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.some(m => m.value === ';; This is a comment'));
+});
+
+test('Lisp can match triple semicolon comments', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, ';;; Section header');
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.some(m => m.value === ';;; Section header'));
+});
+
+test('Lisp can match decimal numbers', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '(+ 42 3.14)');
+	const numbers = matches.filter(m => m.type === 'constant');
+	assert.ok(numbers.some(m => m.value === '42'));
+	assert.ok(numbers.some(m => m.value === '3.14'));
+});
+
+test('Lisp can match hexadecimal numbers', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '0xFF 0x1A2B');
+	const numbers = matches.filter(m => m.type === 'constant');
+	assert.ok(numbers.some(m => m.value === '0xFF'));
+	assert.ok(numbers.some(m => m.value === '0x1A2B'));
+});
+
+test('Lisp can match hash constants', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '#t #f #nil');
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === '#t'));
+	assert.ok(constants.some(m => m.value === '#f'));
+	assert.ok(constants.some(m => m.value === '#nil'));
+});
+
+test('Lisp can match hash keywords', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '#true #false');
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === '#true'));
+	assert.ok(constants.some(m => m.value === '#false'));
+});
+
+test('Lisp can match function calls', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '(defun factorial (n))');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'defun'));
+});
+
+test('Lisp can match function names in expressions', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '(+ 1 2)');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === '+'));
+});
+
+test('Lisp can match built-in functions', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '(list 1 2 3)');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'list'));
+});
+
+test('Lisp can match special forms', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '(if condition then else)');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'if'));
+});
+
+test('Lisp can match lambda expressions', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '(lambda (x) (* x x))');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'lambda'));
+});
+
+test('Lisp can match double-quoted strings', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '"Hello, World!"');
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === '"Hello, World!"'));
+});
+
+test('Lisp can match multi-line strings', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '"Line 1\nLine 2"');
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value.includes('Line 1')));
+});
+
+test('Lisp can match string escapes', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '"Say \\"Hello\\""');
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.length > 0);
+});
+
+test('Lisp can match nested expressions', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '(+ (* 2 3) (- 5 1))');
+	const operators = matches.filter(m => m.type === 'operator');
+	const openParens = operators.filter(m => m.value === '(');
+	const closeParens = operators.filter(m => m.value === ')');
+	assert.ok(openParens.length >= 3);
+	assert.ok(closeParens.length >= 3);
+});
+
+test('Lisp can match let bindings', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(
+		syntax,
+		'(let ((x 10) (y 20)) (+ x y))'
+	);
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'let'));
+});
+
+test('Lisp can match define statements', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '(define x 42)');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'define'));
+});
+
+test('Lisp can match setq assignments', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '(setq x 100)');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'setq'));
+});
+
+test('Lisp can process complete function definition', async () => {
+	const language = await syntax.getResource('lisp');
+	const code = `(defun factorial (n)
+	(if (<= n 1)
+		1
+		(* n (factorial (- n 1)))))`;
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'defun'));
+	assert.ok(functions.some(m => m.value === 'if'));
+	assert.ok(functions.some(m => m.value === '<='));
+	assert.ok(functions.some(m => m.value === '*'));
+	assert.ok(functions.some(m => m.value === 'factorial'));
+	assert.ok(functions.some(m => m.value === '-'));
+});
+
+test('Lisp can process code with comments', async () => {
+	const language = await syntax.getResource('lisp');
+	const code = `; Calculate factorial
+(defun factorial (n)
+	;; Base case
+	(if (<= n 1)
+		1  ; Return 1
+		(* n (factorial (- n 1)))))`;
+	const matches = await language.getMatches(syntax, code);
+
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.some(m => m.value === '; Calculate factorial'));
+	assert.ok(comments.some(m => m.value === ';; Base case'));
+	assert.ok(comments.some(m => m.value === '; Return 1'));
+});
+
+test('Lisp can match quoted expressions', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, "'(1 2 3)");
+	// Quote is just part of the syntax, lists are in parentheses
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '('));
+	assert.ok(operators.some(m => m.value === ')'));
+});
+
+test('Lisp can match backquote and unquote', async () => {
+	const language = await syntax.getResource('lisp');
+	const matches = await language.getMatches(syntax, '`(1 ,x 3)');
+	// Backquote and comma are part of the expression syntax
+	assert.ok(matches.length > 0);
+});

data/public/_components/@socketry/syntax/test/Syntax/Language/lua.js

@@ -0,0 +1,307 @@
+/**
+ * Tests for Lua language syntax highlighting
+ */
+
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {JSDOM} from 'jsdom';
+import Syntax from '../../../Syntax.js';
+
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>');
+global.window = dom.window;
+global.document = dom.window.document;
+global.HTMLElement = dom.window.HTMLElement;
+global.customElements = dom.window.customElements;
+
+const syntax = new Syntax();
+
+test('Lua language can be registered', async () => {
+	const language = await syntax.getResource('lua');
+	assert.ok(language);
+	assert.equal(language.name, 'lua');
+});
+
+test('Lua can match function keyword', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'function test() end');
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'function'));
+	assert.ok(keywords.some(m => m.value === 'end'));
+});
+
+test('Lua can match local keyword', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'local x = 10');
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'local'));
+});
+
+test('Lua can match control flow keywords', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'if x > 0 then return true else return false end'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'if'));
+	assert.ok(keywords.some(m => m.value === 'then'));
+	assert.ok(keywords.some(m => m.value === 'else'));
+	assert.ok(keywords.some(m => m.value === 'return'));
+	assert.ok(keywords.some(m => m.value === 'end'));
+});
+
+test('Lua can match elseif keyword', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'if x > 0 then elseif x < 0 then else end'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'elseif'));
+});
+
+test('Lua can match loop keywords', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'for i = 1, 10 do end while true do break end'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'for'));
+	assert.ok(keywords.some(m => m.value === 'while'));
+	assert.ok(keywords.some(m => m.value === 'do'));
+	assert.ok(keywords.some(m => m.value === 'break'));
+});
+
+test('Lua can match repeat until keywords', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'repeat x = x + 1 until x > 10'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'repeat'));
+	assert.ok(keywords.some(m => m.value === 'until'));
+});
+
+test('Lua can match in keyword', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'for k, v in pairs(t) do end'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'in'));
+});
+
+test('Lua can match logical keywords', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'if x > 0 and y < 10 or not z then end'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'and'));
+	assert.ok(keywords.some(m => m.value === 'or'));
+	assert.ok(keywords.some(m => m.value === 'not'));
+});
+
+test('Lua can match boolean constants', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'x = true; y = false');
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'true'));
+	assert.ok(constants.some(m => m.value === 'false'));
+});
+
+test('Lua can match nil constant', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'x = nil');
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'nil'));
+});
+
+test('Lua can match self constant', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'function obj:method() self.value = 10 end'
+	);
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'self'));
+});
+
+test('Lua can match arithmetic operators', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'x + y - z * a / b % c ^ d');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '+'));
+	assert.ok(operators.some(m => m.value === '-'));
+	assert.ok(operators.some(m => m.value === '*'));
+	assert.ok(operators.some(m => m.value === '/'));
+	assert.ok(operators.some(m => m.value === '%'));
+	assert.ok(operators.some(m => m.value === '^'));
+});
+
+test('Lua can match comparison operators', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'if x == y or a ~= b or c < d or e > f then end'
+	);
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '=='));
+	assert.ok(operators.some(m => m.value === '~='));
+	assert.ok(operators.some(m => m.value === '<'));
+	assert.ok(operators.some(m => m.value === '>'));
+});
+
+test('Lua can match less/greater than or equal operators', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'if x <= y and a >= b then end'
+	);
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '<='));
+	assert.ok(operators.some(m => m.value === '>='));
+});
+
+test('Lua can match concatenation operator', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		's = "Hello" .. " " .. "World"'
+	);
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '..'));
+});
+
+test('Lua can match length operator', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'len = #table');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '#'));
+});
+
+test('Lua can match assignment operator', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'x = 10');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '='));
+});
+
+test('Lua can match colon operator', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'obj:method()');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === ':'));
+});
+
+test('Lua can match single-line comments', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'-- This is a comment\nx = 10'
+	);
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.some(m => m.value === '-- This is a comment'));
+});
+
+test('Lua can match multi-line comments', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(
+		syntax,
+		'--[[ This is a\nmulti-line comment ]]--'
+	);
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.some(m => m.value.includes('multi-line')));
+});
+
+test('Lua can match single-quoted strings', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, "s = 'Hello, World!'");
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === "'Hello, World!'"));
+});
+
+test('Lua can match double-quoted strings', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 's = "Hello, World!"');
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === '"Hello, World!"'));
+});
+
+test('Lua can match string escapes', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 's = "Line 1\\nLine 2"');
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.length > 0);
+});
+
+test('Lua can match decimal numbers', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'x = 42; y = 3.14');
+	const numbers = matches.filter(m => m.type === 'constant');
+	assert.ok(numbers.some(m => m.value === '42'));
+	assert.ok(numbers.some(m => m.value === '3.14'));
+});
+
+test('Lua can match hexadecimal numbers', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'color = 0xFF00AA');
+	const numbers = matches.filter(m => m.type === 'constant');
+	assert.ok(numbers.some(m => m.value === '0xFF00AA'));
+});
+
+test('Lua can match CamelCase types', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'MyClass = {}');
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'MyClass'));
+});
+
+test('Lua can match function calls', async () => {
+	const language = await syntax.getResource('lua');
+	const matches = await language.getMatches(syntax, 'print("Hello")');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'print'));
+});
+
+test('Lua can process complete function definition', async () => {
+	const language = await syntax.getResource('lua');
+	const code = `function factorial(n)
+	if n <= 1 then
+		return 1
+	else
+		return n * factorial(n - 1)
+	end
+end`;
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'function'));
+	assert.ok(keywords.some(m => m.value === 'if'));
+	assert.ok(keywords.some(m => m.value === 'then'));
+	assert.ok(keywords.some(m => m.value === 'return'));
+	assert.ok(keywords.some(m => m.value === 'else'));
+	assert.ok(keywords.some(m => m.value === 'end'));
+});
+
+test('Lua can process table definition', async () => {
+	const language = await syntax.getResource('lua');
+	const code = `local person = {
+	name = "Alice",
+	age = 30,
+	greet = function(self)
+		print("Hello, " .. self.name)
+	end
+}`;
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'local'));
+	assert.ok(keywords.some(m => m.value === 'function'));
+});