var -> let, format

src/vs/base/browser/ui/scrollbar/common.ts

@@ -8,33 +8,33 @@ import {IScrollable} from 'vs/base/common/scrollable';
 
 export interface IMouseWheelEvent {
 	browserEvent: MouseWheelEvent;
-	deltaX:number;
-	deltaY:number;
+	deltaX: number;
+	deltaY: number;
 	preventDefault(): void;
 	stopPropagation(): void;
 }
 
 export interface IDimensions {
-	width:number;
-	height:number;
+	width: number;
+	height: number;
 }
 
 export interface IScrollbar {
-	domNode:HTMLElement;
+	domNode: HTMLElement;
 	destroy(): void;
-	slider:HTMLElement;
-	onElementSize(size:number): void;
-	onElementScrollSize(scrollSize:number): void;
-	onElementScrollPosition(scrollPosition:number): void;
+	slider: HTMLElement;
+	onElementSize(size: number): void;
+	onElementScrollSize(scrollSize: number): void;
+	onElementScrollPosition(scrollPosition: number): void;
 	beginReveal(): void;
 	beginHide(): void;
-	delegateMouseDown(browserEvent:MouseEvent): void;
-	validateScrollPosition(scrollPosition:number): number;
-	setDesiredScrollPosition(scrollPosition:number): void;
+	delegateMouseDown(browserEvent: MouseEvent): void;
+	validateScrollPosition(scrollPosition: number): number;
+	setDesiredScrollPosition(scrollPosition: number): void;
 }
 
 export interface IParent {
-	onMouseWheel(mouseWheelEvent:IMouseWheelEvent): void;
+	onMouseWheel(mouseWheelEvent: IMouseWheelEvent): void;
 	onDragStart(): void;
 	onDragEnd(): void;
 }
@@ -45,7 +45,7 @@ export enum Visibility {
 	Visible
 };
 
-export function visibilityFromString(visibility:string): Visibility {
+export function visibilityFromString(visibility: string): Visibility {
 	switch (visibility) {
 		case 'hidden':
 			return Visibility.Hidden;
@@ -65,17 +65,17 @@ export interface IOptions {
 	/**
 	 * CSS Class name for the scrollable element
 	 */
-	className:string;
+	className: string;
 
 	/**
 	 * Drop subtle horizontal and vertical shadows.
 	 */
-	useShadows:boolean;
+	useShadows: boolean;
 
 	/**
 	 * Handle mouse wheel (listen to mouse wheel scrolling).
 	 */
-	handleMouseWheel:boolean;
+	handleMouseWheel: boolean;
 
 	/**
 	 * Flip axes. Treat vertical scrolling like horizontal and vice-versa.
@@ -91,52 +91,52 @@ export interface IOptions {
 	/**
 	 * Height for vertical arrows (top/bottom) and width for horizontal arrows (left/right).
 	 */
-	arrowSize:number;
+	arrowSize: number;
 
 	/**
 	 * The scrollable that will react to all the scrolling logic.
 	 */
-	scrollable:IScrollable;
+	scrollable: IScrollable;
 
 	/**
 	 * The dom node events should be bound to.
 	 */
-	listenOnDomNode:HTMLElement;
+	listenOnDomNode: HTMLElement;
 
 	/**
 	 * Visibility of the horizontal scrollbar.
 	 */
-	horizontal:Visibility;
+	horizontal: Visibility;
 
 	/**
 	 * Height (in px) of the horizontal scrollbar.
 	 */
-	horizontalScrollbarSize:number;
+	horizontalScrollbarSize: number;
 
 	/**
 	 * Height (in px) of the horizontal scrollbar slider.
 	 */
-	horizontalSliderSize:number;
+	horizontalSliderSize: number;
 
 	/**
 	 * Render arrows (left/right) for the horizontal scrollbar.
 	 */
-	horizontalHasArrows:boolean;
+	horizontalHasArrows: boolean;
 
 	/**
 	 * Visibility of the vertical scrollbar.
 	 */
-	vertical:Visibility;
+	vertical: Visibility;
 
 	/**
 	 * Width (in px) of the vertical scrollbar.
 	 */
-	verticalScrollbarSize:number;
+	verticalScrollbarSize: number;
 
 	/**
 	 * Width (in px) of the vertical scrollbar slider.
 	 */
-	verticalSliderSize:number;
+	verticalSliderSize: number;
 
 	/**
 	 * Render arrows (top/bottom) for the vertical scrollbar.

src/vs/base/browser/ui/scrollbar/domNodeScrollable.ts

@@ -16,7 +16,7 @@ export class DomNodeScrollable implements IScrollable {
 	private domNode: HTMLElement;
 	private gestureHandler: Gesture;
 
-	constructor(domNode:HTMLElement) {
+	constructor(domNode: HTMLElement) {
 		this.eventEmitterHelper = new EventEmitter();
 		this.domNode = domNode;
 		this.gestureHandler = new Gesture(this.domNode);
@@ -34,7 +34,7 @@ export class DomNodeScrollable implements IScrollable {
 		return this.domNode.scrollLeft;
 	}
 
-	public setScrollLeft(scrollLeft:number): void {
+	public setScrollLeft(scrollLeft: number): void {
 		this.domNode.scrollLeft = scrollLeft;
 	}
 
@@ -42,13 +42,13 @@ export class DomNodeScrollable implements IScrollable {
 		return this.domNode.scrollTop;
 	}
 
-	public setScrollTop(scrollTop:number): void {
+	public setScrollTop(scrollTop: number): void {
 		this.domNode.scrollTop = scrollTop;
 	}
 
-	public addScrollListener(callback:()=>void): IDisposable {
-		var localDisposable = this.eventEmitterHelper.addListener2('scroll', callback);
-		var domDisposable = DomUtils.addDisposableListener(this.domNode, 'scroll', (e:Event) => {
+	public addScrollListener(callback: () => void): IDisposable {
+		let localDisposable = this.eventEmitterHelper.addListener2('scroll', callback);
+		let domDisposable = DomUtils.addDisposableListener(this.domNode, 'scroll', (e: Event) => {
 			this.eventEmitterHelper.emit('scroll', { browserEvent: e });
 		});
 

src/vs/base/browser/ui/scrollbar/horizontalScrollbar.ts

@@ -13,10 +13,10 @@ import {IScrollable} from 'vs/base/common/scrollable';
 
 export class HorizontalScrollbar extends AbstractScrollbar {
 
-	private scrollable:IScrollable;
+	private scrollable: IScrollable;
 
-	constructor(scrollable:IScrollable, parent:IParent, options:IOptions) {
-		var s = new ScrollbarState(
+	constructor(scrollable: IScrollable, parent: IParent, options: IOptions) {
+		let s = new ScrollbarState(
 			(options.horizontalHasArrows ? options.arrowSize : 0),
 			(options.horizontal === Visibility.Hidden ? 0 : options.horizontalScrollbarSize),
 			(options.vertical === Visibility.Hidden ? 0 : options.verticalScrollbarSize)
@@ -26,8 +26,8 @@ export class HorizontalScrollbar extends AbstractScrollbar {
 
 		this._createDomNode();
 		if (options.horizontalHasArrows) {
-			var arrowDelta = (options.arrowSize - AbstractScrollbar.ARROW_IMG_SIZE) / 2;
-			var scrollbarDelta = (options.horizontalScrollbarSize - AbstractScrollbar.ARROW_IMG_SIZE) / 2;
+			let arrowDelta = (options.arrowSize - AbstractScrollbar.ARROW_IMG_SIZE) / 2;
+			let scrollbarDelta = (options.horizontalScrollbarSize - AbstractScrollbar.ARROW_IMG_SIZE) / 2;
 
 			this._createArrow('left-arrow', scrollbarDelta, arrowDelta, null, null, options.arrowSize, options.horizontalScrollbarSize, () => this._createMouseWheelEvent(1));
 			this._createArrow('right-arrow', scrollbarDelta, null, null, arrowDelta, options.arrowSize, options.horizontalScrollbarSize, () => this._createMouseWheelEvent(-1));
@@ -36,11 +36,11 @@ export class HorizontalScrollbar extends AbstractScrollbar {
 		this._createSlider(Math.floor((options.horizontalScrollbarSize - options.horizontalSliderSize) / 2), 0, null, options.horizontalSliderSize);
 	}
 
-	public _createMouseWheelEvent(sign:number) {
+	public _createMouseWheelEvent(sign: number) {
 		return new StandardMouseWheelEvent(null, sign, 0);
 	}
 
-	public _updateSlider(sliderSize:number, sliderPosition:number): void {
+	public _updateSlider(sliderSize: number, sliderPosition: number): void {
 		DomUtils.StyleMutator.setWidth(this.slider, sliderSize);
 		if (!this.forbidTranslate3dUse && Browser.canUseTranslate3d) {
 			DomUtils.StyleMutator.setTransform(this.slider, 'translate3d(' + sliderPosition + 'px, 0px, 0px)');
@@ -49,22 +49,22 @@ export class HorizontalScrollbar extends AbstractScrollbar {
 		}
 	}
 
-	public _renderDomNode(largeSize:number, smallSize:number): void {
+	public _renderDomNode(largeSize: number, smallSize: number): void {
 		DomUtils.StyleMutator.setWidth(this.domNode, largeSize);
 		DomUtils.StyleMutator.setHeight(this.domNode, smallSize);
 		DomUtils.StyleMutator.setLeft(this.domNode, 0);
 		DomUtils.StyleMutator.setBottom(this.domNode, 0);
 	}
 
-	public _mouseDownRelativePosition(e:StandardMouseEvent, domNodePosition:DomUtils.IDomNodePosition): number {
+	public _mouseDownRelativePosition(e: StandardMouseEvent, domNodePosition: DomUtils.IDomNodePosition): number {
 		return e.posx - domNodePosition.left;
 	}
 
-	public _sliderMousePosition(e:IMouseMoveEventData): number {
+	public _sliderMousePosition(e: IMouseMoveEventData): number {
 		return e.posx;
 	}
 
-	public _sliderOrthogonalMousePosition(e:IMouseMoveEventData): number {
+	public _sliderOrthogonalMousePosition(e: IMouseMoveEventData): number {
 		return e.posy;
 	}
 
@@ -72,7 +72,7 @@ export class HorizontalScrollbar extends AbstractScrollbar {
 		return this.scrollable.getScrollLeft();
 	}
 
-	public _setScrollPosition(scrollPosition:number) {
+	public _setScrollPosition(scrollPosition: number) {
 		this.scrollable.setScrollLeft(scrollPosition);
 	}
 }

src/vs/base/browser/ui/scrollbar/scrollableElement.ts

@@ -15,19 +15,19 @@ export interface ICreationOptions {
 	/**
 	 * CSS Class name for the scrollable element.
 	 */
-	className?:string;
+	className?: string;
 
 	/**
 	 * Drop subtle horizontal and vertical shadows.
 	 * Defaults to false.
 	 */
-	useShadows?:boolean;
+	useShadows?: boolean;
 
 	/**
 	 * Handle mouse wheel (listen to mouse wheel scrolling).
 	 * Defaults to true
 	 */
-	handleMouseWheel?:boolean;
+	handleMouseWheel?: boolean;
 
 	/**
 	 * Flip axes. Treat vertical scrolling like horizontal and vice-versa.
@@ -45,63 +45,63 @@ export interface ICreationOptions {
 	 * Height for vertical arrows (top/bottom) and width for horizontal arrows (left/right).
 	 * Defaults to 11.
 	 */
-	arrowSize?:number;
+	arrowSize?: number;
 
 	/**
 	 * The scrollable that will react to all the scrolling logic.
 	 * If no scrollable is provided, a dom node scrollable will be created automatically.
 	 */
-	scrollable?:IScrollable;
+	scrollable?: IScrollable;
 
 	/**
 	 * The dom node events should be bound to.
 	 * If no listenOnDomNode is provided, the dom node passed to the constructor will be used for event listening.
 	 */
-	listenOnDomNode?:HTMLElement;
+	listenOnDomNode?: HTMLElement;
 
 	/**
 	 * Control the visibility of the horizontal scrollbar.
 	 * Accepted values: 'auto' (on mouse over), 'visible' (always visible), 'hidden' (never visible)
 	 * Defaults to 'auto'.
 	 */
-	horizontal?:string;
+	horizontal?: string;
 
 	/**
 	 * Height (in px) of the horizontal scrollbar.
 	 * Defaults to 10.
 	 */
-	horizontalScrollbarSize?:number;
+	horizontalScrollbarSize?: number;
 
 	/**
 	 * Height (in px) of the horizontal scrollbar slider.
 	 * Defaults to `horizontalScrollbarSize`
 	 */
-	horizontalSliderSize?:number;
+	horizontalSliderSize?: number;
 
 	/**
 	 * Render arrows (left/right) for the horizontal scrollbar.
 	 * Defaults to false.
 	 */
-	horizontalHasArrows?:boolean;
+	horizontalHasArrows?: boolean;
 
 	/**
 	 * Control the visibility of the vertical scrollbar.
 	 * Accepted values: 'auto' (on mouse over), 'visible' (always visible), 'hidden' (never visible)
 	 * Defaults to 'auto'.
 	 */
-	vertical?:string;
+	vertical?: string;
 
 	/**
 	 * Width (in px) of the vertical scrollbar.
 	 * Defaults to 10.
 	 */
-	verticalScrollbarSize?:number;
+	verticalScrollbarSize?: number;
 
 	/**
 	 * Width (in px) of the vertical scrollbar slider.
 	 * Defaults to `verticalScrollbarSize`
 	 */
-	verticalSliderSize?:number;
+	verticalSliderSize?: number;
 
 	/**
 	 * Render arrows (top/bottom) for the vertical scrollbar.
@@ -130,19 +130,19 @@ export interface IDimensions {
  */
 export interface IScrollableElement {
 
-	verticalScrollbarWidth:number;
+	verticalScrollbarWidth: number;
 
-	horizontalScrollbarHeight:number;
+	horizontalScrollbarHeight: number;
 
 	/**
 	 * Get the generated 'scrollable' dom node
 	 */
-	getDomNode():HTMLElement;
+	getDomNode(): HTMLElement;
 
 	/**
 	 * Let the scrollable element know that the generated dom node's width / height might have changed.
 	 */
-	onElementDimensions(dimensions?:IDimensions): void;
+	onElementDimensions(dimensions?: IDimensions): void;
 
 	/**
 	 * Let the scrollable element know that the contained dom node's width / height might have changed.
@@ -157,21 +157,21 @@ export interface IScrollableElement {
 	/**
 	 * Update the class name of the scrollable element.
 	 */
-	updateClassName(newClassName:string): void;
+	updateClassName(newClassName: string): void;
 
 	/**
 	 * Update configuration options for the scrollbar.
 	 * Really this is Editor.IEditorScrollbarOptions, but base shouldn't
 	 * depend on Editor.
 	 */
-	updateOptions(newOptions:ICreationOptions):void;
+	updateOptions(newOptions: ICreationOptions): void;
 
-	getOverviewRulerLayoutInfo():IOverviewRulerLayoutInfo;
+	getOverviewRulerLayoutInfo(): IOverviewRulerLayoutInfo;
 
 	/**
 	 * Delegate a mouse down event to the vertical scrollbar.
 	 * This is to help with clicking somewhere else and having the scrollbar react.
 	 */
-	delegateVerticalScrollbarMouseDown(browserEvent:MouseEvent): void;
+	delegateVerticalScrollbarMouseDown(browserEvent: MouseEvent): void;
 
 }
\ No newline at end of file

src/vs/base/browser/ui/scrollbar/scrollableElementImpl.ts

@@ -5,48 +5,49 @@
 'use strict';
 
 import 'vs/css!./media/scrollbars';
+
 import DomUtils = require('vs/base/browser/dom');
 import {StandardMouseWheelEvent} from 'vs/base/browser/mouseEvent';
 import Platform = require('vs/base/common/platform');
-import {IOptions,IScrollbar,IDimensions,IMouseWheelEvent,visibilityFromString} from 'vs/base/browser/ui/scrollbar/common';
+import {IOptions, IScrollbar, IDimensions, IMouseWheelEvent, visibilityFromString} from 'vs/base/browser/ui/scrollbar/common';
 import {DomNodeScrollable} from 'vs/base/browser/ui/scrollbar/domNodeScrollable';
 import {HorizontalScrollbar} from 'vs/base/browser/ui/scrollbar/horizontalScrollbar';
 import {VerticalScrollbar} from 'vs/base/browser/ui/scrollbar/verticalScrollbar';
 import ScrollableElementInt = require('vs/base/browser/ui/scrollbar/scrollableElement');
-import {IDisposable,disposeAll} from 'vs/base/common/lifecycle';
+import {IDisposable, disposeAll} from 'vs/base/common/lifecycle';
 import {IScrollable} from 'vs/base/common/scrollable';
 
-var HIDE_TIMEOUT = 500;
-var SCROLL_WHEEL_SENSITIVITY = 50;
+const HIDE_TIMEOUT = 500;
+const SCROLL_WHEEL_SENSITIVITY = 50;
 
 export class ScrollableElement implements ScrollableElementInt.IScrollableElement {
 
-	private originalElement:HTMLElement;
-	private options:IOptions;
-	private scrollable:IScrollable;
-	public verticalScrollbarWidth:number;
-	public horizontalScrollbarHeight:number;
-	private verticalScrollbar:IScrollbar;
-	private horizontalScrollbar:IScrollbar;
-	private domNode:HTMLElement;
+	private originalElement: HTMLElement;
+	private options: IOptions;
+	private scrollable: IScrollable;
+	public verticalScrollbarWidth: number;
+	public horizontalScrollbarHeight: number;
+	private verticalScrollbar: IScrollbar;
+	private horizontalScrollbar: IScrollbar;
+	private domNode: HTMLElement;
 
-	private leftShadowDomNode:HTMLElement;
-	private topShadowDomNode:HTMLElement;
-	private topLeftShadowDomNode:HTMLElement;
-	private listenOnDomNode:HTMLElement;
+	private leftShadowDomNode: HTMLElement;
+	private topShadowDomNode: HTMLElement;
+	private topLeftShadowDomNode: HTMLElement;
+	private listenOnDomNode: HTMLElement;
 
-	private toDispose:IDisposable[];
-	private _mouseWheelToDispose:IDisposable[];
+	private toDispose: IDisposable[];
+	private _mouseWheelToDispose: IDisposable[];
 
-	private onElementDimensionsTimeout:number;
-	private onElementInternalDimensionsTimeout:number;
-	private isDragging:boolean;
-	private mouseIsOver:boolean;
+	private onElementDimensionsTimeout: number;
+	private onElementInternalDimensionsTimeout: number;
+	private isDragging: boolean;
+	private mouseIsOver: boolean;
 
-	private dimensions:IDimensions;
-	private hideTimeout:number;
+	private dimensions: IDimensions;
+	private hideTimeout: number;
 
-	constructor(element:HTMLElement, options:ScrollableElementInt.ICreationOptions, dimensions:ScrollableElementInt.IDimensions = null) {
+	constructor(element: HTMLElement, options: ScrollableElementInt.ICreationOptions, dimensions: ScrollableElementInt.IDimensions = null) {
 		this.originalElement = element;
 		this.originalElement.style.overflow = 'hidden';
 		this.options = this._createOptions(options);
@@ -95,8 +96,8 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 
 		this._mouseWheelToDispose = [];
 		this._setListeningToMouseWheel(this.options.handleMouseWheel);
-		this.toDispose.push(DomUtils.addDisposableListener(this.listenOnDomNode, 'mouseover', (e:MouseEvent) => this._onMouseOver(e)));
-		this.toDispose.push(DomUtils.addDisposableNonBubblingMouseOutListener(this.listenOnDomNode, (e:MouseEvent) => this._onMouseOut(e)));
+		this.toDispose.push(DomUtils.addDisposableListener(this.listenOnDomNode, 'mouseover', (e: MouseEvent) => this._onMouseOver(e)));
+		this.toDispose.push(DomUtils.addDisposableNonBubblingMouseOutListener(this.listenOnDomNode, (e: MouseEvent) => this._onMouseOut(e)));
 
 		this.onElementDimensionsTimeout = -1;
 		this.onElementInternalDimensionsTimeout = -1;
@@ -123,26 +124,26 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 		}
 	}
 
-	public getDomNode():HTMLElement {
+	public getDomNode(): HTMLElement {
 		return this.domNode;
 	}
 
-	public getOverviewRulerLayoutInfo():ScrollableElementInt.IOverviewRulerLayoutInfo {
+	public getOverviewRulerLayoutInfo(): ScrollableElementInt.IOverviewRulerLayoutInfo {
 		return {
 			parent: this.domNode,
 			insertBefore: this.verticalScrollbar.domNode,
 		};
 	}
 
-	private getVerticalSliderDomNode():HTMLElement {
+	private getVerticalSliderDomNode(): HTMLElement {
 		return this.verticalScrollbar.slider;
 	}
 
-	public delegateVerticalScrollbarMouseDown(browserEvent:MouseEvent): void {
+	public delegateVerticalScrollbarMouseDown(browserEvent: MouseEvent): void {
 		this.verticalScrollbar.delegateMouseDown(browserEvent);
 	}
 
-	public onElementDimensions(dimensions:ScrollableElementInt.IDimensions = null, synchronous:boolean = false): void {
+	public onElementDimensions(dimensions: ScrollableElementInt.IDimensions = null, synchronous: boolean = false): void {
 		if (synchronous) {
 			this.actualElementDimensions(dimensions);
 		} else {
@@ -152,7 +153,7 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 		}
 	}
 
-	private actualElementDimensions(dimensions:ScrollableElementInt.IDimensions = null): void {
+	private actualElementDimensions(dimensions: ScrollableElementInt.IDimensions = null): void {
 		this.onElementDimensionsTimeout = -1;
 		if (!dimensions) {
 			dimensions = {
@@ -165,7 +166,7 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 		this.horizontalScrollbar.onElementSize(this.dimensions.width);
 	}
 
-	public onElementInternalDimensions(synchronous:boolean = false): void {
+	public onElementInternalDimensions(synchronous: boolean = false): void {
 		if (synchronous) {
 			this.actualElementInternalDimensions();
 		} else {
@@ -181,7 +182,7 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 		this.verticalScrollbar.onElementScrollSize(this.scrollable.getScrollHeight());
 	}
 
-	public updateClassName(newClassName:string): void {
+	public updateClassName(newClassName: string): void {
 		this.options.className = newClassName;
 		// Defaults are different on Macs
 		if (Platform.isMacintosh) {
@@ -190,18 +191,18 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 		this.domNode.className = 'monaco-scrollable-element ' + this.options.className;
 	}
 
-	public updateOptions(newOptions:ScrollableElementInt.ICreationOptions):void {
+	public updateOptions(newOptions: ScrollableElementInt.ICreationOptions): void {
 		// only support handleMouseWheel changes for now
-		var massagedOptions = this._createOptions(newOptions);
+		let massagedOptions = this._createOptions(newOptions);
 		this.options.handleMouseWheel = massagedOptions.handleMouseWheel;
 		this.options.mouseWheelScrollSensitivity = massagedOptions.mouseWheelScrollSensitivity;
 		this._setListeningToMouseWheel(this.options.handleMouseWheel);
 	}
 
-// -------------------- mouse wheel scrolling --------------------
+	// -------------------- mouse wheel scrolling --------------------
 
-	private _setListeningToMouseWheel(shouldListen:boolean): void {
-		var isListening = (this._mouseWheelToDispose.length > 0);
+	private _setListeningToMouseWheel(shouldListen: boolean): void {
+		let isListening = (this._mouseWheelToDispose.length > 0);
 
 		if (isListening === shouldListen) {
 			// No change
@@ -213,8 +214,8 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 
 		// Start listening (if necessary)
 		if (shouldListen) {
-			var onMouseWheel = (browserEvent:MouseWheelEvent) => {
-				var e = new StandardMouseWheelEvent(browserEvent);
+			let onMouseWheel = (browserEvent: MouseWheelEvent) => {
+				let e = new StandardMouseWheelEvent(browserEvent);
 				this.onMouseWheel(e);
 			};
 
@@ -226,21 +227,21 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 	public onMouseWheel(e: IMouseWheelEvent): void {
 		if (Platform.isMacintosh && e.browserEvent && this.options.saveLastScrollTimeOnClassName) {
 			// Mark dom node with timestamp of wheel event
-			var target = <HTMLElement>e.browserEvent.target;
+			let target = <HTMLElement>e.browserEvent.target;
 			if (target && target.nodeType === 1) {
-				var r = DomUtils.findParentWithClass(target, this.options.saveLastScrollTimeOnClassName);
+				let r = DomUtils.findParentWithClass(target, this.options.saveLastScrollTimeOnClassName);
 				if (r) {
 					r.setAttribute('last-scroll-time', String(new Date().getTime()));
 				}
 			}
 		}
 
-		var desiredScrollTop = -1;
-		var desiredScrollLeft = -1;
+		let desiredScrollTop = -1;
+		let desiredScrollLeft = -1;
 
 		if (e.deltaY || e.deltaX) {
-			var deltaY = e.deltaY * this.options.mouseWheelScrollSensitivity;
-			var deltaX = e.deltaX * this.options.mouseWheelScrollSensitivity;
+			let deltaY = e.deltaY * this.options.mouseWheelScrollSensitivity;
+			let deltaX = e.deltaX * this.options.mouseWheelScrollSensitivity;
 
 			if (this.options.flipAxes) {
 				deltaY = e.deltaX;
@@ -258,14 +259,14 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 			}
 
 			if (deltaY) {
-				var currentScrollTop = this.scrollable.getScrollTop();
+				let currentScrollTop = this.scrollable.getScrollTop();
 				desiredScrollTop = this.verticalScrollbar.validateScrollPosition((desiredScrollTop !== -1 ? desiredScrollTop : currentScrollTop) - SCROLL_WHEEL_SENSITIVITY * deltaY);
 				if (desiredScrollTop === currentScrollTop) {
 					desiredScrollTop = -1;
 				}
 			}
 			if (deltaX) {
-				var currentScrollLeft = this.scrollable.getScrollLeft();
+				let currentScrollLeft = this.scrollable.getScrollLeft();
 				desiredScrollLeft = this.horizontalScrollbar.validateScrollPosition((desiredScrollLeft !== -1 ? desiredScrollLeft : currentScrollLeft) - SCROLL_WHEEL_SENSITIVITY * deltaX);
 				if (desiredScrollLeft === currentScrollLeft) {
 					desiredScrollLeft = -1;
@@ -289,23 +290,23 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 	}
 
 	private _onScroll(): void {
-		var scrollHeight = this.scrollable.getScrollHeight();
-		var scrollTop = this.scrollable.getScrollTop();
-		var scrollWidth = this.scrollable.getScrollWidth();
-		var scrollLeft = this.scrollable.getScrollLeft();
+		let scrollHeight = this.scrollable.getScrollHeight();
+		let scrollTop = this.scrollable.getScrollTop();
+		let scrollWidth = this.scrollable.getScrollWidth();
+		let scrollLeft = this.scrollable.getScrollLeft();
 
 		this.verticalScrollbar.onElementScrollPosition(scrollTop);
 		this.horizontalScrollbar.onElementScrollPosition(scrollLeft);
 
 		if (this.options.useShadows) {
-			var enableTop = scrollHeight > 0 && scrollTop > 0;
-			var enableLeft = this.options.useShadows && scrollWidth > 0 && scrollLeft > 0;
+			let enableTop = scrollHeight > 0 && scrollTop > 0;
+			let enableLeft = this.options.useShadows && scrollWidth > 0 && scrollLeft > 0;
 
 			if (this.topShadowDomNode) {
 				DomUtils.toggleClass(this.topShadowDomNode, 'top', enableTop);
 			}
 
-			if(this.topLeftShadowDomNode) {
+			if (this.topLeftShadowDomNode) {
 				DomUtils.toggleClass(this.topLeftShadowDomNode, 'top', enableTop);
 			}
 
@@ -321,7 +322,7 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 		this._reveal();
 	}
 
-// -------------------- fade in / fade out --------------------
+	// -------------------- fade in / fade out --------------------
 
 	public onDragStart(): void {
 		this.isDragging = true;
@@ -333,12 +334,12 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 		this._hide();
 	}
 
-	private _onMouseOut(e:MouseEvent): void {
+	private _onMouseOut(e: MouseEvent): void {
 		this.mouseIsOver = false;
 		this._hide();
 	}
 
-	private _onMouseOver(e:MouseEvent): void {
+	private _onMouseOver(e: MouseEvent): void {
 		this.mouseIsOver = true;
 		this._reveal();
 	}
@@ -363,11 +364,11 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 		this.hideTimeout = window.setTimeout(this._hide.bind(this), HIDE_TIMEOUT);
 	}
 
-// -------------------- size & layout --------------------
+	// -------------------- size & layout --------------------
 
-	private _computeDimensions(clientWidth:number, clientHeight:number): IDimensions {
-		var width = clientWidth;
-		var height = clientHeight;
+	private _computeDimensions(clientWidth: number, clientHeight: number): IDimensions {
+		let width = clientWidth;
+		let height = clientHeight;
 
 		return {
 			width: width,
@@ -375,16 +376,16 @@ export class ScrollableElement implements ScrollableElementInt.IScrollableElemen
 		};
 	}
 
-	private _createOptions(options:ScrollableElementInt.ICreationOptions): IOptions {
+	private _createOptions(options: ScrollableElementInt.ICreationOptions): IOptions {
 
-		function ensureValue<V>(source:any, prop:string, value:V) {
+		function ensureValue<V>(source: any, prop: string, value: V) {
 			if (source.hasOwnProperty(prop)) {
 				return <V>source[prop];
 			}
 			return value;
 		}
 
-		var result:IOptions = {
+		let result: IOptions = {
 			forbidTranslate3dUse: ensureValue(options, 'forbidTranslate3dUse', false),
 			className: ensureValue(options, 'className', ''),
 			useShadows: ensureValue(options, 'useShadows', true),

src/vs/base/browser/ui/scrollbar/verticalScrollbar.ts

@@ -13,10 +13,10 @@ import {IScrollable} from 'vs/base/common/scrollable';
 
 export class VerticalScrollbar extends AbstractScrollbar {
 
-	private scrollable:IScrollable;
+	private scrollable: IScrollable;
 
-	constructor(scrollable:IScrollable, parent:IParent, options:IOptions) {
-		var s = new ScrollbarState(
+	constructor(scrollable: IScrollable, parent: IParent, options: IOptions) {
+		let s = new ScrollbarState(
 			(options.verticalHasArrows ? options.arrowSize : 0),
 			(options.vertical === Visibility.Hidden ? 0 : options.verticalScrollbarSize),
 			(options.horizontal === Visibility.Hidden ? 0 : options.horizontalScrollbarSize)
@@ -26,8 +26,8 @@ export class VerticalScrollbar extends AbstractScrollbar {
 
 		this._createDomNode();
 		if (options.verticalHasArrows) {
-			var arrowDelta = (options.arrowSize - AbstractScrollbar.ARROW_IMG_SIZE) / 2;
-			var scrollbarDelta = (options.verticalScrollbarSize - AbstractScrollbar.ARROW_IMG_SIZE) / 2;
+			let arrowDelta = (options.arrowSize - AbstractScrollbar.ARROW_IMG_SIZE) / 2;
+			let scrollbarDelta = (options.verticalScrollbarSize - AbstractScrollbar.ARROW_IMG_SIZE) / 2;
 
 			this._createArrow('up-arrow', arrowDelta, scrollbarDelta, null, null, options.verticalScrollbarSize, options.arrowSize, () => this._createMouseWheelEvent(1));
 			this._createArrow('down-arrow', null, scrollbarDelta, arrowDelta, null, options.verticalScrollbarSize, options.arrowSize, () => this._createMouseWheelEvent(-1));
@@ -36,11 +36,11 @@ export class VerticalScrollbar extends AbstractScrollbar {
 		this._createSlider(0, Math.floor((options.verticalScrollbarSize - options.verticalSliderSize) / 2), options.verticalSliderSize, null);
 	}
 
-	public _createMouseWheelEvent(sign:number) {
+	public _createMouseWheelEvent(sign: number) {
 		return new StandardMouseWheelEvent(null, 0, sign);
 	}
 
-	public _updateSlider(sliderSize:number, sliderPosition:number): void {
+	public _updateSlider(sliderSize: number, sliderPosition: number): void {
 		DomUtils.StyleMutator.setHeight(this.slider, sliderSize);
 		if (!this.forbidTranslate3dUse && Browser.canUseTranslate3d) {
 			DomUtils.StyleMutator.setTransform(this.slider, 'translate3d(0px, ' + sliderPosition + 'px, 0px)');
@@ -49,22 +49,22 @@ export class VerticalScrollbar extends AbstractScrollbar {
 		}
 	}
 
-	public _renderDomNode(largeSize:number, smallSize:number): void {
+	public _renderDomNode(largeSize: number, smallSize: number): void {
 		DomUtils.StyleMutator.setWidth(this.domNode, smallSize);
 		DomUtils.StyleMutator.setHeight(this.domNode, largeSize);
 		DomUtils.StyleMutator.setRight(this.domNode, 0);
 		DomUtils.StyleMutator.setTop(this.domNode, 0);
 	}
 
-	public _mouseDownRelativePosition(e:StandardMouseEvent, domNodePosition:DomUtils.IDomNodePosition): number {
+	public _mouseDownRelativePosition(e: StandardMouseEvent, domNodePosition: DomUtils.IDomNodePosition): number {
 		return e.posy - domNodePosition.top;
 	}
 
-	public _sliderMousePosition(e:IMouseMoveEventData): number {
+	public _sliderMousePosition(e: IMouseMoveEventData): number {
 		return e.posy;
 	}
 
-	public _sliderOrthogonalMousePosition(e:IMouseMoveEventData): number {
+	public _sliderOrthogonalMousePosition(e: IMouseMoveEventData): number {
 		return e.posx;
 	}
 
@@ -72,7 +72,7 @@ export class VerticalScrollbar extends AbstractScrollbar {
 		return this.scrollable.getScrollTop();
 	}
 
-	public _setScrollPosition(scrollPosition:number): void {
+	public _setScrollPosition(scrollPosition: number): void {
 		this.scrollable.setScrollTop(scrollPosition);
 	}
 }