@harmoniclabs/monaco-editor 0.52.0

package/src/basic-languages/css/css.ts

@@ -0,0 +1,215 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import type { languages } from '../../fillers/monaco-editor-core';
+
+export const conf: languages.LanguageConfiguration = {
+	wordPattern: /(#?-?\d*\.\d\w*%?)|((::|[@#.!:])?[\w-?]+%?)|::|[@#.!:]/g,
+
+	comments: {
+		blockComment: ['/*', '*/']
+	},
+
+	brackets: [
+		['{', '}'],
+		['[', ']'],
+		['(', ')']
+	],
+
+	autoClosingPairs: [
+		{ open: '{', close: '}', notIn: ['string', 'comment'] },
+		{ open: '[', close: ']', notIn: ['string', 'comment'] },
+		{ open: '(', close: ')', notIn: ['string', 'comment'] },
+		{ open: '"', close: '"', notIn: ['string', 'comment'] },
+		{ open: "'", close: "'", notIn: ['string', 'comment'] }
+	],
+
+	surroundingPairs: [
+		{ open: '{', close: '}' },
+		{ open: '[', close: ']' },
+		{ open: '(', close: ')' },
+		{ open: '"', close: '"' },
+		{ open: "'", close: "'" }
+	],
+
+	folding: {
+		markers: {
+			start: new RegExp('^\\s*\\/\\*\\s*#region\\b\\s*(.*?)\\s*\\*\\/'),
+			end: new RegExp('^\\s*\\/\\*\\s*#endregion\\b.*\\*\\/')
+		}
+	}
+};
+
+export const language = <languages.IMonarchLanguage>{
+	defaultToken: '',
+	tokenPostfix: '.css',
+
+	ws: '[ \t\n\r\f]*', // whitespaces (referenced in several rules)
+	identifier:
+		'-?-?([a-zA-Z]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))([\\w\\-]|(\\\\(([0-9a-fA-F]{1,6}\\s?)|[^[0-9a-fA-F])))*',
+
+	brackets: [
+		{ open: '{', close: '}', token: 'delimiter.bracket' },
+		{ open: '[', close: ']', token: 'delimiter.bracket' },
+		{ open: '(', close: ')', token: 'delimiter.parenthesis' },
+		{ open: '<', close: '>', token: 'delimiter.angle' }
+	],
+
+	tokenizer: {
+		root: [{ include: '@selector' }],
+
+		selector: [
+			{ include: '@comments' },
+			{ include: '@import' },
+			{ include: '@strings' },
+			[
+				'[@](keyframes|-webkit-keyframes|-moz-keyframes|-o-keyframes)',
+				{ token: 'keyword', next: '@keyframedeclaration' }
+			],
+			['[@](page|content|font-face|-moz-document)', { token: 'keyword' }],
+			['[@](charset|namespace)', { token: 'keyword', next: '@declarationbody' }],
+			[
+				'(url-prefix)(\\()',
+				['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }]
+			],
+			[
+				'(url)(\\()',
+				['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }]
+			],
+			{ include: '@selectorname' },
+			['[\\*]', 'tag'], // selector symbols
+			['[>\\+,]', 'delimiter'], // selector operators
+			['\\[', { token: 'delimiter.bracket', next: '@selectorattribute' }],
+			['{', { token: 'delimiter.bracket', next: '@selectorbody' }]
+		],
+
+		selectorbody: [
+			{ include: '@comments' },
+			['[*_]?@identifier@ws:(?=(\\s|\\d|[^{;}]*[;}]))', 'attribute.name', '@rulevalue'], // rule definition: to distinguish from a nested selector check for whitespace, number or a semicolon
+			['}', { token: 'delimiter.bracket', next: '@pop' }]
+		],
+
+		selectorname: [
+			['(\\.|#(?=[^{])|%|(@identifier)|:)+', 'tag'] // selector (.foo, div, ...)
+		],
+
+		selectorattribute: [{ include: '@term' }, [']', { token: 'delimiter.bracket', next: '@pop' }]],
+
+		term: [
+			{ include: '@comments' },
+			[
+				'(url-prefix)(\\()',
+				['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }]
+			],
+			[
+				'(url)(\\()',
+				['attribute.value', { token: 'delimiter.parenthesis', next: '@urldeclaration' }]
+			],
+			{ include: '@functioninvocation' },
+			{ include: '@numbers' },
+			{ include: '@name' },
+			{ include: '@strings' },
+			['([<>=\\+\\-\\*\\/\\^\\|\\~,])', 'delimiter'],
+			[',', 'delimiter']
+		],
+
+		rulevalue: [
+			{ include: '@comments' },
+			{ include: '@strings' },
+			{ include: '@term' },
+			['!important', 'keyword'],
+			[';', 'delimiter', '@pop'],
+			['(?=})', { token: '', next: '@pop' }] // missing semicolon
+		],
+
+		warndebug: [['[@](warn|debug)', { token: 'keyword', next: '@declarationbody' }]],
+
+		import: [['[@](import)', { token: 'keyword', next: '@declarationbody' }]],
+
+		urldeclaration: [
+			{ include: '@strings' },
+			['[^)\r\n]+', 'string'],
+			['\\)', { token: 'delimiter.parenthesis', next: '@pop' }]
+		],
+
+		parenthizedterm: [
+			{ include: '@term' },
+			['\\)', { token: 'delimiter.parenthesis', next: '@pop' }]
+		],
+
+		declarationbody: [
+			{ include: '@term' },
+			[';', 'delimiter', '@pop'],
+			['(?=})', { token: '', next: '@pop' }] // missing semicolon
+		],
+
+		comments: [
+			['\\/\\*', 'comment', '@comment'],
+			['\\/\\/+.*', 'comment']
+		],
+
+		comment: [
+			['\\*\\/', 'comment', '@pop'],
+			[/[^*/]+/, 'comment'],
+			[/./, 'comment']
+		],
+
+		name: [['@identifier', 'attribute.value']],
+
+		numbers: [
+			['-?(\\d*\\.)?\\d+([eE][\\-+]?\\d+)?', { token: 'attribute.value.number', next: '@units' }],
+			['#[0-9a-fA-F_]+(?!\\w)', 'attribute.value.hex']
+		],
+
+		units: [
+			[
+				'(em|ex|ch|rem|fr|vmin|vmax|vw|vh|vm|cm|mm|in|px|pt|pc|deg|grad|rad|turn|s|ms|Hz|kHz|%)?',
+				'attribute.value.unit',
+				'@pop'
+			]
+		],
+
+		keyframedeclaration: [
+			['@identifier', 'attribute.value'],
+			['{', { token: 'delimiter.bracket', switchTo: '@keyframebody' }]
+		],
+
+		keyframebody: [
+			{ include: '@term' },
+			['{', { token: 'delimiter.bracket', next: '@selectorbody' }],
+			['}', { token: 'delimiter.bracket', next: '@pop' }]
+		],
+
+		functioninvocation: [
+			['@identifier\\(', { token: 'attribute.value', next: '@functionarguments' }]
+		],
+
+		functionarguments: [
+			['\\$@identifier@ws:', 'attribute.name'],
+			['[,]', 'delimiter'],
+			{ include: '@term' },
+			['\\)', { token: 'attribute.value', next: '@pop' }]
+		],
+
+		strings: [
+			['~?"', { token: 'string', next: '@stringenddoublequote' }],
+			["~?'", { token: 'string', next: '@stringendquote' }]
+		],
+
+		stringenddoublequote: [
+			['\\\\.', 'string'],
+			['"', { token: 'string', next: '@pop' }],
+			[/[^\\"]+/, 'string'],
+			['.', 'string']
+		],
+
+		stringendquote: [
+			['\\\\.', 'string'],
+			["'", { token: 'string', next: '@pop' }],
+			[/[^\\']+/, 'string'],
+			['.', 'string']
+		]
+	}
+};

package/src/basic-languages/cypher/cypher.contribution.ts

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { registerLanguage } from '../_.contribution';
+
+declare var AMD: any;
+declare var require: any;
+
+registerLanguage({
+	id: 'cypher',
+	extensions: ['.cypher', '.cyp'],
+	aliases: ['Cypher', 'OpenCypher'],
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/cypher/cypher'], resolve, reject);
+			});
+		} else {
+			return import('./cypher');
+		}
+	}
+});

package/src/basic-languages/cypher/cypher.test.ts

@@ -0,0 +1,327 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { testTokenization } from '../test/testRunner';
+
+testTokenization('cypher', [
+	// Comments
+	[
+		{
+			line: '// Single line comment',
+			tokens: [{ startIndex: 0, type: 'comment.cypher' }]
+		}
+	],
+	[
+		{
+			line: 'MATCH /* comment part */ xyz',
+			tokens: [
+				{ startIndex: 0, type: 'keyword.cypher' },
+				{ startIndex: 5, type: 'white.cypher' },
+				{ startIndex: 6, type: 'comment.cypher' },
+				{ startIndex: 24, type: 'white.cypher' },
+				{ startIndex: 25, type: 'identifier.cypher' }
+			]
+		}
+	],
+	[
+		{
+			line: '/* multi line comment',
+			tokens: [{ startIndex: 0, type: 'comment.cypher' }]
+		},
+		{
+			line: 'comment continues MATCH // not done yet',
+			tokens: [{ startIndex: 0, type: 'comment.cypher' }]
+		},
+		{
+			line: 'comment ends */ MATCH',
+			tokens: [
+				{ startIndex: 0, type: 'comment.cypher' },
+				{ startIndex: 15, type: 'white.cypher' },
+				{ startIndex: 16, type: 'keyword.cypher' }
+			]
+		}
+	],
+
+	// Numbers: A decimal (integer or float) literal:
+	[
+		{
+			line: '13',
+			tokens: [{ startIndex: 0, type: 'number.cypher' }]
+		}
+	],
+	[
+		{
+			line: '-40000',
+			tokens: [{ startIndex: 0, type: 'number.cypher' }]
+		}
+	],
+	[
+		{
+			line: '3.14',
+			tokens: [{ startIndex: 0, type: 'number.float.cypher' }]
+		}
+	],
+	[
+		{
+			line: '.314',
+			tokens: [{ startIndex: 0, type: 'number.float.cypher' }]
+		}
+	],
+	[
+		{
+			line: '-.314',
+			tokens: [{ startIndex: 0, type: 'number.float.cypher' }]
+		}
+	],
+	[
+		{
+			line: '6.022E23',
+			tokens: [{ startIndex: 0, type: 'number.float.cypher' }]
+		}
+	],
+	[
+		{
+			line: '-6.022e23',
+			tokens: [{ startIndex: 0, type: 'number.float.cypher' }]
+		}
+	],
+	[
+		{
+			line: '12E10',
+			tokens: [{ startIndex: 0, type: 'number.float.cypher' }]
+		}
+	],
+	[
+		{
+			line: '12e10',
+			tokens: [{ startIndex: 0, type: 'number.float.cypher' }]
+		}
+	],
+	[
+		{
+			line: '12e-10',
+			tokens: [{ startIndex: 0, type: 'number.float.cypher' }]
+		}
+	],
+	[
+		{
+			line: '12E-10',
+			tokens: [{ startIndex: 0, type: 'number.float.cypher' }]
+		}
+	],
+
+	// Numbers: A hexadecimal integer literal (starting with 0x)
+	[
+		{
+			line: '0x13af',
+			tokens: [{ startIndex: 0, type: 'number.hex.cypher' }]
+		}
+	],
+	[
+		{
+			line: '0xFC3A9',
+			tokens: [{ startIndex: 0, type: 'number.hex.cypher' }]
+		}
+	],
+	[
+		{
+			line: '-0x66eff',
+			tokens: [{ startIndex: 0, type: 'number.hex.cypher' }]
+		}
+	],
+
+	// Numbers: An octal integer literal (starting with 0)
+	[
+		{
+			line: '01372',
+			tokens: [{ startIndex: 0, type: 'number.octal.cypher' }]
+		}
+	],
+	[
+		{
+			line: '02127',
+			tokens: [{ startIndex: 0, type: 'number.octal.cypher' }]
+		}
+	],
+	[
+		{
+			line: '-05671',
+			tokens: [{ startIndex: 0, type: 'number.octal.cypher' }]
+		}
+	],
+
+	// Strings: A String literal ('', ""), escaped and non-escaped
+	[
+		{
+			line: '"two \'words\'"',
+			tokens: [{ startIndex: 0, type: 'string.cypher' }]
+		}
+	],
+	[
+		{
+			line: '"two \\"words\\""',
+			tokens: [{ startIndex: 0, type: 'string.cypher' }]
+		}
+	],
+	[
+		{
+			line: '\'two "words"\'',
+			tokens: [{ startIndex: 0, type: 'string.cypher' }]
+		}
+	],
+	[
+		{
+			line: "'two \\'words\\''",
+			tokens: [{ startIndex: 0, type: 'string.cypher' }]
+		}
+	],
+
+	// Identifiers wrapped with backtick (``)
+	[
+		{
+			line: '`variable`',
+			tokens: [{ startIndex: 0, type: 'identifier.escape.cypher' }]
+		}
+	],
+	[
+		{
+			line: '`A variable with weird stuff in it[]!`',
+			tokens: [{ startIndex: 0, type: 'identifier.escape.cypher' }]
+		}
+	],
+	[
+		{
+			line: '`Escaped \\`variable\\``',
+			tokens: [{ startIndex: 0, type: 'identifier.escape.cypher' }]
+		}
+	],
+
+	// Operators
+	[
+		{
+			line: '1+2',
+			tokens: [
+				{ startIndex: 0, type: 'number.cypher' },
+				{ startIndex: 1, type: 'delimiter.cypher' },
+				{ startIndex: 2, type: 'number.cypher' }
+			]
+		}
+	],
+	[
+		{
+			line: '1++2',
+			tokens: [
+				{ startIndex: 0, type: 'number.cypher' },
+				{ startIndex: 1, type: '' },
+				{ startIndex: 3, type: 'number.cypher' }
+			]
+		}
+	],
+
+	// Builtin literals: A boolean literal (true | false)
+	[
+		{
+			line: 'true',
+			tokens: [{ startIndex: 0, type: 'predefined.literal.cypher' }]
+		}
+	],
+	[
+		{
+			line: 'false',
+			tokens: [{ startIndex: 0, type: 'predefined.literal.cypher' }]
+		}
+	],
+	[
+		{
+			line: 'TRUE',
+			tokens: [{ startIndex: 0, type: 'predefined.literal.cypher' }]
+		}
+	],
+	[
+		{
+			line: 'FALSE',
+			tokens: [{ startIndex: 0, type: 'predefined.literal.cypher' }]
+		}
+	],
+
+	// Builtin literals: A null literal
+	[
+		{
+			line: 'null',
+			tokens: [{ startIndex: 0, type: 'predefined.literal.cypher' }]
+		}
+	],
+	[
+		{
+			line: 'NULL',
+			tokens: [{ startIndex: 0, type: 'predefined.literal.cypher' }]
+		}
+	],
+
+	// Builtin functions
+	[
+		{
+			line: 'properties(node)',
+			tokens: [
+				{ startIndex: 0, type: 'predefined.function.cypher' },
+				{ startIndex: 10, type: 'delimiter.parenthesis.cypher' },
+				{ startIndex: 11, type: 'identifier.cypher' },
+				{ startIndex: 15, type: 'delimiter.parenthesis.cypher' }
+			]
+		}
+	],
+	[
+		{
+			line: 'left(right("Hello Cypher"))',
+			tokens: [
+				{ startIndex: 0, type: 'predefined.function.cypher' },
+				{ startIndex: 4, type: 'delimiter.parenthesis.cypher' },
+				{ startIndex: 5, type: 'predefined.function.cypher' },
+				{ startIndex: 10, type: 'delimiter.parenthesis.cypher' },
+				{ startIndex: 11, type: 'string.cypher' },
+				{ startIndex: 25, type: 'delimiter.parenthesis.cypher' }
+			]
+		}
+	],
+
+	// Keywords
+	[
+		{
+			line: 'MATCH (n) RETURN n',
+			tokens: [
+				{ startIndex: 0, type: 'keyword.cypher' },
+				{ startIndex: 5, type: 'white.cypher' },
+				{ startIndex: 6, type: 'delimiter.parenthesis.cypher' },
+				{ startIndex: 7, type: 'identifier.cypher' },
+				{ startIndex: 8, type: 'delimiter.parenthesis.cypher' },
+				{ startIndex: 9, type: 'white.cypher' },
+				{ startIndex: 10, type: 'keyword.cypher' },
+				{ startIndex: 16, type: 'white.cypher' },
+				{ startIndex: 17, type: 'identifier.cypher' }
+			]
+		}
+	],
+
+	// Labels on nodes and relationships
+	[
+		{
+			line: '(n:NodeLabel1)-[:RelationshipType]->(:NodeLabel2:NodeLabel3)',
+			tokens: [
+				{ startIndex: 0, type: 'delimiter.parenthesis.cypher' },
+				{ startIndex: 1, type: 'identifier.cypher' },
+				{ startIndex: 2, type: 'type.identifier.cypher' },
+				{ startIndex: 13, type: 'delimiter.parenthesis.cypher' },
+				{ startIndex: 14, type: 'delimiter.cypher' },
+				{ startIndex: 15, type: 'delimiter.bracket.cypher' },
+				{ startIndex: 16, type: 'type.identifier.cypher' },
+				{ startIndex: 33, type: 'delimiter.bracket.cypher' },
+				{ startIndex: 34, type: 'delimiter.cypher' },
+				{ startIndex: 36, type: 'delimiter.parenthesis.cypher' },
+				{ startIndex: 37, type: 'type.identifier.cypher' },
+				{ startIndex: 59, type: 'delimiter.parenthesis.cypher' }
+			]
+		}
+	]
+]);