RubyGems - presently - Versions diffs - 0.1.0 - Mend

presently 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (215) hide show

data/public/_components/@socketry/syntax/test/Syntax/Language/io.js ADDED Viewed

@@ -0,0 +1,229 @@
+/**
+ * Tests for Io 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('Io language can be registered', async () => {
+	const language = await syntax.getResource('io');
+	assert.ok(language);
+	assert.equal(language.name, 'io');
+});
+test('Io can match return keyword', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'return 42');
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'return'));
+});
+test('Io can match assignment operator', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'x := 42');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === ':='));
+});
+test('Io can match slot assignment operator', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'x ::= 42');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '::='));
+});
+test('Io can match logical operators', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'true or false and true');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === 'or'));
+	assert.ok(operators.some(m => m.value === 'and'));
+});
+test('Io can match at operator', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'obj @method');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '@'));
+});
+test('Io can match arithmetic operators', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'x + y - z * a / b % c');
+	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 === '%'));
+});
+test('Io can match bitwise operators', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'x & y | z ~ a');
+	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 === '~'));
+});
+test('Io can match comparison operators', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'x < y = z > a');
+	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 === '>'));
+});
+test('Io can match bracket operators', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'x := [1, 2, 3]');
+	const operators = matches.filter(m => m.type === 'operator');
+	// Brackets are operators in the Io syntax definition
+	assert.ok(operators.length > 0);
+});
+test('Io can match new operator', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'obj := Object new');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === 'new'));
+});
+test('Io can match space-delimited method invocations', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'obj println');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'println'));
+});
+test('Io can match method calls after parentheses', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'list(1, 2) println');
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'println'));
+});
+test('Io can match CamelCase types', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, 'Person := Object clone');
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'Person'));
+	assert.ok(types.some(m => m.value === 'Object'));
+});
+test('Io can match Perl-style comments', async () => {
+	const language = await syntax.getResource('io');
+	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('Io can match C-style comments', async () => {
+	const language = await syntax.getResource('io');
+	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('Io can match C++-style comments', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(
+		syntax,
+		'// This is a comment\nx := 5'
+	);
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.some(m => m.value === '// This is a comment'));
+});
+test('Io can match single-quoted strings', async () => {
+	const language = await syntax.getResource('io');
+	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('Io can match double-quoted strings', async () => {
+	const language = await syntax.getResource('io');
+	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('Io can match string escapes', async () => {
+	const language = await syntax.getResource('io');
+	const matches = await language.getMatches(syntax, '"Line 1\\nLine 2"');
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.length > 0);
+});
+test('Io can match decimal numbers', async () => {
+	const language = await syntax.getResource('io');
+	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('Io can match hexadecimal numbers', async () => {
+	const language = await syntax.getResource('io');
+	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('Io can process object cloning', async () => {
+	const language = await syntax.getResource('io');
+	const code = 'Person := Object clone';
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'Person'));
+	assert.ok(types.some(m => m.value === 'Object'));
+});
+test('Io can process method definitions', async () => {
+	const language = await syntax.getResource('io');
+	const code = 'Person greet := method("Hello, " .. self name)';
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'Person'));
+});
+test('Io can process complete program', async () => {
+	const language = await syntax.getResource('io');
+	const code = `# Factorial function
+factorial := method(n,
+	if(n <= 1,
+		return 1,
+		return n * factorial(n - 1)
+	)
+)
+factorial(5) println`;
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.some(m => m.value === '# Factorial function'));
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'return'));
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === ':='));
+});

data/public/_components/@socketry/syntax/test/Syntax/Language/java.js ADDED Viewed

@@ -0,0 +1,362 @@
+/**
+ * Tests for Java 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('Java language can be registered', async () => {
+	const language = await syntax.getResource('java');
+	assert.ok(language);
+	assert.equal(language.name, 'java');
+});
+test('Java can match class keyword', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(syntax, 'public class MyClass { }');
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'class'));
+});
+test('Java can match control flow keywords', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'if (x > 0) { return true; } else { return false; }'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'if'));
+	assert.ok(keywords.some(m => m.value === 'else'));
+	assert.ok(keywords.some(m => m.value === 'return'));
+});
+test('Java can match loop keywords', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'for (int i = 0; i < 10; i++) { while (true) { break; } }'
+	);
+	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 === 'break'));
+});
+test('Java can match exception keywords', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'try { } catch (Exception e) { throw e; } finally { }'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'try'));
+	assert.ok(keywords.some(m => m.value === 'catch'));
+	assert.ok(keywords.some(m => m.value === 'throw'));
+	assert.ok(keywords.some(m => m.value === 'finally'));
+});
+test('Java can match access modifiers', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'public private protected package'
+	);
+	const access = matches.filter(m => m.type === 'access');
+	assert.ok(access.some(m => m.value === 'public'));
+	assert.ok(access.some(m => m.value === 'private'));
+	assert.ok(access.some(m => m.value === 'protected'));
+	assert.ok(access.some(m => m.value === 'package'));
+});
+test('Java can match primitive types', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'int x; double y; boolean flag; char c;'
+	);
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'int'));
+	assert.ok(types.some(m => m.value === 'double'));
+	assert.ok(types.some(m => m.value === 'boolean'));
+	assert.ok(types.some(m => m.value === 'char'));
+});
+test('Java can match void type', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(syntax, 'void method() { }');
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'void'));
+});
+test('Java can match constants', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'this.value = true; that.value = false; x = null;'
+	);
+	const constants = matches.filter(m => m.type === 'constant');
+	assert.ok(constants.some(m => m.value === 'this'));
+	assert.ok(constants.some(m => m.value === 'true'));
+	assert.ok(constants.some(m => m.value === 'false'));
+	assert.ok(constants.some(m => m.value === 'null'));
+});
+test('Java can match comparison operators', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'if (a == b && c != d || e < f && g > h)'
+	);
+	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('Java can match assignment operators', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(syntax, 'x += 5; y -= 3; z *= 2;');
+	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 === '*='));
+});
+test('Java can match bitwise operators', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(syntax, 'x << 2; y >> 1; z >>> 3;');
+	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 === '>>>'));
+});
+test('Java can match increment and decrement operators', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(syntax, 'i++; j--;');
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === '++'));
+	assert.ok(operators.some(m => m.value === '--'));
+});
+test('Java can match instanceof operator', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'if (obj instanceof String)'
+	);
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === 'instanceof'));
+});
+test('Java can match new operator', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'String s = new String("test");'
+	);
+	const operators = matches.filter(m => m.type === 'operator');
+	assert.ok(operators.some(m => m.value === 'new'));
+});
+test('Java can match CamelCase types', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'String name; ArrayList<Integer> list;'
+	);
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'String'));
+	assert.ok(types.some(m => m.value === 'ArrayList'));
+	assert.ok(types.some(m => m.value === 'Integer'));
+});
+test('Java can match C-style comments', async () => {
+	const language = await syntax.getResource('java');
+	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('Java can match C++-style comments', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'// This is a comment\nint x = 5;'
+	);
+	const comments = matches.filter(m => m.type === 'comment');
+	assert.ok(comments.some(m => m.value === '// This is a comment'));
+});
+test('Java can match decimal numbers', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'int x = 42; double 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('Java can match hexadecimal numbers', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(syntax, 'int color = 0xFF00AA;');
+	const numbers = matches.filter(m => m.type === 'constant');
+	assert.ok(numbers.some(m => m.value === '0xFF00AA'));
+});
+test('Java can match single-quoted strings', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(syntax, "char c = 'a';");
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === "'a'"));
+});
+test('Java can match double-quoted strings', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'String s = "Hello, World!";'
+	);
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.some(m => m.value === '"Hello, World!"'));
+});
+test('Java can match string escapes', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'String s = "Line 1\\nLine 2";'
+	);
+	const strings = matches.filter(m => m.type === 'string');
+	assert.ok(strings.length > 0);
+});
+test('Java can match function calls', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'System.out.println("Hello");'
+	);
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'println'));
+});
+test('Java can match method definitions', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'public void doSomething() { }'
+	);
+	const functions = matches.filter(m => m.type === 'function');
+	assert.ok(functions.some(m => m.value === 'doSomething'));
+});
+test('Java can match interface keyword', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'public interface MyInterface { }'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'interface'));
+});
+test('Java can match implements keyword', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'class MyClass implements MyInterface { }'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'implements'));
+});
+test('Java can match extends keyword', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'class Child extends Parent { }'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'extends'));
+});
+test('Java can match static and final keywords', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'public static final int MAX = 100;'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'static'));
+	assert.ok(keywords.some(m => m.value === 'final'));
+});
+test('Java can match abstract keyword', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'public abstract class MyClass { }'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'abstract'));
+});
+test('Java can match synchronized keyword', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'synchronized void method() { }'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'synchronized'));
+});
+test('Java can match enum keyword', async () => {
+	const language = await syntax.getResource('java');
+	const matches = await language.getMatches(
+		syntax,
+		'enum Color { RED, GREEN, BLUE }'
+	);
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'enum'));
+});
+test('Java can process complete class definition', async () => {
+	const language = await syntax.getResource('java');
+	const code = `public class Calculator {
+	private int result;
+	public int add(int a, int b) {
+		return a + b;
+	}
+}`;
+	const matches = await language.getMatches(syntax, code);
+	assert.ok(matches.length > 0);
+	const access = matches.filter(m => m.type === 'access');
+	assert.ok(access.some(m => m.value === 'public'));
+	assert.ok(access.some(m => m.value === 'private'));
+	const keywords = matches.filter(m => m.type === 'keyword');
+	assert.ok(keywords.some(m => m.value === 'class'));
+	assert.ok(keywords.some(m => m.value === 'return'));
+	const types = matches.filter(m => m.type === 'type');
+	assert.ok(types.some(m => m.value === 'int'));
+});

data/public/_components/@socketry/syntax/test/Syntax/Language/javascript.js ADDED Viewed

@@ -0,0 +1,101 @@
+import Syntax from '../../../Syntax.js';
+import registerJavaScript from '../../../Syntax/Language/javascript.js';
+import {strictEqual, ok} from 'node:assert';
+import test from 'node:test';
+async function getLanguage() {
+	const syntax = new Syntax();
+	registerJavaScript(syntax);
+	return await syntax.getLanguage('javascript');
+}
+function typesFrom(matches) {
+	return matches.map(m => m.expression.type);
+}
+test('JavaScript: keywords highlighted', async () => {
+	const language = await getLanguage();
+	const code =
+		'async function run() { await fetch(); const x = class {}; let y; var z; return yield; }';
+	const matches = await language.getMatches(Syntax.default, code);
+	const types = typesFrom(matches);
+	ok(types.includes('keyword'));
+});
+test('JavaScript: constants highlighted', async () => {
+	const language = await getLanguage();
+	const code = 'this === null || true && false';
+	const matches = await language.getMatches(Syntax.default, code);
+	const constants = matches.filter(m => m.expression.type === 'constant');
+	ok(constants.length >= 4);
+});
+test('JavaScript: operators highlighted', async () => {
+	const language = await getLanguage();
+	const code = 'a + b * c / d - e & f | g ~ h ! i % j < k = l > m';
+	const matches = await language.getMatches(Syntax.default, code);
+	const operators = matches.filter(m => m.expression.type === 'operator');
+	ok(operators.length > 0);
+});
+test('JavaScript: access modifiers highlighted', async () => {
+	const language = await getLanguage();
+	const code =
+		'public interface Foo extends Bar implements Baz { private x; protected y; package z; }';
+	const matches = await language.getMatches(Syntax.default, code);
+	const access = matches.filter(m => m.expression.type === 'access');
+	ok(access.length >= 5);
+});
+test('JavaScript: regex literals', async () => {
+	const language = await getLanguage();
+	const code = 'const pattern = /test\\d+/gi;';
+	const matches = await language.getMatches(Syntax.default, code);
+	const regex = matches.filter(
+		m => m.expression.type === 'constant' && m.value.startsWith('/')
+	);
+	ok(regex.length >= 1);
+});
+test('JavaScript: comments', async () => {
+	const language = await getLanguage();
+	const code = '/* block */ // line';
+	const matches = await language.getMatches(Syntax.default, code);
+	const comments = matches.filter(m => m.expression.type === 'comment');
+	ok(comments.length >= 2);
+});
+test('JavaScript: strings', async () => {
+	const language = await getLanguage();
+	const code =
+		'const a = "double"; const b = \'single\'; const c = "esc\\"ape";';
+	const matches = await language.getMatches(Syntax.default, code);
+	const strings = matches.filter(m => m.expression.type === 'string');
+	ok(strings.length >= 3);
+});
+test('JavaScript: numbers', async () => {
+	const language = await getLanguage();
+	const code = 'const a = 42; const b = 3.14; const c = 0xFF;';
+	const matches = await language.getMatches(Syntax.default, code);
+	const numbers = matches.filter(
+		m => m.expression.type === 'constant' && /^\d/.test(m.value)
+	);
+	ok(numbers.length >= 3);
+});
+test('JavaScript: function calls', async () => {
+	const language = await getLanguage();
+	const code = 'console.log("test"); Math.max(1, 2);';
+	const matches = await language.getMatches(Syntax.default, code);
+	const functions = matches.filter(m => m.expression.type === 'function');
+	ok(functions.length >= 2);
+});
+test('JavaScript: CamelCase types', async () => {
+	const language = await getLanguage();
+	const code = 'const obj = new MyClass();';
+	const matches = await language.getMatches(Syntax.default, code);
+	const types = matches.filter(m => m.expression.type === 'type');
+	ok(types.length >= 1);
+});