@harmoniclabs/monaco-editor 0.52.0

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

@@ -0,0 +1,296 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { languages } from '../../fillers/monaco-editor-core';
+
+export const conf: languages.LanguageConfiguration = {
+	comments: {
+		lineComment: '#',
+		blockComment: ["'''", "'''"]
+	},
+	brackets: [
+		['{', '}'],
+		['[', ']'],
+		['(', ')']
+	],
+	autoClosingPairs: [
+		{ open: '{', close: '}' },
+		{ open: '[', close: ']' },
+		{ open: '(', close: ')' },
+		{ open: '"', close: '"', notIn: ['string'] },
+		{ open: "'", close: "'", notIn: ['string', 'comment'] }
+	],
+	surroundingPairs: [
+		{ open: '{', close: '}' },
+		{ open: '[', close: ']' },
+		{ open: '(', close: ')' },
+		{ open: '"', close: '"' },
+		{ open: "'", close: "'" }
+	],
+	onEnterRules: [
+		{
+			beforeText: new RegExp(
+				'^\\s*(?:def|class|for|if|elif|else|while|try|with|finally|except|async|match|case).*?:\\s*$'
+			),
+			action: { indentAction: languages.IndentAction.Indent }
+		}
+	],
+	folding: {
+		offSide: true,
+		markers: {
+			start: new RegExp('^\\s*#region\\b'),
+			end: new RegExp('^\\s*#endregion\\b')
+		}
+	}
+};
+
+export const language = <languages.IMonarchLanguage>{
+	defaultToken: '',
+	tokenPostfix: '.python',
+
+	keywords: [
+		// This section is the result of running
+		// `import keyword; for k in sorted(keyword.kwlist + keyword.softkwlist): print("  '" + k + "',")`
+		// in a Python REPL,
+		// though note that the output from Python 3 is not a strict superset of the
+		// output from Python 2.
+		'False', // promoted to keyword.kwlist in Python 3
+		'None', // promoted to keyword.kwlist in Python 3
+		'True', // promoted to keyword.kwlist in Python 3
+		'_', // new in Python 3.10
+		'and',
+		'as',
+		'assert',
+		'async', // new in Python 3
+		'await', // new in Python 3
+		'break',
+		'case', // new in Python 3.10
+		'class',
+		'continue',
+		'def',
+		'del',
+		'elif',
+		'else',
+		'except',
+		'exec', // Python 2, but not 3.
+		'finally',
+		'for',
+		'from',
+		'global',
+		'if',
+		'import',
+		'in',
+		'is',
+		'lambda',
+		'match', // new in Python 3.10
+		'nonlocal', // new in Python 3
+		'not',
+		'or',
+		'pass',
+		'print', // Python 2, but not 3.
+		'raise',
+		'return',
+		'try',
+		'type', // new in Python 3.12
+		'while',
+		'with',
+		'yield',
+
+		'int',
+		'float',
+		'long',
+		'complex',
+		'hex',
+
+		'abs',
+		'all',
+		'any',
+		'apply',
+		'basestring',
+		'bin',
+		'bool',
+		'buffer',
+		'bytearray',
+		'callable',
+		'chr',
+		'classmethod',
+		'cmp',
+		'coerce',
+		'compile',
+		'complex',
+		'delattr',
+		'dict',
+		'dir',
+		'divmod',
+		'enumerate',
+		'eval',
+		'execfile',
+		'file',
+		'filter',
+		'format',
+		'frozenset',
+		'getattr',
+		'globals',
+		'hasattr',
+		'hash',
+		'help',
+		'id',
+		'input',
+		'intern',
+		'isinstance',
+		'issubclass',
+		'iter',
+		'len',
+		'locals',
+		'list',
+		'map',
+		'max',
+		'memoryview',
+		'min',
+		'next',
+		'object',
+		'oct',
+		'open',
+		'ord',
+		'pow',
+		'print',
+		'property',
+		'reversed',
+		'range',
+		'raw_input',
+		'reduce',
+		'reload',
+		'repr',
+		'reversed',
+		'round',
+		'self',
+		'set',
+		'setattr',
+		'slice',
+		'sorted',
+		'staticmethod',
+		'str',
+		'sum',
+		'super',
+		'tuple',
+		'type',
+		'unichr',
+		'unicode',
+		'vars',
+		'xrange',
+		'zip',
+
+		'__dict__',
+		'__methods__',
+		'__members__',
+		'__class__',
+		'__bases__',
+		'__name__',
+		'__mro__',
+		'__subclasses__',
+		'__init__',
+		'__import__'
+	],
+
+	brackets: [
+		{ open: '{', close: '}', token: 'delimiter.curly' },
+		{ open: '[', close: ']', token: 'delimiter.bracket' },
+		{ open: '(', close: ')', token: 'delimiter.parenthesis' }
+	],
+
+	tokenizer: {
+		root: [
+			{ include: '@whitespace' },
+			{ include: '@numbers' },
+			{ include: '@strings' },
+
+			[/[,:;]/, 'delimiter'],
+			[/[{}\[\]()]/, '@brackets'],
+
+			[/@[a-zA-Z_]\w*/, 'tag'],
+			[
+				/[a-zA-Z_]\w*/,
+				{
+					cases: {
+						'@keywords': 'keyword',
+						'@default': 'identifier'
+					}
+				}
+			]
+		],
+
+		// Deal with white space, including single and multi-line comments
+		whitespace: [
+			[/\s+/, 'white'],
+			[/(^#.*$)/, 'comment'],
+			[/'''/, 'string', '@endDocString'],
+			[/"""/, 'string', '@endDblDocString']
+		],
+		endDocString: [
+			[/[^']+/, 'string'],
+			[/\\'/, 'string'],
+			[/'''/, 'string', '@popall'],
+			[/'/, 'string']
+		],
+		endDblDocString: [
+			[/[^"]+/, 'string'],
+			[/\\"/, 'string'],
+			[/"""/, 'string', '@popall'],
+			[/"/, 'string']
+		],
+
+		// Recognize hex, negatives, decimals, imaginaries, longs, and scientific notation
+		numbers: [
+			[/-?0x([abcdef]|[ABCDEF]|\d)+[lL]?/, 'number.hex'],
+			[/-?(\d*\.)?\d+([eE][+\-]?\d+)?[jJ]?[lL]?/, 'number']
+		],
+
+		// Recognize strings, including those broken across lines with \ (but not without)
+		strings: [
+			[/'$/, 'string.escape', '@popall'],
+			[/f'{1,3}/, 'string.escape', '@fStringBody'],
+			[/'/, 'string.escape', '@stringBody'],
+			[/"$/, 'string.escape', '@popall'],
+			[/f"{1,3}/, 'string.escape', '@fDblStringBody'],
+			[/"/, 'string.escape', '@dblStringBody']
+		],
+		fStringBody: [
+			[/[^\\'\{\}]+$/, 'string', '@popall'],
+			[/[^\\'\{\}]+/, 'string'],
+			[/\{[^\}':!=]+/, 'identifier', '@fStringDetail'],
+			[/\\./, 'string'],
+			[/'/, 'string.escape', '@popall'],
+			[/\\$/, 'string']
+		],
+		stringBody: [
+			[/[^\\']+$/, 'string', '@popall'],
+			[/[^\\']+/, 'string'],
+			[/\\./, 'string'],
+			[/'/, 'string.escape', '@popall'],
+			[/\\$/, 'string']
+		],
+		fDblStringBody: [
+			[/[^\\"\{\}]+$/, 'string', '@popall'],
+			[/[^\\"\{\}]+/, 'string'],
+			[/\{[^\}':!=]+/, 'identifier', '@fStringDetail'],
+			[/\\./, 'string'],
+			[/"/, 'string.escape', '@popall'],
+			[/\\$/, 'string']
+		],
+		dblStringBody: [
+			[/[^\\"]+$/, 'string', '@popall'],
+			[/[^\\"]+/, 'string'],
+			[/\\./, 'string'],
+			[/"/, 'string.escape', '@popall'],
+			[/\\$/, 'string']
+		],
+		fStringDetail: [
+			[/[:][^}]+/, 'string'],
+			[/[!][ars]/, 'string'], // only !a, !r, !s are supported by f-strings: https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals
+			[/=/, 'string'],
+			[/\}/, 'identifier', '@pop']
+		]
+	}
+};

package/src/basic-languages/qsharp/qsharp.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: 'qsharp',
+	extensions: ['.qs'],
+	aliases: ['Q#', 'qsharp'],
+	loader: () => {
+		if (AMD) {
+			return new Promise((resolve, reject) => {
+				require(['vs/basic-languages/qsharp/qsharp'], resolve, reject);
+			});
+		} else {
+			return import('./qsharp');
+		}
+	}
+});

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

@@ -0,0 +1,186 @@
+/*---------------------------------------------------------------------------------------------
+ *  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('qsharp', [
+	[
+		{
+			line: 'open Microsoft.Quantum.Arrays;',
+			tokens: [
+				{ startIndex: 0, type: 'keyword.open.qsharp' },
+				{ startIndex: 4, type: 'white.qsharp' },
+				{ startIndex: 5, type: 'namespace.qsharp' },
+				{ startIndex: 14, type: 'delimiter.qsharp' },
+				{ startIndex: 15, type: 'namespace.qsharp' },
+				{ startIndex: 22, type: 'delimiter.qsharp' },
+				{ startIndex: 23, type: 'namespace.qsharp' },
+				{ startIndex: 29, type: 'delimiter.qsharp' }
+			]
+		},
+		{
+			line: '',
+			tokens: []
+		},
+		{
+			line: 'operation SampleRandomNumber(nQubits : Int) : Result[] {',
+			tokens: [
+				{ startIndex: 0, type: 'keyword.qsharp' },
+				{ startIndex: 9, type: 'white.qsharp' },
+				{ startIndex: 10, type: 'identifier.qsharp' },
+				{ startIndex: 28, type: 'delimiter.parenthesis.qsharp' },
+				{ startIndex: 29, type: 'identifier.qsharp' },
+				{ startIndex: 36, type: 'white.qsharp' },
+				{ startIndex: 37, type: 'operator.qsharp' },
+				{ startIndex: 38, type: 'white.qsharp' },
+				{ startIndex: 39, type: 'type.qsharp' },
+				{ startIndex: 42, type: 'delimiter.parenthesis.qsharp' },
+				{ startIndex: 43, type: 'white.qsharp' },
+				{ startIndex: 44, type: 'operator.qsharp' },
+				{ startIndex: 45, type: 'white.qsharp' },
+				{ startIndex: 46, type: 'type.qsharp' },
+				{ startIndex: 52, type: 'delimiter.square.qsharp' },
+				{ startIndex: 54, type: 'white.qsharp' },
+				{ startIndex: 55, type: 'delimiter.curly.qsharp' }
+			]
+		},
+		{
+			line: '	// We prepare a register of qubits in a uniform',
+			tokens: [
+				{ startIndex: 0, type: 'white.qsharp' },
+				{ startIndex: 1, type: 'comment.qsharp' }
+			]
+		},
+		{
+			line: '	use register = Qubit[nQubits] {',
+			tokens: [
+				{ startIndex: 0, type: 'white.qsharp' },
+				{ startIndex: 1, type: 'keyword.qsharp' },
+				{ startIndex: 4, type: 'white.qsharp' },
+				{ startIndex: 5, type: 'identifier.qsharp' },
+				{ startIndex: 13, type: 'white.qsharp' },
+				{ startIndex: 14, type: 'operator.qsharp' },
+				{ startIndex: 15, type: 'white.qsharp' },
+				{ startIndex: 16, type: 'type.qsharp' },
+				{ startIndex: 21, type: 'delimiter.square.qsharp' },
+				{ startIndex: 22, type: 'identifier.qsharp' },
+				{ startIndex: 29, type: 'delimiter.square.qsharp' },
+				{ startIndex: 30, type: 'white.qsharp' },
+				{ startIndex: 31, type: 'delimiter.curly.qsharp' }
+			]
+		},
+		{
+			line: '		ApplyToEachA(H, register);',
+			tokens: [
+				{ startIndex: 0, type: 'white.qsharp' },
+				{ startIndex: 2, type: 'identifier.qsharp' },
+				{ startIndex: 14, type: 'delimiter.parenthesis.qsharp' },
+				{ startIndex: 15, type: 'keyword.qsharp' },
+				{ startIndex: 16, type: 'delimiter.qsharp' },
+				{ startIndex: 17, type: 'white.qsharp' },
+				{ startIndex: 18, type: 'identifier.qsharp' },
+				{ startIndex: 26, type: 'delimiter.parenthesis.qsharp' },
+				{ startIndex: 27, type: 'delimiter.qsharp' }
+			]
+		},
+		{
+			line: '		return ForEach(MResetZ, register);',
+			tokens: [
+				{ startIndex: 0, type: 'white.qsharp' },
+				{ startIndex: 2, type: 'keyword.qsharp' },
+				{ startIndex: 8, type: 'white.qsharp' },
+				{ startIndex: 9, type: 'identifier.qsharp' },
+				{ startIndex: 16, type: 'delimiter.parenthesis.qsharp' },
+				{ startIndex: 17, type: 'identifier.qsharp' },
+				{ startIndex: 24, type: 'delimiter.qsharp' },
+				{ startIndex: 25, type: 'white.qsharp' },
+				{ startIndex: 26, type: 'identifier.qsharp' },
+				{ startIndex: 34, type: 'delimiter.parenthesis.qsharp' },
+				{ startIndex: 35, type: 'delimiter.qsharp' }
+			]
+		},
+		{
+			line: '	}',
+			tokens: [
+				{ startIndex: 0, type: 'white.qsharp' },
+				{ startIndex: 1, type: 'delimiter.curly.qsharp' }
+			]
+		},
+		{
+			line: '}',
+			tokens: [{ startIndex: 0, type: 'delimiter.curly.qsharp' }]
+		},
+		{
+			line: 'struct Foo { First : Int, Second : Int }',
+			tokens: [
+				{ startIndex: 0, type: 'keyword.qsharp' },
+				{ startIndex: 6, type: 'white.qsharp' },
+				{ startIndex: 7, type: 'identifier.qsharp' },
+				{ startIndex: 10, type: 'white.qsharp' },
+				{ startIndex: 11, type: 'delimiter.curly.qsharp' },
+				{ startIndex: 12, type: 'white.qsharp' },
+				{ startIndex: 13, type: 'identifier.qsharp' },
+				{ startIndex: 18, type: 'white.qsharp' },
+				{ startIndex: 19, type: 'operator.qsharp' },
+				{ startIndex: 20, type: 'white.qsharp' },
+				{ startIndex: 21, type: 'type.qsharp' },
+				{ startIndex: 24, type: 'delimiter.qsharp' },
+				{ startIndex: 25, type: 'white.qsharp' },
+				{ startIndex: 26, type: 'identifier.qsharp' },
+				{ startIndex: 32, type: 'white.qsharp' },
+				{ startIndex: 33, type: 'operator.qsharp' },
+				{ startIndex: 34, type: 'white.qsharp' },
+				{ startIndex: 35, type: 'type.qsharp' },
+				{ startIndex: 38, type: 'white.qsharp' },
+				{ startIndex: 39, type: 'delimiter.curly.qsharp' }
+			]
+		},
+		{
+			line: 'Foo.First',
+			tokens: [
+				{ startIndex: 0, type: 'identifier.qsharp' },
+				{ startIndex: 3, type: 'operator.qsharp' },
+				{ startIndex: 4, type: 'identifier.qsharp' }
+			]
+		},
+		{
+			line: 'import Microsoft.Quantum.Math, Microsoft.Quantum.Diagnostics.*;',
+			tokens: [
+				{ startIndex: 0, type: 'keyword.import.qsharp' },
+				{ startIndex: 6, type: 'white.qsharp' },
+				{ startIndex: 7, type: 'namespace.qsharp' },
+				{ startIndex: 16, type: 'delimiter.qsharp' },
+				{ startIndex: 17, type: 'namespace.qsharp' },
+				{ startIndex: 24, type: 'delimiter.qsharp' },
+				{ startIndex: 25, type: 'identifier.qsharp' },
+				{ startIndex: 29, type: 'delimiter.qsharp' },
+				{ startIndex: 30, type: 'white.qsharp' },
+				{ startIndex: 31, type: 'namespace.qsharp' },
+				{ startIndex: 40, type: 'delimiter.qsharp' },
+				{ startIndex: 41, type: 'namespace.qsharp' },
+				{ startIndex: 48, type: 'delimiter.qsharp' },
+				{ startIndex: 49, type: 'namespace.qsharp' },
+				{ startIndex: 60, type: 'delimiter.qsharp' },
+				{ startIndex: 61, type: 'wildcard.qsharp' },
+				{ startIndex: 62, type: 'delimiter.qsharp' }
+			]
+		},
+		{
+			line: 'export A, B, C;',
+			tokens: [
+				{ startIndex: 0, type: 'keyword.qsharp' },
+				{ startIndex: 6, type: 'white.qsharp' },
+				{ startIndex: 7, type: 'identifier.qsharp' },
+				{ startIndex: 8, type: 'delimiter.qsharp' },
+				{ startIndex: 9, type: 'white.qsharp' },
+				{ startIndex: 10, type: 'identifier.qsharp' },
+				{ startIndex: 11, type: 'delimiter.qsharp' },
+				{ startIndex: 12, type: 'white.qsharp' },
+				{ startIndex: 13, type: 'identifier.qsharp' },
+				{ startIndex: 14, type: 'delimiter.qsharp' }
+			]
+		}
+	]
+]);