monaco-editor: add monaco.languages.setMonarchTokensProvider

build/gulpfile.editor.js

@@ -83,12 +83,21 @@ gulp.task('editor-distro', ['clean-editor-distro', 'minify-editor', 'optimize-ed
 	return es.merge(
 		// other assets
 		es.merge(
-			gulp.src('build/monaco/package.json'),
 			gulp.src('build/monaco/LICENSE'),
 			gulp.src('build/monaco/ThirdPartyNotices.txt'),
 			gulp.src('src/vs/monaco.d.ts')
 		).pipe(gulp.dest('out-monaco-editor-core')),
 
+		// package.json
+		gulp.src('build/monaco/package.json')
+			.pipe(es.through(function(data) {
+				var json = JSON.parse(data.contents.toString());
+				json.private = false;
+				data.contents = new Buffer(JSON.stringify(json, null, '  '));
+				this.emit('data', data);
+			}))
+			.pipe(gulp.dest('out-monaco-editor-core')),
+
 		// dev folder
 		es.merge(
 			gulp.src('out-editor/**/*')

build/monaco/monaco.d.ts.recipe

@@ -38,7 +38,6 @@ declare module monaco {
 #include(vs/base/common/uri): URI
 #include(vs/base/common/keyCodes): KeyCode, KeyMod
 #include(vs/base/common/htmlContent): IHTMLContentElementCode, IHTMLContentElement
-#include(vs/base/common/actions): IAction
 #include(vs/base/browser/keyboardEvent): IKeyboardEvent
 #include(vs/base/browser/mouseEvent): IMouseEvent
 #include(vs/editor/common/editorCommon): IScrollEvent
@@ -54,18 +53,9 @@ declare module monaco.editor {
 #include(vs/editor/browser/standalone/standaloneCodeEditor): IEditorConstructionOptions, IDiffEditorConstructionOptions
 #include(vs/editor/browser/standalone/standaloneServices): IEditorOverrideServices
 #include(vs/platform/markers/common/markers): IMarkerData
-
-    export interface IColorizerOptions {
-        tabSize?: number;
-    }
-
-    export interface IColorizerElementOptions extends IColorizerOptions {
-        theme?: string;
-        mimeType?: string;
-    }
-
-#include(vs/editor/common/modes/monarch/monarchTypes): ILanguage, ILanguageBracket
+#include(vs/editor/browser/standalone/colorizer): IColorizerOptions, IColorizerElementOptions
 #include(vs/base/browser/ui/scrollbar/scrollableElementOptions): ScrollbarVisibility
+#include(vs/base/common/actions): IAction
 #includeAll(vs/editor/common/editorCommon;IMode=>languages.IMode): IPosition, IRange, ISelection, SelectionDirection, IScrollEvent
 #includeAll(vs/editor/browser/editorBrowser;editorCommon.=>):
 }
@@ -78,6 +68,7 @@ declare module monaco.languages {
 #include(vs/editor/common/modes/supports/electricCharacter): IBracketElectricCharacterContribution, IDocComment
 #includeAll(vs/editor/common/modes;editorCommon.IRange=>IRange;editorCommon.IPosition=>IPosition;editorCommon.=>editor.;IToken2=>IToken;ILineTokens2=>ILineTokens;IState2=>IState):
 #include(vs/editor/common/services/modeService): ILanguageExtensionPoint
+#includeAll(vs/editor/common/modes/monarch/monarchTypes):
 
 }
 

build/monaco/package.json

 {
   "name": "monaco-editor-core",
-  "version": "0.2.3",
+  "private": true,
+  "version": "0.3.0",
   "description": "A browser based code editor",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
   "author": "Microsoft Corporation",
   "license": "MIT"
 }

src/vs/editor/browser/standalone/standaloneLanguages.ts

@@ -12,7 +12,7 @@ import {ExtensionsRegistry} from 'vs/platform/extensions/common/extensionsRegist
 import {Extensions, IJSONContributionRegistry} from 'vs/platform/jsonschemas/common/jsonContributionRegistry';
 import {Registry} from 'vs/platform/platform';
 import {ModesRegistry} from 'vs/editor/common/modes/modesRegistry';
-import {ILanguage} from 'vs/editor/common/modes/monarch/monarchTypes';
+import {IMonarchLanguage} from 'vs/editor/common/modes/monarch/monarchTypes';
 import {ILanguageExtensionPoint} from 'vs/editor/common/services/modeService';
 import {ensureStaticPlatformServices} from 'vs/editor/browser/standalone/standaloneServices';
 import * as modes from 'vs/editor/common/modes';
@@ -60,6 +60,17 @@ export function setTokensProvider(languageId:string, support:modes.TokensProvide
 	return staticPlatformServices.modeService.registerTokenizationSupport2(languageId, support);
 }
 
+export function setMonarchTokensProvider(languageId:string, languageDef:IMonarchLanguage): IDisposable {
+	startup.initStaticServicesIfNecessary();
+	let staticPlatformServices = ensureStaticPlatformServices(null);
+	let lexer = compile(languageId, languageDef);
+	let modeService = staticPlatformServices.modeService;
+
+	return modeService.registerTokenizationSupport(languageId, (mode) => {
+		return createTokenizationSupport(modeService, mode, lexer);
+	});
+}
+
 export function registerReferenceProvider(languageId:string, support:modes.ReferenceProvider): IDisposable {
 	return modes.ReferenceProviderRegistry.register(languageId, support);
 }
@@ -296,7 +307,7 @@ export function registerMonarchStandaloneLanguage(language:ILanguageExtensionPoi
 	ModesRegistry.registerLanguage(language);
 
 	ExtensionsRegistry.registerOneTimeActivationEventListener('onLanguage:' + language.id, () => {
-		require([defModule], (value:{language:ILanguage;conf:IRichLanguageConfiguration}) => {
+		require([defModule], (value:{language:IMonarchLanguage;conf:IRichLanguageConfiguration}) => {
 			if (!value.language) {
 				console.error('Expected ' + defModule + ' to export a `language`');
 				return;
@@ -363,6 +374,7 @@ export function createMonacoLanguagesAPI(): typeof monaco.languages {
 		// provider methods
 		setLanguageConfiguration: setLanguageConfiguration,
 		setTokensProvider: setTokensProvider,
+		setMonarchTokensProvider: setMonarchTokensProvider,
 		registerReferenceProvider: registerReferenceProvider,
 		registerRenameProvider: registerRenameProvider,
 		registerCompletionItemProvider: registerCompletionItemProvider,
@@ -378,9 +390,6 @@ export function createMonacoLanguagesAPI(): typeof monaco.languages {
 		registerOnTypeFormattingEditProvider: registerOnTypeFormattingEditProvider,
 		registerLinkProvider: registerLinkProvider,
 
-		// other methods
-		// registerMonarchStandaloneLanguage: registerMonarchStandaloneLanguage,
-
 		// enums
 		DocumentHighlightKind: modes.DocumentHighlightKind,
 		CompletionItemKind: CompletionItemKind,

src/vs/editor/common/editorCommon.ts

@@ -959,6 +959,7 @@ export interface IConfigurationChangedEvent {
 
 /**
  * An event describing that one or more supports of a mode have changed.
+ * @internal
  */
 export interface IModeSupportChangedEvent {
 	tokenizationSupport:boolean;
@@ -1418,6 +1419,9 @@ export interface ITextModelResolvedOptions {
 	trimAutoWhitespace: boolean;
 }
 
+/**
+ * @internal
+ */
 export interface ITextModelCreationOptions {
 	tabSize: number;
 	insertSpaces: boolean;
@@ -2029,6 +2033,9 @@ export interface IModel extends IReadOnlyModel, IEditableTextModel, ITextModelWi
 
 	onDidChangeRawContent(listener: (e:IModelContentChangedEvent)=>void): IDisposable;
 	onDidChangeContent(listener: (e:IModelContentChangedEvent2)=>void): IDisposable;
+	/**
+	 * @internal
+	 */
 	onDidChangeModeSupport(listener: (e:IModeSupportChangedEvent)=>void): IDisposable;
 	onDidChangeDecorations(listener: (e:IModelDecorationsChangedEvent)=>void): IDisposable;
 	onDidChangeOptions(listener: (e:IModelOptionsChangedEvent)=>void): IDisposable;
@@ -3519,6 +3526,9 @@ export interface IRangeWithMessage {
 export interface ICommonCodeEditor extends IEditor {
 
 	onDidChangeModel(listener: (e:IModelChangedEvent)=>void): IDisposable;
+	/**
+	 * @internal
+	 */
 	onDidChangeModelModeSupport(listener: (e:IModeSupportChangedEvent)=>void): IDisposable;
 	onDidChangeModelDecorations(listener: (e:IModelDecorationsChangedEvent)=>void): IDisposable;
 

src/vs/editor/common/modes/monarch/monarchCompile.ts

@@ -11,7 +11,7 @@
 
 import * as objects from 'vs/base/common/objects';
 import * as monarchCommon from 'vs/editor/common/modes/monarch/monarchCommon';
-import {ILanguage, ILanguageBracket} from 'vs/editor/common/modes/monarch/monarchTypes';
+import {IMonarchLanguage, IMonarchLanguageBracket} from 'vs/editor/common/modes/monarch/monarchTypes';
 
 /*
  * Type helpers
@@ -386,7 +386,7 @@ class Rule implements monarchCommon.IRule {
  * (Currently we have no samples that need this so perhaps we should always have
  * jsonStrict to true).
  */
-export function compile(languageId:string, json: ILanguage): monarchCommon.ILexer {
+export function compile(languageId:string, json: IMonarchLanguage): monarchCommon.ILexer {
 	if (!json || typeof (json) !== 'object') {
 		throw new Error('Monarch: expecting a language definition object');
 	}
@@ -512,7 +512,7 @@ export function compile(languageId:string, json: ILanguage): monarchCommon.ILexe
 			{ open: '(', close: ')', token: 'delimiter.parenthesis' },
 			{ open: '<', close: '>', token: 'delimiter.angle' }];
 	}
-	var brackets : ILanguageBracket[] = [];
+	var brackets : IMonarchLanguageBracket[] = [];
 	for (var bracketIdx in json.brackets) {
 		if (json.brackets.hasOwnProperty(bracketIdx)) {
 			var desc = <any> json.brackets[bracketIdx];

src/vs/editor/common/modes/monarch/monarchTypes.ts

@@ -13,11 +13,11 @@
 /**
  * A Monarch language definition
  */
-export interface ILanguage {
+export interface IMonarchLanguage {
 	/**
 	 * map from string to ILanguageRule[]
 	 */
-	tokenizer: Object;
+	tokenizer: {[name:string]:IMonarchLanguageRule[]};
 	/**
 	 * is the language case insensitive?
 	 */
@@ -29,7 +29,7 @@ export interface ILanguage {
 	/**
 	 * for example [['{','}','delimiter.curly']]
 	 */
-	brackets?: ILanguageBracket[];
+	brackets?: IMonarchLanguageBracket[];
 	/**
 	 * start symbol in the tokenizer (by default the first entry is used)
 	 */
@@ -45,7 +45,7 @@ export interface ILanguage {
  * 		shorthands: [reg,act] == { regex: reg, action: act}
  *		and       : [reg,act,nxt] == { regex: reg, action: act{ next: nxt }}
  */
-export interface ILanguageRule {
+export interface IMonarchLanguageRule {
 	/**
 	 * match tokens
 	 */
@@ -53,7 +53,7 @@ export interface ILanguageRule {
 	/**
 	 * action to take on match
 	 */
-	action?: ILanguageAction;
+	action?: IMonarchLanguageAction;
 
 	/**
 	 * or an include rule. include all rules from the included state
@@ -66,11 +66,11 @@ export interface ILanguageRule {
  * ... or a case statement with guards...
  * ... or a basic action with a token value.
  */
-export interface ILanguageAction {
+export interface IMonarchLanguageAction {
 	/**
 	 * array of actions for each parenthesized match group
 	 */
-	group?: ILanguageAction[];
+	group?: IMonarchLanguageAction[];
 
 	/**
 	 * map from string to ILanguageAction
@@ -110,7 +110,7 @@ export interface ILanguageAction {
 /**
  * This interface can be shortened as an array, ie. ['{','}','delimiter.curly']
  */
-export interface ILanguageBracket {
+export interface IMonarchLanguageBracket {
 	/**
 	 * open bracket
 	 */

src/vs/editor/standalone-languages/all.ts

@@ -11,12 +11,12 @@ var global:any = self;
 global.MonacoEditorLanguages = global.MonacoEditorLanguages || [];
 let MonacoEditorLanguages: ILanguageDef[] = global.MonacoEditorLanguages;
 
-MonacoEditorLanguages.push({
-	id: 'bat',
-	extensions: [ '.bat', '.cmd'],
-	aliases: [ 'Batch', 'bat' ],
-	defModule: 'vs/editor/standalone-languages/bat'
-});
+// MonacoEditorLanguages.push({
+// 	id: 'bat',
+// 	extensions: [ '.bat', '.cmd'],
+// 	aliases: [ 'Batch', 'bat' ],
+// 	defModule: 'vs/editor/standalone-languages/bat'
+// });
 MonacoEditorLanguages.push({
 	id: 'coffeescript',
 	extensions: [ '.coffee' ],

src/vs/editor/standalone-languages/buildfile.js

@@ -6,7 +6,7 @@
 
 exports.collectModules = function() {
 	return [
-		{ name: "vs/editor/standalone-languages/bat" },
+		// { name: "vs/editor/standalone-languages/bat" },
 		{ name: "vs/editor/standalone-languages/coffee" },
 		{ name: "vs/editor/standalone-languages/cpp" },
 		{ name: "vs/editor/standalone-languages/csharp" },

src/vs/editor/standalone-languages/types.ts

@@ -17,7 +17,7 @@ export interface ILanguageDef {
 
 export interface ILanguage {
 	// required
-	tokenizer: Object;							// map from string to ILanguageRule[]
+	tokenizer: any;							// map from string to ILanguageRule[]
 	tokenPostfix: string;						// attach this to every token class (by default '.' + name)
 
 	// optional

src/vs/editor/test/common/modesUtil.ts

@@ -9,7 +9,7 @@ import {Model} from 'vs/editor/common/model/model';
 import * as modes from 'vs/editor/common/modes';
 import {compile} from 'vs/editor/common/modes/monarch/monarchCompile';
 import {createTokenizationSupport} from 'vs/editor/common/modes/monarch/monarchLexer';
-import {ILanguage} from 'vs/editor/common/modes/monarch/monarchTypes';
+import {IMonarchLanguage} from 'vs/editor/common/modes/monarch/monarchTypes';
 import {createMockModeService} from 'vs/editor/test/common/servicesTestUtils';
 import {MockMode} from 'vs/editor/test/common/mocks/mockMode';
 import {RichEditSupport, IRichLanguageConfiguration} from 'vs/editor/common/modes/languageConfigurationRegistry';
@@ -94,7 +94,7 @@ export function executeTests2(tokenizationSupport: modes.TokensProvider, tests:I
 	}
 }
 
-export function executeMonarchTokenizationTests(name:string, language:ILanguage, tests:ITestItem[][]): void {
+export function executeMonarchTokenizationTests(name:string, language:IMonarchLanguage, tests:ITestItem[][]): void {
 	var lexer = compile(name, language);
 
 	var modeService = createMockModeService();

src/vs/languages/less/common/less.ts

@@ -23,7 +23,7 @@ import {wireCancellationToken} from 'vs/base/common/async';
 import {createTokenizationSupport} from 'vs/editor/common/modes/monarch/monarchLexer';
 import {LanguageConfigurationRegistry, IRichLanguageConfiguration} from 'vs/editor/common/modes/languageConfigurationRegistry';
 
-export var language: Types.ILanguage = <Types.ILanguage> {
+export var language: Types.IMonarchLanguage = <Types.IMonarchLanguage> {
 	defaultToken: '',
 	tokenPostfix: '.less',
 

src/vs/languages/markdown/common/markdown.ts

@@ -24,7 +24,7 @@ import {LanguageConfigurationRegistry, IRichLanguageConfiguration} from 'vs/edit
 import {wireCancellationToken} from 'vs/base/common/async';
 
 export const language =
-	<Types.ILanguage>{
+	<Types.IMonarchLanguage>{
 		defaultToken: '',
 		tokenPostfix: '.md',
 

src/vs/languages/sass/common/sass.ts

@@ -23,7 +23,7 @@ import {wireCancellationToken} from 'vs/base/common/async';
 import {createTokenizationSupport} from 'vs/editor/common/modes/monarch/monarchLexer';
 import {LanguageConfigurationRegistry, IRichLanguageConfiguration} from 'vs/editor/common/modes/languageConfigurationRegistry';
 
-export var language = <Types.ILanguage>{
+export var language = <Types.IMonarchLanguage>{
 	defaultToken: '',
 	tokenPostfix: '.sass',
 

src/vs/monaco.d.ts

@@ -355,16 +355,6 @@ declare module monaco {
         code?: IHTMLContentElementCode;
     }
 
-    export interface IAction extends IDisposable {
-        id: string;
-        label: string;
-        tooltip: string;
-        class: string;
-        enabled: boolean;
-        checked: boolean;
-        run(event?: any): Promise<any>;
-    }
-
     export interface IKeyboardEvent {
         browserEvent: Event;
         target: HTMLElement;
@@ -709,92 +699,22 @@ declare module monaco.editor {
         theme?: string;
         mimeType?: string;
     }
-
-    /**
-     * A Monarch language definition
-     */
-    export interface ILanguage {
-        /**
-         * unique name to identify the language.
-         */
-        name: string;
-        /**
-         * map from string to ILanguageRule[]
-         */
-        tokenizer: Object;
-        /**
-         * nice display name
-         */
-        displayName?: string;
-        /**
-         * is the language case insensitive?
-         */
-        ignoreCase?: boolean;
-        /**
-         * used to insert/delete line comments in the editor
-         */
-        lineComment?: string;
-        /**
-         * used to insert/delete block comments in the editor
-         */
-        blockCommentStart?: string;
-        /**
-         * used to insert/delete block comments in the editor
-         */
-        blockCommentEnd?: string;
-        /**
-         * if no match in the tokenizer assign this token class (default 'source')
-         */
-        defaultToken?: string;
-        /**
-         * for example [['{','}','delimiter.curly']]
-         */
-        brackets?: ILanguageBracket[];
-        /**
-         * start symbol in the tokenizer (by default the first entry is used)
-         */
-        start?: string;
-        /**
-         * attach this to every token class (by default '.' + name)
-         */
-        tokenPostfix?: string;
-        /**
-         * for example [['"','"']]
-         */
-        autoClosingPairs?: string[][];
-        /**
-         * word definition regular expression
-         */
-        wordDefinition?: RegExp;
-        /**
-         * characters that could potentially cause outdentation
-         */
-        outdentTriggers?: string;
-    }
-
-    /**
-     * This interface can be shortened as an array, ie. ['{','}','delimiter.curly']
-     */
-    export interface ILanguageBracket {
-        /**
-         * open bracket
-         */
-        open: string;
-        /**
-         * closeing bracket
-         */
-        close: string;
-        /**
-         * token class
-         */
-        token: string;
-    }
     export enum ScrollbarVisibility {
         Auto = 1,
         Hidden = 2,
         Visible = 3,
     }
 
+    export interface IAction extends IDisposable {
+        id: string;
+        label: string;
+        tooltip: string;
+        class: string;
+        enabled: boolean;
+        checked: boolean;
+        run(event?: any): Promise<any>;
+    }
+
     /**
      * Configuration options for editor scrollbars
      */
@@ -1040,6 +960,10 @@ declare module monaco.editor {
          * Defaults to 500 (ms)
          */
         quickSuggestionsDelay?: number;
+        /**
+         * Enables parameter hints
+         */
+        parameterHints?: boolean;
         /**
          * Render icons in suggestions box.
          * Defaults to true.
@@ -1218,6 +1142,7 @@ declare module monaco.editor {
         contextmenu: boolean;
         quickSuggestions: boolean;
         quickSuggestionsDelay: number;
+        parameterHints: boolean;
         iconsInSuggestions: boolean;
         formatOnType: boolean;
         suggestOnTriggerCharacters: boolean;
@@ -1263,14 +1188,6 @@ declare module monaco.editor {
         contribInfo: boolean;
     }
 
-    /**
-     * An event describing that one or more supports of a mode have changed.
-     */
-    export interface IModeSupportChangedEvent {
-        tokenizationSupport: boolean;
-        richEditSupport: boolean;
-    }
-
     /**
      * Vertical Lane in the overview ruler of the editor.
      */
@@ -1586,14 +1503,6 @@ declare module monaco.editor {
         trimAutoWhitespace: boolean;
     }
 
-    export interface ITextModelCreationOptions {
-        tabSize: number;
-        insertSpaces: boolean;
-        detectIndentation: boolean;
-        trimAutoWhitespace: boolean;
-        defaultEOL: DefaultEndOfLine;
-    }
-
     export interface ITextModelUpdateOptions {
         tabSize?: number;
         insertSpaces?: boolean;
@@ -1903,7 +1812,6 @@ declare module monaco.editor {
     export interface IModel extends IReadOnlyModel, IEditableTextModel, ITextModelWithMarkers, ITokenizedModel, ITextModelWithTrackedRanges, ITextModelWithDecorations, IEditorModel {
         onDidChangeRawContent(listener: (e: IModelContentChangedEvent) => void): IDisposable;
         onDidChangeContent(listener: (e: IModelContentChangedEvent2) => void): IDisposable;
-        onDidChangeModeSupport(listener: (e: IModeSupportChangedEvent) => void): IDisposable;
         onDidChangeDecorations(listener: (e: IModelDecorationsChangedEvent) => void): IDisposable;
         onDidChangeOptions(listener: (e: IModelOptionsChangedEvent) => void): IDisposable;
         onDidChangeMode(listener: (e: IModelModeChangedEvent) => void): IDisposable;
@@ -2765,7 +2673,6 @@ declare module monaco.editor {
 
     export interface ICommonCodeEditor extends IEditor {
         onDidChangeModel(listener: (e: IModelChangedEvent) => void): IDisposable;
-        onDidChangeModelModeSupport(listener: (e: IModeSupportChangedEvent) => void): IDisposable;
         onDidChangeModelDecorations(listener: (e: IModelDecorationsChangedEvent) => void): IDisposable;
         onDidFocusEditorText(listener: () => void): IDisposable;
         onDidBlurEditorText(listener: () => void): IDisposable;
@@ -3308,6 +3215,8 @@ declare module monaco.languages {
 
     export function setTokensProvider(languageId: string, support: TokensProvider): IDisposable;
 
+    export function setMonarchTokensProvider(languageId: string, languageDef: IMonarchLanguage): IDisposable;
+
     export function registerReferenceProvider(languageId: string, support: ReferenceProvider): IDisposable;
 
     export function registerRenameProvider(languageId: string, support: RenameProvider): IDisposable;
@@ -3410,7 +3319,6 @@ declare module monaco.languages {
 
     export interface IBracketElectricCharacterContribution {
         docComment?: IDocComment;
-        caseInsensitive?: boolean;
         embeddedElectricCharacters?: string[];
     }
 
@@ -3672,6 +3580,119 @@ declare module monaco.languages {
         mimetypes?: string[];
         configuration?: string;
     }
+    /**
+     * A Monarch language definition
+     */
+    export interface IMonarchLanguage {
+        /**
+         * map from string to ILanguageRule[]
+         */
+        tokenizer: {
+            [name: string]: IMonarchLanguageRule[];
+        };
+        /**
+         * is the language case insensitive?
+         */
+        ignoreCase?: boolean;
+        /**
+         * if no match in the tokenizer assign this token class (default 'source')
+         */
+        defaultToken?: string;
+        /**
+         * for example [['{','}','delimiter.curly']]
+         */
+        brackets?: IMonarchLanguageBracket[];
+        /**
+         * start symbol in the tokenizer (by default the first entry is used)
+         */
+        start?: string;
+        /**
+         * attach this to every token class (by default '.' + name)
+         */
+        tokenPostfix: string;
+    }
+
+    /**
+     * A rule is either a regular expression and an action
+     * 		shorthands: [reg,act] == { regex: reg, action: act}
+     *		and       : [reg,act,nxt] == { regex: reg, action: act{ next: nxt }}
+     */
+    export interface IMonarchLanguageRule {
+        /**
+         * match tokens
+         */
+        regex?: string | RegExp;
+        /**
+         * action to take on match
+         */
+        action?: IMonarchLanguageAction;
+        /**
+         * or an include rule. include all rules from the included state
+         */
+        include?: string;
+    }
+
+    /**
+     * An action is either an array of actions...
+     * ... or a case statement with guards...
+     * ... or a basic action with a token value.
+     */
+    export interface IMonarchLanguageAction {
+        /**
+         * array of actions for each parenthesized match group
+         */
+        group?: IMonarchLanguageAction[];
+        /**
+         * map from string to ILanguageAction
+         */
+        cases?: Object;
+        /**
+         * token class (ie. css class) (or "@brackets" or "@rematch")
+         */
+        token?: string;
+        /**
+         * the next state to push, or "@push", "@pop", "@popall"
+         */
+        next?: string;
+        /**
+         * switch to this state
+         */
+        switchTo?: string;
+        /**
+         * go back n characters in the stream
+         */
+        goBack?: number;
+        /**
+         * @open or @close
+         */
+        bracket?: string;
+        /**
+         * switch to embedded language (useing the mimetype) or get out using "@pop"
+         */
+        nextEmbedded?: string;
+        /**
+         * log a message to the browser console window
+         */
+        log?: string;
+    }
+
+    /**
+     * This interface can be shortened as an array, ie. ['{','}','delimiter.curly']
+     */
+    export interface IMonarchLanguageBracket {
+        /**
+         * open bracket
+         */
+        open: string;
+        /**
+         * closeing bracket
+         */
+        close: string;
+        /**
+         * token class
+         */
+        token: string;
+    }
 
 }
 

src/vs/workbench/parts/output/common/outputMode.ts

@@ -21,7 +21,7 @@ import {createTokenizationSupport} from 'vs/editor/common/modes/monarch/monarchL
 import {LanguageConfigurationRegistry, IRichLanguageConfiguration} from 'vs/editor/common/modes/languageConfigurationRegistry';
 import {wireCancellationToken} from 'vs/base/common/async';
 
-export const language: types.ILanguage = {
+export const language: types.IMonarchLanguage = {
 	defaultToken: '',
 	tokenPostfix: '.log',
 	ignoreCase: true,