Initial VS Code 1.19 source merge (#571)

* Initial 1.19 xcopy

* Fix yarn build

* Fix numerous build breaks

* Next batch of build break fixes

* More build break fixes

* Runtime breaks

* Additional post merge fixes

* Fix windows setup file

* Fix test failures.

* Update license header blocks to refer to source eula

src/vs/editor/common/viewModel/prefixSumComputer.ts

@@ -205,10 +205,6 @@ export class PrefixSumComputerWithCache {
 		this._cache = null;
 	}
 
-	public getCount(): number {
-		return this._actual.getCount();
-	}
-
 	public insertValues(insertIndex: number, insertValues: Uint32Array): void {
 		if (this._actual.insertValues(insertIndex, insertValues)) {
 			this._bustCache();

src/vs/editor/common/viewModel/splitLinesCollection.ts

@@ -5,7 +5,6 @@
 'use strict';
 
 import { Position } from 'vs/editor/common/core/position';
-import { Selection } from 'vs/editor/common/core/selection';
 import { Range } from 'vs/editor/common/core/range';
 import * as editorCommon from 'vs/editor/common/editorCommon';
 import { LineTokens } from 'vs/editor/common/core/lineTokens';
@@ -110,12 +109,6 @@ export class CoordinatesConverter implements ICoordinatesConverter {
 		return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
 	}
 
-	public convertViewSelectionToModelSelection(viewSelection: Selection): Selection {
-		let selectionStart = this._lines.convertViewPositionToModelPosition(viewSelection.selectionStartLineNumber, viewSelection.selectionStartColumn);
-		let position = this._lines.convertViewPositionToModelPosition(viewSelection.positionLineNumber, viewSelection.positionColumn);
-		return new Selection(selectionStart.lineNumber, selectionStart.column, position.lineNumber, position.column);
-	}
-
 	public validateViewPosition(viewPosition: Position, expectedModelPosition: Position): Position {
 		return this._lines.validateViewPosition(viewPosition.lineNumber, viewPosition.column, expectedModelPosition);
 	}
@@ -138,12 +131,6 @@ export class CoordinatesConverter implements ICoordinatesConverter {
 		return new Range(start.lineNumber, start.column, end.lineNumber, end.column);
 	}
 
-	public convertModelSelectionToViewSelection(modelSelection: Selection): Selection {
-		let selectionStart = this._lines.convertModelPositionToViewPosition(modelSelection.selectionStartLineNumber, modelSelection.selectionStartColumn);
-		let position = this._lines.convertModelPositionToViewPosition(modelSelection.positionLineNumber, modelSelection.positionColumn);
-		return new Selection(selectionStart.lineNumber, selectionStart.column, position.lineNumber, position.column);
-	}
-
 	public modelPositionIsVisible(modelPosition: Position): boolean {
 		return this._lines.modelPositionIsVisible(modelPosition.lineNumber, modelPosition.column);
 	}
@@ -790,7 +777,7 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
 
 class VisibleIdentitySplitLine implements ISplitLine {
 
-	public static INSTANCE = new VisibleIdentitySplitLine();
+	public static readonly INSTANCE = new VisibleIdentitySplitLine();
 
 	private constructor() { }
 
@@ -855,7 +842,7 @@ class VisibleIdentitySplitLine implements ISplitLine {
 
 class InvisibleIdentitySplitLine implements ISplitLine {
 
-	public static INSTANCE = new InvisibleIdentitySplitLine();
+	public static readonly INSTANCE = new InvisibleIdentitySplitLine();
 
 	private constructor() { }
 
@@ -1097,12 +1084,6 @@ export class IdentityCoordinatesConverter implements ICoordinatesConverter {
 		return this._lines.model.validateRange(range);
 	}
 
-	private _validSelection(selection: Selection): Selection {
-		let selectionStart = this._validPosition(new Position(selection.selectionStartLineNumber, selection.selectionStartColumn));
-		let position = this._validPosition(new Position(selection.positionLineNumber, selection.positionColumn));
-		return new Selection(selectionStart.lineNumber, selectionStart.column, position.lineNumber, position.column);
-	}
-
 	// View -> Model conversion and related methods
 
 	public convertViewPositionToModelPosition(viewPosition: Position): Position {
@@ -1113,10 +1094,6 @@ export class IdentityCoordinatesConverter implements ICoordinatesConverter {
 		return this._validRange(viewRange);
 	}
 
-	public convertViewSelectionToModelSelection(viewSelection: Selection): Selection {
-		return this._validSelection(viewSelection);
-	}
-
 	public validateViewPosition(viewPosition: Position, expectedModelPosition: Position): Position {
 		return this._validPosition(expectedModelPosition);
 	}
@@ -1135,10 +1112,6 @@ export class IdentityCoordinatesConverter implements ICoordinatesConverter {
 		return this._validRange(modelRange);
 	}
 
-	public convertModelSelectionToViewSelection(modelSelection: Selection): Selection {
-		return this._validSelection(modelSelection);
-	}
-
 	public modelPositionIsVisible(modelPosition: Position): boolean {
 		const lineCount = this._lines.model.getLineCount();
 		if (modelPosition.lineNumber < 1 || modelPosition.lineNumber > lineCount) {

src/vs/editor/common/viewModel/viewModel.ts

@@ -8,7 +8,6 @@ import { INewScrollPosition, EndOfLinePreference, IViewState, IModelDecorationOp
 import { ViewLineToken } from 'vs/editor/common/core/viewLineToken';
 import { Position, IPosition } from 'vs/editor/common/core/position';
 import { Range } from 'vs/editor/common/core/range';
-import { Selection } from 'vs/editor/common/core/selection';
 import { ViewEvent, IViewEventListener } from 'vs/editor/common/view/viewEvents';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { Scrollable, IScrollPosition } from 'vs/base/common/scrollable';
@@ -101,14 +100,12 @@ export interface ICoordinatesConverter {
 	// View -> Model conversion and related methods
 	convertViewPositionToModelPosition(viewPosition: Position): Position;
 	convertViewRangeToModelRange(viewRange: Range): Range;
-	convertViewSelectionToModelSelection(viewSelection: Selection): Selection;
 	validateViewPosition(viewPosition: Position, expectedModelPosition: Position): Position;
 	validateViewRange(viewRange: Range, expectedModelRange: Range): Range;
 
 	// Model -> View conversion and related methods
 	convertModelPositionToViewPosition(modelPosition: Position): Position;
 	convertModelRangeToViewRange(modelRange: Range): Range;
-	convertModelSelectionToViewSelection(modelSelection: Selection): Selection;
 	modelPositionIsVisible(modelPosition: Position): boolean;
 }
 
@@ -252,17 +249,18 @@ export class ViewLineRenderingData {
 	}
 }
 
+export const enum InlineDecorationType {
+	Regular = 0,
+	Before = 1,
+	After = 2
+}
+
 export class InlineDecoration {
-	_inlineDecorationBrand: void;
-
-	readonly range: Range;
-	readonly inlineClassName: string;
-	readonly insertsBeforeOrAfter: boolean;
-
-	constructor(range: Range, inlineClassName: string, insertsBeforeOrAfter: boolean) {
-		this.range = range;
-		this.inlineClassName = inlineClassName;
-		this.insertsBeforeOrAfter = insertsBeforeOrAfter;
+	constructor(
+		public readonly range: Range,
+		public readonly inlineClassName: string,
+		public readonly type: InlineDecorationType
+	) {
 	}
 }
 

src/vs/editor/common/viewModel/viewModelDecorations.ts

@@ -8,7 +8,7 @@ import { IDisposable } from 'vs/base/common/lifecycle';
 import { Range } from 'vs/editor/common/core/range';
 import { Position } from 'vs/editor/common/core/position';
 import * as editorCommon from 'vs/editor/common/editorCommon';
-import { InlineDecoration, ViewModelDecoration, ICoordinatesConverter } from 'vs/editor/common/viewModel/viewModel';
+import { InlineDecoration, ViewModelDecoration, ICoordinatesConverter, InlineDecorationType } from 'vs/editor/common/viewModel/viewModel';
 import { IViewModelLinesCollection } from 'vs/editor/common/viewModel/splitLinesCollection';
 
 export interface IDecorationsViewportData {
@@ -123,7 +123,7 @@ export class ViewModelDecorations implements IDisposable {
 			decorationsInViewport[decorationsInViewportLen++] = viewModelDecoration;
 
 			if (decorationOptions.inlineClassName) {
-				let inlineDecoration = new InlineDecoration(viewRange, decorationOptions.inlineClassName, false);
+				let inlineDecoration = new InlineDecoration(viewRange, decorationOptions.inlineClassName, InlineDecorationType.Regular);
 				let intersectedStartLineNumber = Math.max(startLineNumber, viewRange.startLineNumber);
 				let intersectedEndLineNumber = Math.min(endLineNumber, viewRange.endLineNumber);
 				for (let j = intersectedStartLineNumber; j <= intersectedEndLineNumber; j++) {
@@ -132,21 +132,20 @@ export class ViewModelDecorations implements IDisposable {
 			}
 			if (decorationOptions.beforeContentClassName) {
 				if (startLineNumber <= viewRange.startLineNumber && viewRange.startLineNumber <= endLineNumber) {
-					// TODO: What happens if the startLineNumber and startColumn is at the end of a line?
 					let inlineDecoration = new InlineDecoration(
-						new Range(viewRange.startLineNumber, viewRange.startColumn, viewRange.startLineNumber, viewRange.startColumn + 1),
+						new Range(viewRange.startLineNumber, viewRange.startColumn, viewRange.startLineNumber, viewRange.startColumn),
 						decorationOptions.beforeContentClassName,
-						true
+						InlineDecorationType.Before
 					);
 					inlineDecorations[viewRange.startLineNumber - startLineNumber].push(inlineDecoration);
 				}
 			}
 			if (decorationOptions.afterContentClassName) {
-				if (startLineNumber <= viewRange.endLineNumber && viewRange.endLineNumber <= endLineNumber && viewRange.endColumn > 1) {
+				if (startLineNumber <= viewRange.endLineNumber && viewRange.endLineNumber <= endLineNumber) {
 					let inlineDecoration = new InlineDecoration(
-						new Range(viewRange.endLineNumber, viewRange.endColumn - 1, viewRange.endLineNumber, viewRange.endColumn),
+						new Range(viewRange.endLineNumber, viewRange.endColumn, viewRange.endLineNumber, viewRange.endColumn),
 						decorationOptions.afterContentClassName,
-						true
+						InlineDecorationType.After
 					);
 					inlineDecorations[viewRange.endLineNumber - startLineNumber].push(inlineDecoration);
 				}

src/vs/editor/common/viewModel/viewModelImpl.ts

@@ -4,7 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 'use strict';
 
-import { EmitterEvent } from 'vs/base/common/eventEmitter';
 import * as strings from 'vs/base/common/strings';
 import { Position, IPosition } from 'vs/editor/common/core/position';
 import { Range } from 'vs/editor/common/core/range';
@@ -38,7 +37,6 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 
 	private readonly decorations: ViewModelDecorations;
 
-	private _isDisposing: boolean;
 	private _centeredViewLine: number;
 
 	constructor(editorId: number, configuration: editorCommon.IConfiguration, model: editorCommon.IModel, scheduleAtNextAnimationFrame: (callback: () => void) => IDisposable) {
@@ -79,21 +77,11 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 			this._emit([new viewEvents.ViewScrollChangedEvent(e)]);
 		}));
 
-		this._isDisposing = false;
 		this._centeredViewLine = -1;
 
 		this.decorations = new ViewModelDecorations(this.editorId, this.model, this.configuration, this.lines, this.coordinatesConverter);
 
-		this._register(this.model.addBulkListener((events: EmitterEvent[]) => {
-			if (this._isDisposing) {
-				// Disposing the lines might end up sending model decoration changed events
-				// ...we no longer care about them...
-				return;
-			}
-			let eventsCollector = new ViewEventsCollector();
-			this._onModelEvents(eventsCollector, events);
-			this._emit(eventsCollector.finalize());
-		}));
+		this._registerModelEvents();
 
 		this._register(this.configuration.onDidChange((e) => {
 			const eventsCollector = new ViewEventsCollector();
@@ -107,10 +95,11 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 	}
 
 	public dispose(): void {
-		this._isDisposing = true;
+		// First remove listeners, as disposing the lines might end up sending
+		// model decoration changed events ... and we no longer care about them ...
+		super.dispose();
 		this.decorations.dispose();
 		this.lines.dispose();
-		super.dispose();
 	}
 
 	private _onConfigurationChanged(eventsCollector: ViewEventsCollector, e: IConfigurationChangedEvent): void {
@@ -157,152 +146,119 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
 		}
 	}
 
-	private _onModelEvents(eventsCollector: ViewEventsCollector, events: EmitterEvent[]): void {
+	private _registerModelEvents(): void {
 
-		// A quick check if there are model content change events incoming
-		// in order to update the configuration and reset the centered view line
-		for (let i = 0, len = events.length; i < len; i++) {
-			const eventType = events[i].type;
-			if (eventType === textModelEvents.TextModelEventType.ModelRawContentChanged2) {
-				// There is a content change event
-				this._centeredViewLine = -1;
-				this.configuration.setMaxLineNumber(this.model.getLineCount());
+		this._register(this.model.onDidChangeRawContent((e) => {
+			const eventsCollector = new ViewEventsCollector();
 
-				break;
-			}
-		}
+			// Update the configuration and reset the centered view line
+			this._centeredViewLine = -1;
+			this.configuration.setMaxLineNumber(this.model.getLineCount());
 
-		let hadOtherModelChange = false;
-		let hadModelLineChangeThatChangedLineMapping = false;
+			let hadOtherModelChange = false;
+			let hadModelLineChangeThatChangedLineMapping = false;
 
-		for (let i = 0, len = events.length; i < len; i++) {
-			const _e = events[i];
-			const type = _e.type;
-			const data = _e.data;
+			const changes = e.changes;
+			const versionId = e.versionId;
 
-			switch (type) {
+			for (let j = 0, lenJ = changes.length; j < lenJ; j++) {
+				const change = changes[j];
 
-				case textModelEvents.TextModelEventType.ModelRawContentChanged2: {
-					const e = <textModelEvents.ModelRawContentChangedEvent>data;
-					const changes = e.changes;
-					const versionId = e.versionId;
-
-					for (let j = 0, lenJ = changes.length; j < lenJ; j++) {
-						const change = changes[j];
-
-						switch (change.changeType) {
-							case textModelEvents.RawContentChangedType.Flush: {
-								this.lines.onModelFlushed();
-								eventsCollector.emit(new viewEvents.ViewFlushedEvent());
-								this.decorations.reset();
-								this.viewLayout.onFlushed(this.getLineCount());
-								hadOtherModelChange = true;
-								break;
-							}
-							case textModelEvents.RawContentChangedType.LinesDeleted: {
-								const linesDeletedEvent = this.lines.onModelLinesDeleted(versionId, change.fromLineNumber, change.toLineNumber);
-								if (linesDeletedEvent !== null) {
-									eventsCollector.emit(linesDeletedEvent);
-									this.viewLayout.onLinesDeleted(linesDeletedEvent.fromLineNumber, linesDeletedEvent.toLineNumber);
-								}
-								hadOtherModelChange = true;
-								break;
-							}
-							case textModelEvents.RawContentChangedType.LinesInserted: {
-								const linesInsertedEvent = this.lines.onModelLinesInserted(versionId, change.fromLineNumber, change.toLineNumber, change.detail.split('\n'));
-								if (linesInsertedEvent !== null) {
-									eventsCollector.emit(linesInsertedEvent);
-									this.viewLayout.onLinesInserted(linesInsertedEvent.fromLineNumber, linesInsertedEvent.toLineNumber);
-								}
-								hadOtherModelChange = true;
-								break;
-							}
-							case textModelEvents.RawContentChangedType.LineChanged: {
-								const [lineMappingChanged, linesChangedEvent, linesInsertedEvent, linesDeletedEvent] = this.lines.onModelLineChanged(versionId, change.lineNumber, change.detail);
-								hadModelLineChangeThatChangedLineMapping = lineMappingChanged;
-								if (linesChangedEvent) {
-									eventsCollector.emit(linesChangedEvent);
-								}
-								if (linesInsertedEvent) {
-									eventsCollector.emit(linesInsertedEvent);
-									this.viewLayout.onLinesInserted(linesInsertedEvent.fromLineNumber, linesInsertedEvent.toLineNumber);
-								}
-								if (linesDeletedEvent) {
-									eventsCollector.emit(linesDeletedEvent);
-									this.viewLayout.onLinesDeleted(linesDeletedEvent.fromLineNumber, linesDeletedEvent.toLineNumber);
-								}
-								break;
-							}
-							case textModelEvents.RawContentChangedType.EOLChanged: {
-								// Nothing to do. The new version will be accepted below
-								break;
-							}
-						}
-					}
-					this.lines.acceptVersionId(versionId);
-
-					break;
-				}
-				case textModelEvents.TextModelEventType.ModelTokensChanged: {
-					const e = <textModelEvents.IModelTokensChangedEvent>data;
-
-					let viewRanges: { fromLineNumber: number; toLineNumber: number; }[] = [];
-					for (let j = 0, lenJ = e.ranges.length; j < lenJ; j++) {
-						const modelRange = e.ranges[j];
-						const viewStartLineNumber = this.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelRange.fromLineNumber, 1)).lineNumber;
-						const viewEndLineNumber = this.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelRange.toLineNumber, this.model.getLineMaxColumn(modelRange.toLineNumber))).lineNumber;
-						viewRanges[j] = {
-							fromLineNumber: viewStartLineNumber,
-							toLineNumber: viewEndLineNumber
-						};
-					}
-					eventsCollector.emit(new viewEvents.ViewTokensChangedEvent(viewRanges));
-					break;
-				}
-				case textModelEvents.TextModelEventType.ModelLanguageChanged: {
-					// That's ok, a model tokens changed event will follow shortly
-					break;
-				}
-				case textModelEvents.TextModelEventType.ModelLanguageConfigurationChanged: {
-					eventsCollector.emit(new viewEvents.ViewLanguageConfigurationEvent());
-					break;
-				}
-				case textModelEvents.TextModelEventType.ModelContentChanged: {
-					// Ignore
-					break;
-				}
-				case textModelEvents.TextModelEventType.ModelOptionsChanged: {
-					// A tab size change causes a line mapping changed event => all view parts will repaint OK, no further event needed here
-					if (this.lines.setTabSize(this.model.getOptions().tabSize)) {
+				switch (change.changeType) {
+					case textModelEvents.RawContentChangedType.Flush: {
+						this.lines.onModelFlushed();
 						eventsCollector.emit(new viewEvents.ViewFlushedEvent());
-						eventsCollector.emit(new viewEvents.ViewLineMappingChangedEvent());
-						eventsCollector.emit(new viewEvents.ViewDecorationsChangedEvent());
-						this.decorations.onLineMappingChanged();
+						this.decorations.reset();
 						this.viewLayout.onFlushed(this.getLineCount());
+						hadOtherModelChange = true;
+						break;
+					}
+					case textModelEvents.RawContentChangedType.LinesDeleted: {
+						const linesDeletedEvent = this.lines.onModelLinesDeleted(versionId, change.fromLineNumber, change.toLineNumber);
+						if (linesDeletedEvent !== null) {
+							eventsCollector.emit(linesDeletedEvent);
+							this.viewLayout.onLinesDeleted(linesDeletedEvent.fromLineNumber, linesDeletedEvent.toLineNumber);
+						}
+						hadOtherModelChange = true;
+						break;
+					}
+					case textModelEvents.RawContentChangedType.LinesInserted: {
+						const linesInsertedEvent = this.lines.onModelLinesInserted(versionId, change.fromLineNumber, change.toLineNumber, change.detail.split('\n'));
+						if (linesInsertedEvent !== null) {
+							eventsCollector.emit(linesInsertedEvent);
+							this.viewLayout.onLinesInserted(linesInsertedEvent.fromLineNumber, linesInsertedEvent.toLineNumber);
+						}
+						hadOtherModelChange = true;
+						break;
+					}
+					case textModelEvents.RawContentChangedType.LineChanged: {
+						const [lineMappingChanged, linesChangedEvent, linesInsertedEvent, linesDeletedEvent] = this.lines.onModelLineChanged(versionId, change.lineNumber, change.detail);
+						hadModelLineChangeThatChangedLineMapping = lineMappingChanged;
+						if (linesChangedEvent) {
+							eventsCollector.emit(linesChangedEvent);
+						}
+						if (linesInsertedEvent) {
+							eventsCollector.emit(linesInsertedEvent);
+							this.viewLayout.onLinesInserted(linesInsertedEvent.fromLineNumber, linesInsertedEvent.toLineNumber);
+						}
+						if (linesDeletedEvent) {
+							eventsCollector.emit(linesDeletedEvent);
+							this.viewLayout.onLinesDeleted(linesDeletedEvent.fromLineNumber, linesDeletedEvent.toLineNumber);
+						}
+						break;
+					}
+					case textModelEvents.RawContentChangedType.EOLChanged: {
+						// Nothing to do. The new version will be accepted below
+						break;
 					}
-
-					break;
 				}
-				case textModelEvents.TextModelEventType.ModelDecorationsChanged: {
-					this.decorations.onModelDecorationsChanged();
-					eventsCollector.emit(new viewEvents.ViewDecorationsChangedEvent());
-					break;
-				}
-				case textModelEvents.TextModelEventType.ModelDispose: {
-					// Ignore, since the editor will take care of this and destroy the view shortly
-					break;
-				}
-				default:
-					console.info('View received unknown event: ');
-					console.info(type, data);
 			}
-		}
+			this.lines.acceptVersionId(versionId);
 
-		if (!hadOtherModelChange && hadModelLineChangeThatChangedLineMapping) {
-			eventsCollector.emit(new viewEvents.ViewLineMappingChangedEvent());
-			eventsCollector.emit(new viewEvents.ViewDecorationsChangedEvent());
-			this.decorations.onLineMappingChanged();
-		}
+			if (!hadOtherModelChange && hadModelLineChangeThatChangedLineMapping) {
+				eventsCollector.emit(new viewEvents.ViewLineMappingChangedEvent());
+				eventsCollector.emit(new viewEvents.ViewDecorationsChangedEvent());
+				this.decorations.onLineMappingChanged();
+			}
+
+			this._emit(eventsCollector.finalize());
+		}));
+
+		this._register(this.model.onDidChangeTokens((e) => {
+			let viewRanges: { fromLineNumber: number; toLineNumber: number; }[] = [];
+			for (let j = 0, lenJ = e.ranges.length; j < lenJ; j++) {
+				const modelRange = e.ranges[j];
+				const viewStartLineNumber = this.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelRange.fromLineNumber, 1)).lineNumber;
+				const viewEndLineNumber = this.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelRange.toLineNumber, this.model.getLineMaxColumn(modelRange.toLineNumber))).lineNumber;
+				viewRanges[j] = {
+					fromLineNumber: viewStartLineNumber,
+					toLineNumber: viewEndLineNumber
+				};
+			}
+			this._emit([new viewEvents.ViewTokensChangedEvent(viewRanges)]);
+		}));
+
+		this._register(this.model.onDidChangeLanguageConfiguration((e) => {
+			this._emit([new viewEvents.ViewLanguageConfigurationEvent()]);
+		}));
+
+		this._register(this.model.onDidChangeOptions((e) => {
+			// A tab size change causes a line mapping changed event => all view parts will repaint OK, no further event needed here
+			if (this.lines.setTabSize(this.model.getOptions().tabSize)) {
+				this.decorations.onLineMappingChanged();
+				this.viewLayout.onFlushed(this.getLineCount());
+				this._emit([
+					new viewEvents.ViewFlushedEvent(),
+					new viewEvents.ViewLineMappingChangedEvent(),
+					new viewEvents.ViewDecorationsChangedEvent(),
+				]);
+			}
+		}));
+
+		this._register(this.model.onDidChangeDecorations((e) => {
+			this.decorations.onModelDecorationsChanged();
+			this._emit([new viewEvents.ViewDecorationsChangedEvent()]);
+		}));
 	}
 
 	public setHiddenAreas(ranges: Range[]): void {