monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/screenReaderSupport.js

@@ -0,0 +1,175 @@
+import { Disposable, MutableDisposable } from '../../../../../base/common/lifecycle.js';
+import { localize } from '../../../../../nls.js';
+import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.js';
+import { IKeybindingService } from '../../../../../platform/keybinding/common/keybinding.js';
+import { Selection } from '../../../../common/core/selection.js';
+import { applyFontInfo } from '../../../config/domFontInfo.js';
+import { ariaLabelForScreenReaderContent } from '../screenReaderUtils.js';
+import { RichScreenReaderContent } from './screenReaderContentRich.js';
+import { SimpleScreenReaderContent } from './screenReaderContentSimple.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+let ScreenReaderSupport = class ScreenReaderSupport extends Disposable {
+    constructor(_domNode, _context, _viewController, _keybindingService, _accessibilityService) {
+        super();
+        this._domNode = _domNode;
+        this._context = _context;
+        this._viewController = _viewController;
+        this._keybindingService = _keybindingService;
+        this._accessibilityService = _accessibilityService;
+        // Configuration values
+        this._contentLeft = 1;
+        this._contentWidth = 1;
+        this._contentHeight = 1;
+        this._divWidth = 1;
+        this._primarySelection = new Selection(1, 1, 1, 1);
+        this._primaryCursorVisibleRange = null;
+        this._state = this._register(new MutableDisposable());
+        this._instantiateScreenReaderContent();
+        this._updateConfigurationSettings();
+        this._updateDomAttributes();
+    }
+    onWillPaste() {
+        this._state.value?.onWillPaste();
+    }
+    onWillCut() {
+        this._state.value?.onWillCut();
+    }
+    handleFocusChange(newFocusValue) {
+        this._state.value?.onFocusChange(newFocusValue);
+        this.writeScreenReaderContent();
+    }
+    onConfigurationChanged(e) {
+        this._instantiateScreenReaderContent();
+        this._updateConfigurationSettings();
+        this._updateDomAttributes();
+        if (e.hasChanged(2 /* EditorOption.accessibilitySupport */)) {
+            this.writeScreenReaderContent();
+        }
+    }
+    _instantiateScreenReaderContent() {
+        const renderRichContent = this._context.configuration.options.get(107 /* EditorOption.renderRichScreenReaderContent */);
+        if (this._renderRichContent !== renderRichContent) {
+            this._renderRichContent = renderRichContent;
+            this._state.value = this._createScreenReaderContent(renderRichContent);
+        }
+    }
+    _createScreenReaderContent(renderRichContent) {
+        if (renderRichContent) {
+            return new RichScreenReaderContent(this._domNode, this._context, this._viewController, this._accessibilityService);
+        }
+        else {
+            return new SimpleScreenReaderContent(this._domNode, this._context, this._viewController, this._accessibilityService);
+        }
+    }
+    _updateConfigurationSettings() {
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        const wrappingColumn = layoutInfo.wrappingColumn;
+        this._contentLeft = layoutInfo.contentLeft;
+        this._contentWidth = layoutInfo.contentWidth;
+        this._contentHeight = layoutInfo.height;
+        this._fontInfo = options.get(59 /* EditorOption.fontInfo */);
+        this._divWidth = Math.round(wrappingColumn * this._fontInfo.typicalHalfwidthCharacterWidth);
+        this._state.value?.onConfigurationChanged(options);
+    }
+    _updateDomAttributes() {
+        const options = this._context.configuration.options;
+        this._domNode.domNode.setAttribute('role', 'textbox');
+        this._domNode.domNode.setAttribute('aria-required', options.get(9 /* EditorOption.ariaRequired */) ? 'true' : 'false');
+        this._domNode.domNode.setAttribute('aria-multiline', 'true');
+        this._domNode.domNode.setAttribute('aria-autocomplete', options.get(104 /* EditorOption.readOnly */) ? 'none' : 'both');
+        this._domNode.domNode.setAttribute('aria-roledescription', localize(60, "editor"));
+        this._domNode.domNode.setAttribute('aria-label', ariaLabelForScreenReaderContent(options, this._keybindingService));
+        const tabSize = this._context.viewModel.model.getOptions().tabSize;
+        const spaceWidth = options.get(59 /* EditorOption.fontInfo */).spaceWidth;
+        this._domNode.domNode.style.tabSize = `${tabSize * spaceWidth}px`;
+        const wordWrapOverride2 = options.get(154 /* EditorOption.wordWrapOverride2 */);
+        const wordWrapOverride1 = (wordWrapOverride2 === 'inherit' ? options.get(153 /* EditorOption.wordWrapOverride1 */) : wordWrapOverride2);
+        const wordWrap = (wordWrapOverride1 === 'inherit' ? options.get(149 /* EditorOption.wordWrap */) : wordWrapOverride1);
+        this._domNode.domNode.style.textWrap = wordWrap === 'off' ? 'nowrap' : 'wrap';
+    }
+    onCursorStateChanged(e) {
+        this._primarySelection = e.selections[0] ?? new Selection(1, 1, 1, 1);
+    }
+    prepareRender(ctx) {
+        this.writeScreenReaderContent();
+        this._primaryCursorVisibleRange = ctx.visibleRangeForPosition(this._primarySelection.getPosition());
+    }
+    render(ctx) {
+        if (!this._primaryCursorVisibleRange) {
+            // The primary cursor is outside the viewport => place textarea to the top left
+            this._renderAtTopLeft();
+            return;
+        }
+        const editorScrollLeft = this._context.viewLayout.getCurrentScrollLeft();
+        const left = this._contentLeft + this._primaryCursorVisibleRange.left - editorScrollLeft;
+        if (left < this._contentLeft || left > this._contentLeft + this._contentWidth) {
+            // cursor is outside the viewport
+            this._renderAtTopLeft();
+            return;
+        }
+        const editorScrollTop = this._context.viewLayout.getCurrentScrollTop();
+        const positionLineNumber = this._primarySelection.positionLineNumber;
+        const top = this._context.viewLayout.getVerticalOffsetForLineNumber(positionLineNumber) - editorScrollTop;
+        if (top < 0 || top > this._contentHeight) {
+            // cursor is outside the viewport
+            this._renderAtTopLeft();
+            return;
+        }
+        // The <div> where we render the screen reader content does not support variable line heights,
+        // all the lines must have the same height. We use the line height of the cursor position as the
+        // line height for all lines.
+        const lineHeight = this._context.viewLayout.getLineHeightForLineNumber(positionLineNumber);
+        this._doRender(top, this._contentLeft, this._divWidth, lineHeight);
+        this._state.value?.updateScrollTop(this._primarySelection);
+    }
+    _renderAtTopLeft() {
+        this._doRender(0, 0, this._contentWidth, 1);
+    }
+    _doRender(top, left, width, height) {
+        // For correct alignment of the screen reader content, we need to apply the correct font
+        applyFontInfo(this._domNode, this._fontInfo);
+        this._domNode.setTop(top);
+        this._domNode.setLeft(left);
+        this._domNode.setWidth(width);
+        this._domNode.setHeight(height);
+        this._domNode.setLineHeight(height);
+    }
+    setAriaOptions(options) {
+        if (options.activeDescendant) {
+            this._domNode.setAttribute('aria-haspopup', 'true');
+            this._domNode.setAttribute('aria-autocomplete', 'list');
+            this._domNode.setAttribute('aria-activedescendant', options.activeDescendant);
+        }
+        else {
+            this._domNode.setAttribute('aria-haspopup', 'false');
+            this._domNode.setAttribute('aria-autocomplete', 'both');
+            this._domNode.removeAttribute('aria-activedescendant');
+        }
+        if (options.role) {
+            this._domNode.setAttribute('role', options.role);
+        }
+    }
+    writeScreenReaderContent() {
+        this._state.value?.updateScreenReaderContent(this._primarySelection);
+    }
+};
+ScreenReaderSupport = __decorate([
+    __param(3, IKeybindingService),
+    __param(4, IAccessibilityService)
+], ScreenReaderSupport);
+
+export { ScreenReaderSupport };

package/dist/workers/screenReaderUtils.js

@@ -0,0 +1,111 @@
+import { Range } from '../../../common/core/range.js';
+import { localize } from '../../../../nls.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class SimplePagedScreenReaderStrategy {
+    _getPageOfLine(lineNumber, linesPerPage) {
+        return Math.floor((lineNumber - 1) / linesPerPage);
+    }
+    _getRangeForPage(page, linesPerPage) {
+        const offset = page * linesPerPage;
+        const startLineNumber = offset + 1;
+        const endLineNumber = offset + linesPerPage;
+        return new Range(startLineNumber, 1, endLineNumber + 1, 1);
+    }
+    fromEditorSelection(model, selection, linesPerPage, trimLongText) {
+        // Chromium handles very poorly text even of a few thousand chars
+        // Cut text to avoid stalling the entire UI
+        const LIMIT_CHARS = 500;
+        const selectionStartPage = this._getPageOfLine(selection.startLineNumber, linesPerPage);
+        const selectionStartPageRange = this._getRangeForPage(selectionStartPage, linesPerPage);
+        const selectionEndPage = this._getPageOfLine(selection.endLineNumber, linesPerPage);
+        const selectionEndPageRange = this._getRangeForPage(selectionEndPage, linesPerPage);
+        let pretextRange = selectionStartPageRange.intersectRanges(new Range(1, 1, selection.startLineNumber, selection.startColumn));
+        if (trimLongText && model.getValueLengthInRange(pretextRange, 1 /* EndOfLinePreference.LF */) > LIMIT_CHARS) {
+            const pretextStart = model.modifyPosition(pretextRange.getEndPosition(), -LIMIT_CHARS);
+            pretextRange = Range.fromPositions(pretextStart, pretextRange.getEndPosition());
+        }
+        const pretext = model.getValueInRange(pretextRange, 1 /* EndOfLinePreference.LF */);
+        const lastLine = model.getLineCount();
+        const lastLineMaxColumn = model.getLineMaxColumn(lastLine);
+        let posttextRange = selectionEndPageRange.intersectRanges(new Range(selection.endLineNumber, selection.endColumn, lastLine, lastLineMaxColumn));
+        if (trimLongText && model.getValueLengthInRange(posttextRange, 1 /* EndOfLinePreference.LF */) > LIMIT_CHARS) {
+            const posttextEnd = model.modifyPosition(posttextRange.getStartPosition(), LIMIT_CHARS);
+            posttextRange = Range.fromPositions(posttextRange.getStartPosition(), posttextEnd);
+        }
+        const posttext = model.getValueInRange(posttextRange, 1 /* EndOfLinePreference.LF */);
+        let text;
+        if (selectionStartPage === selectionEndPage || selectionStartPage + 1 === selectionEndPage) {
+            // take full selection
+            text = model.getValueInRange(selection, 1 /* EndOfLinePreference.LF */);
+        }
+        else {
+            const selectionRange1 = selectionStartPageRange.intersectRanges(selection);
+            const selectionRange2 = selectionEndPageRange.intersectRanges(selection);
+            text = (model.getValueInRange(selectionRange1, 1 /* EndOfLinePreference.LF */)
+                + String.fromCharCode(8230)
+                + model.getValueInRange(selectionRange2, 1 /* EndOfLinePreference.LF */));
+        }
+        if (trimLongText && text.length > 2 * LIMIT_CHARS) {
+            text = text.substring(0, LIMIT_CHARS) + String.fromCharCode(8230) + text.substring(text.length - LIMIT_CHARS, text.length);
+        }
+        let selectionStart;
+        let selectionEnd;
+        if (selection.getDirection() === 0 /* SelectionDirection.LTR */) {
+            selectionStart = pretext.length;
+            selectionEnd = pretext.length + text.length;
+        }
+        else {
+            selectionEnd = pretext.length;
+            selectionStart = pretext.length + text.length;
+        }
+        return {
+            value: pretext + text + posttext,
+            selection: selection,
+            selectionStart,
+            selectionEnd,
+            startPositionWithinEditor: pretextRange.getStartPosition(),
+            newlineCountBeforeSelection: pretextRange.endLineNumber - pretextRange.startLineNumber,
+        };
+    }
+}
+function ariaLabelForScreenReaderContent(options, keybindingService) {
+    const accessibilitySupport = options.get(2 /* EditorOption.accessibilitySupport */);
+    if (accessibilitySupport === 1 /* AccessibilitySupport.Disabled */) {
+        const toggleKeybindingLabel = keybindingService.lookupKeybinding('editor.action.toggleScreenReaderAccessibilityMode')?.getAriaLabel();
+        const runCommandKeybindingLabel = keybindingService.lookupKeybinding('workbench.action.showCommands')?.getAriaLabel();
+        const keybindingEditorKeybindingLabel = keybindingService.lookupKeybinding('workbench.action.openGlobalKeybindings')?.getAriaLabel();
+        const editorNotAccessibleMessage = localize(61, "The editor is not accessible at this time.");
+        if (toggleKeybindingLabel) {
+            return localize(62, "{0} To enable screen reader optimized mode, use {1}", editorNotAccessibleMessage, toggleKeybindingLabel);
+        }
+        else if (runCommandKeybindingLabel) {
+            return localize(63, "{0} To enable screen reader optimized mode, open the quick pick with {1} and run the command Toggle Screen Reader Accessibility Mode, which is currently not triggerable via keyboard.", editorNotAccessibleMessage, runCommandKeybindingLabel);
+        }
+        else if (keybindingEditorKeybindingLabel) {
+            return localize(64, "{0} Please assign a keybinding for the command Toggle Screen Reader Accessibility Mode by accessing the keybindings editor with {1} and run it.", editorNotAccessibleMessage, keybindingEditorKeybindingLabel);
+        }
+        else {
+            // SOS
+            return editorNotAccessibleMessage;
+        }
+    }
+    return options.get(8 /* EditorOption.ariaLabel */);
+}
+function newlinecount(text) {
+    let result = 0;
+    let startIndex = -1;
+    do {
+        startIndex = text.indexOf('\n', startIndex + 1);
+        if (startIndex === -1) {
+            break;
+        }
+        result++;
+    } while (true);
+    return result;
+}
+
+export { SimplePagedScreenReaderStrategy, ariaLabelForScreenReaderContent, newlinecount };

package/dist/workers/scrollDecoration.js

@@ -0,0 +1,70 @@
+import './scrollDecoration.css';
+import { createFastDomNode } from '../../../../base/browser/fastDomNode.js';
+import { ViewPart } from '../../view/viewPart.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class ScrollDecorationViewPart extends ViewPart {
+    constructor(context) {
+        super(context);
+        this._scrollTop = 0;
+        this._width = 0;
+        this._updateWidth();
+        this._shouldShow = false;
+        const options = this._context.configuration.options;
+        const scrollbar = options.get(117 /* EditorOption.scrollbar */);
+        this._useShadows = scrollbar.useShadows;
+        this._domNode = createFastDomNode(document.createElement('div'));
+        this._domNode.setAttribute('role', 'presentation');
+        this._domNode.setAttribute('aria-hidden', 'true');
+    }
+    dispose() {
+        super.dispose();
+    }
+    _updateShouldShow() {
+        const newShouldShow = (this._useShadows && this._scrollTop > 0);
+        if (this._shouldShow !== newShouldShow) {
+            this._shouldShow = newShouldShow;
+            return true;
+        }
+        return false;
+    }
+    getDomNode() {
+        return this._domNode;
+    }
+    _updateWidth() {
+        const options = this._context.configuration.options;
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        if (layoutInfo.minimap.renderMinimap === 0 || (layoutInfo.minimap.minimapWidth > 0 && layoutInfo.minimap.minimapLeft === 0)) {
+            this._width = layoutInfo.width;
+        }
+        else {
+            this._width = layoutInfo.width - layoutInfo.verticalScrollbarWidth;
+        }
+    }
+    // --- begin event handlers
+    onConfigurationChanged(e) {
+        const options = this._context.configuration.options;
+        const scrollbar = options.get(117 /* EditorOption.scrollbar */);
+        this._useShadows = scrollbar.useShadows;
+        this._updateWidth();
+        this._updateShouldShow();
+        return true;
+    }
+    onScrollChanged(e) {
+        this._scrollTop = e.scrollTop;
+        return this._updateShouldShow();
+    }
+    // --- end event handlers
+    prepareRender(ctx) {
+        // Nothing to read
+    }
+    render(ctx) {
+        this._domNode.setWidth(this._width);
+        this._domNode.setClassName(this._shouldShow ? 'scroll-decoration' : '');
+    }
+}
+
+export { ScrollDecorationViewPart };

package/dist/workers/scrollable.js

@@ -0,0 +1,323 @@
+import { Emitter } from './event.js';
+import { Disposable } from './lifecycle.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class ScrollState {
+    constructor(_forceIntegerValues, width, scrollWidth, scrollLeft, height, scrollHeight, scrollTop) {
+        this._forceIntegerValues = _forceIntegerValues;
+        this._scrollStateBrand = undefined;
+        if (this._forceIntegerValues) {
+            width = width | 0;
+            scrollWidth = scrollWidth | 0;
+            scrollLeft = scrollLeft | 0;
+            height = height | 0;
+            scrollHeight = scrollHeight | 0;
+            scrollTop = scrollTop | 0;
+        }
+        this.rawScrollLeft = scrollLeft; // before validation
+        this.rawScrollTop = scrollTop; // before validation
+        if (width < 0) {
+            width = 0;
+        }
+        if (scrollLeft + width > scrollWidth) {
+            scrollLeft = scrollWidth - width;
+        }
+        if (scrollLeft < 0) {
+            scrollLeft = 0;
+        }
+        if (height < 0) {
+            height = 0;
+        }
+        if (scrollTop + height > scrollHeight) {
+            scrollTop = scrollHeight - height;
+        }
+        if (scrollTop < 0) {
+            scrollTop = 0;
+        }
+        this.width = width;
+        this.scrollWidth = scrollWidth;
+        this.scrollLeft = scrollLeft;
+        this.height = height;
+        this.scrollHeight = scrollHeight;
+        this.scrollTop = scrollTop;
+    }
+    equals(other) {
+        return (this.rawScrollLeft === other.rawScrollLeft
+            && this.rawScrollTop === other.rawScrollTop
+            && this.width === other.width
+            && this.scrollWidth === other.scrollWidth
+            && this.scrollLeft === other.scrollLeft
+            && this.height === other.height
+            && this.scrollHeight === other.scrollHeight
+            && this.scrollTop === other.scrollTop);
+    }
+    withScrollDimensions(update, useRawScrollPositions) {
+        return new ScrollState(this._forceIntegerValues, (typeof update.width !== 'undefined' ? update.width : this.width), (typeof update.scrollWidth !== 'undefined' ? update.scrollWidth : this.scrollWidth), useRawScrollPositions ? this.rawScrollLeft : this.scrollLeft, (typeof update.height !== 'undefined' ? update.height : this.height), (typeof update.scrollHeight !== 'undefined' ? update.scrollHeight : this.scrollHeight), useRawScrollPositions ? this.rawScrollTop : this.scrollTop);
+    }
+    withScrollPosition(update) {
+        return new ScrollState(this._forceIntegerValues, this.width, this.scrollWidth, (typeof update.scrollLeft !== 'undefined' ? update.scrollLeft : this.rawScrollLeft), this.height, this.scrollHeight, (typeof update.scrollTop !== 'undefined' ? update.scrollTop : this.rawScrollTop));
+    }
+    createScrollEvent(previous, inSmoothScrolling) {
+        const widthChanged = (this.width !== previous.width);
+        const scrollWidthChanged = (this.scrollWidth !== previous.scrollWidth);
+        const scrollLeftChanged = (this.scrollLeft !== previous.scrollLeft);
+        const heightChanged = (this.height !== previous.height);
+        const scrollHeightChanged = (this.scrollHeight !== previous.scrollHeight);
+        const scrollTopChanged = (this.scrollTop !== previous.scrollTop);
+        return {
+            inSmoothScrolling: inSmoothScrolling,
+            oldWidth: previous.width,
+            oldScrollWidth: previous.scrollWidth,
+            oldScrollLeft: previous.scrollLeft,
+            width: this.width,
+            scrollWidth: this.scrollWidth,
+            scrollLeft: this.scrollLeft,
+            oldHeight: previous.height,
+            oldScrollHeight: previous.scrollHeight,
+            oldScrollTop: previous.scrollTop,
+            height: this.height,
+            scrollHeight: this.scrollHeight,
+            scrollTop: this.scrollTop,
+            widthChanged: widthChanged,
+            scrollWidthChanged: scrollWidthChanged,
+            scrollLeftChanged: scrollLeftChanged,
+            heightChanged: heightChanged,
+            scrollHeightChanged: scrollHeightChanged,
+            scrollTopChanged: scrollTopChanged,
+        };
+    }
+}
+class Scrollable extends Disposable {
+    constructor(options) {
+        super();
+        this._scrollableBrand = undefined;
+        this._onScroll = this._register(new Emitter());
+        this.onScroll = this._onScroll.event;
+        this._smoothScrollDuration = options.smoothScrollDuration;
+        this._scheduleAtNextAnimationFrame = options.scheduleAtNextAnimationFrame;
+        this._state = new ScrollState(options.forceIntegerValues, 0, 0, 0, 0, 0, 0);
+        this._smoothScrolling = null;
+    }
+    dispose() {
+        if (this._smoothScrolling) {
+            this._smoothScrolling.dispose();
+            this._smoothScrolling = null;
+        }
+        super.dispose();
+    }
+    setSmoothScrollDuration(smoothScrollDuration) {
+        this._smoothScrollDuration = smoothScrollDuration;
+    }
+    validateScrollPosition(scrollPosition) {
+        return this._state.withScrollPosition(scrollPosition);
+    }
+    getScrollDimensions() {
+        return this._state;
+    }
+    setScrollDimensions(dimensions, useRawScrollPositions) {
+        const newState = this._state.withScrollDimensions(dimensions, useRawScrollPositions);
+        this._setState(newState, Boolean(this._smoothScrolling));
+        // Validate outstanding animated scroll position target
+        this._smoothScrolling?.acceptScrollDimensions(this._state);
+    }
+    /**
+     * Returns the final scroll position that the instance will have once the smooth scroll animation concludes.
+     * If no scroll animation is occurring, it will return the current scroll position instead.
+     */
+    getFutureScrollPosition() {
+        if (this._smoothScrolling) {
+            return this._smoothScrolling.to;
+        }
+        return this._state;
+    }
+    /**
+     * Returns the current scroll position.
+     * Note: This result might be an intermediate scroll position, as there might be an ongoing smooth scroll animation.
+     */
+    getCurrentScrollPosition() {
+        return this._state;
+    }
+    setScrollPositionNow(update) {
+        // no smooth scrolling requested
+        const newState = this._state.withScrollPosition(update);
+        // Terminate any outstanding smooth scrolling
+        if (this._smoothScrolling) {
+            this._smoothScrolling.dispose();
+            this._smoothScrolling = null;
+        }
+        this._setState(newState, false);
+    }
+    setScrollPositionSmooth(update, reuseAnimation) {
+        if (this._smoothScrollDuration === 0) {
+            // Smooth scrolling not supported.
+            return this.setScrollPositionNow(update);
+        }
+        if (this._smoothScrolling) {
+            // Combine our pending scrollLeft/scrollTop with incoming scrollLeft/scrollTop
+            update = {
+                scrollLeft: (typeof update.scrollLeft === 'undefined' ? this._smoothScrolling.to.scrollLeft : update.scrollLeft),
+                scrollTop: (typeof update.scrollTop === 'undefined' ? this._smoothScrolling.to.scrollTop : update.scrollTop)
+            };
+            // Validate `update`
+            const validTarget = this._state.withScrollPosition(update);
+            if (this._smoothScrolling.to.scrollLeft === validTarget.scrollLeft && this._smoothScrolling.to.scrollTop === validTarget.scrollTop) {
+                // No need to interrupt or extend the current animation since we're going to the same place
+                return;
+            }
+            let newSmoothScrolling;
+            if (reuseAnimation) {
+                newSmoothScrolling = new SmoothScrollingOperation(this._smoothScrolling.from, validTarget, this._smoothScrolling.startTime, this._smoothScrolling.duration);
+            }
+            else {
+                newSmoothScrolling = this._smoothScrolling.combine(this._state, validTarget, this._smoothScrollDuration);
+            }
+            this._smoothScrolling.dispose();
+            this._smoothScrolling = newSmoothScrolling;
+        }
+        else {
+            // Validate `update`
+            const validTarget = this._state.withScrollPosition(update);
+            this._smoothScrolling = SmoothScrollingOperation.start(this._state, validTarget, this._smoothScrollDuration);
+        }
+        // Begin smooth scrolling animation
+        this._smoothScrolling.animationFrameDisposable = this._scheduleAtNextAnimationFrame(() => {
+            if (!this._smoothScrolling) {
+                return;
+            }
+            this._smoothScrolling.animationFrameDisposable = null;
+            this._performSmoothScrolling();
+        });
+    }
+    hasPendingScrollAnimation() {
+        return Boolean(this._smoothScrolling);
+    }
+    _performSmoothScrolling() {
+        if (!this._smoothScrolling) {
+            return;
+        }
+        const update = this._smoothScrolling.tick();
+        const newState = this._state.withScrollPosition(update);
+        this._setState(newState, true);
+        if (!this._smoothScrolling) {
+            // Looks like someone canceled the smooth scrolling
+            // from the scroll event handler
+            return;
+        }
+        if (update.isDone) {
+            this._smoothScrolling.dispose();
+            this._smoothScrolling = null;
+            return;
+        }
+        // Continue smooth scrolling animation
+        this._smoothScrolling.animationFrameDisposable = this._scheduleAtNextAnimationFrame(() => {
+            if (!this._smoothScrolling) {
+                return;
+            }
+            this._smoothScrolling.animationFrameDisposable = null;
+            this._performSmoothScrolling();
+        });
+    }
+    _setState(newState, inSmoothScrolling) {
+        const oldState = this._state;
+        if (oldState.equals(newState)) {
+            // no change
+            return;
+        }
+        this._state = newState;
+        this._onScroll.fire(this._state.createScrollEvent(oldState, inSmoothScrolling));
+    }
+}
+class SmoothScrollingUpdate {
+    constructor(scrollLeft, scrollTop, isDone) {
+        this.scrollLeft = scrollLeft;
+        this.scrollTop = scrollTop;
+        this.isDone = isDone;
+    }
+}
+function createEaseOutCubic(from, to) {
+    const delta = to - from;
+    return function (completion) {
+        return from + delta * easeOutCubic(completion);
+    };
+}
+function createComposed(a, b, cut) {
+    return function (completion) {
+        if (completion < cut) {
+            return a(completion / cut);
+        }
+        return b((completion - cut) / (1 - cut));
+    };
+}
+class SmoothScrollingOperation {
+    constructor(from, to, startTime, duration) {
+        this.from = from;
+        this.to = to;
+        this.duration = duration;
+        this.startTime = startTime;
+        this.animationFrameDisposable = null;
+        this._initAnimations();
+    }
+    _initAnimations() {
+        this.scrollLeft = this._initAnimation(this.from.scrollLeft, this.to.scrollLeft, this.to.width);
+        this.scrollTop = this._initAnimation(this.from.scrollTop, this.to.scrollTop, this.to.height);
+    }
+    _initAnimation(from, to, viewportSize) {
+        const delta = Math.abs(from - to);
+        if (delta > 2.5 * viewportSize) {
+            let stop1, stop2;
+            if (from < to) {
+                // scroll to 75% of the viewportSize
+                stop1 = from + 0.75 * viewportSize;
+                stop2 = to - 0.75 * viewportSize;
+            }
+            else {
+                stop1 = from - 0.75 * viewportSize;
+                stop2 = to + 0.75 * viewportSize;
+            }
+            return createComposed(createEaseOutCubic(from, stop1), createEaseOutCubic(stop2, to), 0.33);
+        }
+        return createEaseOutCubic(from, to);
+    }
+    dispose() {
+        if (this.animationFrameDisposable !== null) {
+            this.animationFrameDisposable.dispose();
+            this.animationFrameDisposable = null;
+        }
+    }
+    acceptScrollDimensions(state) {
+        this.to = state.withScrollPosition(this.to);
+        this._initAnimations();
+    }
+    tick() {
+        return this._tick(Date.now());
+    }
+    _tick(now) {
+        const completion = (now - this.startTime) / this.duration;
+        if (completion < 1) {
+            const newScrollLeft = this.scrollLeft(completion);
+            const newScrollTop = this.scrollTop(completion);
+            return new SmoothScrollingUpdate(newScrollLeft, newScrollTop, false);
+        }
+        return new SmoothScrollingUpdate(this.to.scrollLeft, this.to.scrollTop, true);
+    }
+    combine(from, to, duration) {
+        return SmoothScrollingOperation.start(from, to, duration);
+    }
+    static start(from, to, duration) {
+        // +10 / -10 : pretend the animation already started for a quicker response to a scroll request
+        duration = duration + 10;
+        const startTime = Date.now() - 10;
+        return new SmoothScrollingOperation(from, to, startTime, duration);
+    }
+}
+function easeInCubic(t) {
+    return Math.pow(t, 3);
+}
+function easeOutCubic(t) {
+    return 1 - easeInCubic(1 - t);
+}
+
+export { ScrollState, Scrollable, SmoothScrollingOperation, SmoothScrollingUpdate };