@codingame/monaco-vscode-walkthrough-service-override 4.3.0

package/vscode/src/vs/workbench/contrib/welcomeWalkthrough/browser/walkThrough.contribution.js

@@ -0,0 +1,39 @@
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { WalkThroughInput } from './walkThroughInput.js';
+import { WalkThroughPart } from './walkThroughPart.js';
+import { WalkThroughArrowUp, WalkThroughArrowDown, WalkThroughPageUp, WalkThroughPageDown } from './walkThroughActions.js';
+import { WalkThroughSnippetContentProvider } from '../common/walkThroughContentProvider.js';
+import { EditorWalkThroughAction, EditorWalkThroughInputSerializer } from './editor/editorWalkThrough.js';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { EditorExtensions } from 'vscode/vscode/vs/workbench/common/editor';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { registerAction2, MenuRegistry, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { EditorPaneDescriptor } from 'vscode/vscode/vs/workbench/browser/editor';
+import { KeybindingsRegistry } from 'vscode/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+
+( Registry.as(EditorExtensions.EditorPane))
+    .registerEditorPane(EditorPaneDescriptor.create(WalkThroughPart, WalkThroughPart.ID, ( localizeWithPath(
+    'vs/workbench/contrib/welcomeWalkthrough/browser/walkThrough.contribution',
+    'walkThrough.editor.label',
+    "Playground"
+))), [( new SyncDescriptor(WalkThroughInput))]);
+registerAction2(EditorWalkThroughAction);
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(EditorWalkThroughInputSerializer.ID, EditorWalkThroughInputSerializer);
+registerWorkbenchContribution2(WalkThroughSnippetContentProvider.ID, WalkThroughSnippetContentProvider, { editorTypeId: WalkThroughPart.ID });
+KeybindingsRegistry.registerCommandAndKeybindingRule(WalkThroughArrowUp);
+KeybindingsRegistry.registerCommandAndKeybindingRule(WalkThroughArrowDown);
+KeybindingsRegistry.registerCommandAndKeybindingRule(WalkThroughPageUp);
+KeybindingsRegistry.registerCommandAndKeybindingRule(WalkThroughPageDown);
+MenuRegistry.appendMenuItem(MenuId.MenubarHelpMenu, {
+    group: '1_welcome',
+    command: {
+        id: 'workbench.action.showInteractivePlayground',
+        title: ( localizeWithPath(
+            'vs/workbench/contrib/welcomeWalkthrough/browser/walkThrough.contribution',
+            { key: 'miPlayground', comment: ['&& denotes a mnemonic'] },
+            "Editor Playgrou&&nd"
+        ))
+    },
+    order: 3
+});

package/vscode/src/vs/workbench/contrib/welcomeWalkthrough/browser/walkThroughActions.js

@@ -0,0 +1,59 @@
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { WALK_THROUGH_FOCUS, WalkThroughPart } from './walkThroughPart.js';
+import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+
+const WalkThroughArrowUp = {
+    id: 'workbench.action.interactivePlayground.arrowUp',
+    weight: 200 ,
+    when: ( ContextKeyExpr.and(WALK_THROUGH_FOCUS, ( EditorContextKeys.editorTextFocus.toNegated()))),
+    primary: 16 ,
+    handler: accessor => {
+        const editorService = accessor.get(IEditorService);
+        const activeEditorPane = editorService.activeEditorPane;
+        if (activeEditorPane instanceof WalkThroughPart) {
+            activeEditorPane.arrowUp();
+        }
+    }
+};
+const WalkThroughArrowDown = {
+    id: 'workbench.action.interactivePlayground.arrowDown',
+    weight: 200 ,
+    when: ( ContextKeyExpr.and(WALK_THROUGH_FOCUS, ( EditorContextKeys.editorTextFocus.toNegated()))),
+    primary: 18 ,
+    handler: accessor => {
+        const editorService = accessor.get(IEditorService);
+        const activeEditorPane = editorService.activeEditorPane;
+        if (activeEditorPane instanceof WalkThroughPart) {
+            activeEditorPane.arrowDown();
+        }
+    }
+};
+const WalkThroughPageUp = {
+    id: 'workbench.action.interactivePlayground.pageUp',
+    weight: 200 ,
+    when: ( ContextKeyExpr.and(WALK_THROUGH_FOCUS, ( EditorContextKeys.editorTextFocus.toNegated()))),
+    primary: 11 ,
+    handler: accessor => {
+        const editorService = accessor.get(IEditorService);
+        const activeEditorPane = editorService.activeEditorPane;
+        if (activeEditorPane instanceof WalkThroughPart) {
+            activeEditorPane.pageUp();
+        }
+    }
+};
+const WalkThroughPageDown = {
+    id: 'workbench.action.interactivePlayground.pageDown',
+    weight: 200 ,
+    when: ( ContextKeyExpr.and(WALK_THROUGH_FOCUS, ( EditorContextKeys.editorTextFocus.toNegated()))),
+    primary: 12 ,
+    handler: accessor => {
+        const editorService = accessor.get(IEditorService);
+        const activeEditorPane = editorService.activeEditorPane;
+        if (activeEditorPane instanceof WalkThroughPart) {
+            activeEditorPane.pageDown();
+        }
+    }
+};
+
+export { WalkThroughArrowDown, WalkThroughArrowUp, WalkThroughPageDown, WalkThroughPageUp };

package/vscode/src/vs/workbench/contrib/welcomeWalkthrough/browser/walkThroughInput.js

@@ -0,0 +1,115 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import { EditorInput } from 'vscode/vscode/vs/workbench/common/editor/editorInput';
+import { EditorModel } from 'vscode/vscode/vs/workbench/common/editor/editorModel';
+import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
+import marked_1 from 'vscode/external/vscode-marked/lib/marked.esm.js';
+import { isEqual } from 'vscode/vscode/vs/base/common/resources';
+import { requireToContent } from '../common/walkThroughContentProvider.js';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+
+var WalkThroughInput_1;
+class WalkThroughModel extends EditorModel {
+    constructor(mainRef, snippetRefs) {
+        super();
+        this.mainRef = mainRef;
+        this.snippetRefs = snippetRefs;
+    }
+    get main() {
+        return this.mainRef;
+    }
+    get snippets() {
+        return ( this.snippetRefs.map(snippet => snippet.object));
+    }
+    dispose() {
+        this.snippetRefs.forEach(ref => ref.dispose());
+        super.dispose();
+    }
+}
+let WalkThroughInput = WalkThroughInput_1 = class WalkThroughInput extends EditorInput {
+    get capabilities() {
+        return 8  | super.capabilities;
+    }
+    get resource() { return this.options.resource; }
+    constructor(options, instantiationService, textModelResolverService) {
+        super();
+        this.options = options;
+        this.instantiationService = instantiationService;
+        this.textModelResolverService = textModelResolverService;
+        this.promise = null;
+        this.maxTopScroll = 0;
+        this.maxBottomScroll = 0;
+    }
+    get typeId() {
+        return this.options.typeId;
+    }
+    getName() {
+        return this.options.name;
+    }
+    getDescription() {
+        return this.options.description || '';
+    }
+    getTelemetryFrom() {
+        return this.options.telemetryFrom;
+    }
+    getTelemetryDescriptor() {
+        const descriptor = super.getTelemetryDescriptor();
+        descriptor['target'] = this.getTelemetryFrom();
+        return descriptor;
+    }
+    get onReady() {
+        return this.options.onReady;
+    }
+    get layout() {
+        return this.options.layout;
+    }
+    resolve() {
+        if (!this.promise) {
+            this.promise = requireToContent(this.instantiationService, this.options.resource)
+                .then(content => {
+                if (this.resource.path.endsWith('.html')) {
+                    return ( new WalkThroughModel(content, []));
+                }
+                const snippets = [];
+                let i = 0;
+                const renderer = new marked_1.Renderer();
+                renderer.code = (code, lang) => {
+                    i++;
+                    const resource = this.options.resource.with({ scheme: Schemas.walkThroughSnippet, fragment: `${i}.${lang}` });
+                    snippets.push(this.textModelResolverService.createModelReference(resource));
+                    return `<div id="snippet-${resource.fragment}" class="walkThroughEditorContainer" ></div>`;
+                };
+                content = marked_1(content, { renderer });
+                return Promise.all(snippets)
+                    .then(refs => ( new WalkThroughModel(content, refs)));
+            });
+        }
+        return this.promise;
+    }
+    matches(otherInput) {
+        if (super.matches(otherInput)) {
+            return true;
+        }
+        if (otherInput instanceof WalkThroughInput_1) {
+            return isEqual(otherInput.options.resource, this.options.resource);
+        }
+        return false;
+    }
+    dispose() {
+        if (this.promise) {
+            this.promise.then(model => model.dispose());
+            this.promise = null;
+        }
+        super.dispose();
+    }
+    relativeScrollPosition(topScroll, bottomScroll) {
+        this.maxTopScroll = Math.max(this.maxTopScroll, topScroll);
+        this.maxBottomScroll = Math.max(this.maxBottomScroll, bottomScroll);
+    }
+};
+WalkThroughInput = WalkThroughInput_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, ITextModelService))
+], WalkThroughInput));
+
+export { WalkThroughInput };

package/vscode/src/vs/workbench/contrib/welcomeWalkthrough/browser/walkThroughPart.js

@@ -0,0 +1,431 @@
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+import '../common/walkThroughUtils.js';
+import './media/walkThroughPart.css.js';
+import { DomScrollableElement } from 'vscode/vscode/vs/base/browser/ui/scrollbar/scrollableElement';
+import { Gesture, EventType } from 'vscode/vscode/vs/base/browser/touch';
+import { escape } from 'vscode/vscode/vs/base/common/strings';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+import { DisposableStore, toDisposable, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
+import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { WalkThroughInput } from './walkThroughInput.js';
+import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
+import { ITextResourceConfigurationService } from 'vscode/vscode/vs/editor/common/services/textResourceConfiguration';
+import { CodeEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
+import { RawContextKey, IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { isObject } from 'vscode/vscode/vs/base/common/types';
+import { CommandsRegistry } from 'vscode/vscode/vs/platform/commands/common/commands';
+import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService';
+import { UILabelProvider } from 'vscode/vscode/vs/base/common/keybindingLabels';
+import { OS } from 'vscode/vscode/vs/base/common/platform';
+import { deepClone } from 'vscode/vscode/vs/base/common/objects';
+import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
+import { size, safeInnerHtml, addDisposableListener } from 'vscode/vscode/vs/base/browser/dom';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+
+var WalkThroughPart_1;
+const WALK_THROUGH_FOCUS = ( new RawContextKey('interactivePlaygroundFocus', false));
+const UNBOUND_COMMAND = ( localizeWithPath(
+    'vs/workbench/contrib/welcomeWalkthrough/browser/walkThroughPart',
+    'walkThrough.unboundCommand',
+    "unbound"
+));
+const WALK_THROUGH_EDITOR_VIEW_STATE_PREFERENCE_KEY = 'walkThroughEditorViewState';
+let WalkThroughPart = class WalkThroughPart extends EditorPane {
+    static { WalkThroughPart_1 = this; }
+    static { this.ID = 'workbench.editor.walkThroughPart'; }
+    constructor(group, telemetryService, themeService, textResourceConfigurationService, instantiationService, openerService, keybindingService, storageService, contextKeyService, configurationService, notificationService, extensionService, editorGroupService) {
+        super(WalkThroughPart_1.ID, group, telemetryService, themeService, storageService);
+        this.instantiationService = instantiationService;
+        this.openerService = openerService;
+        this.keybindingService = keybindingService;
+        this.contextKeyService = contextKeyService;
+        this.configurationService = configurationService;
+        this.notificationService = notificationService;
+        this.extensionService = extensionService;
+        this.disposables = ( new DisposableStore());
+        this.contentDisposables = [];
+        this.editorFocus = WALK_THROUGH_FOCUS.bindTo(this.contextKeyService);
+        this.editorMemento = this.getEditorMemento(editorGroupService, textResourceConfigurationService, WALK_THROUGH_EDITOR_VIEW_STATE_PREFERENCE_KEY);
+    }
+    createEditor(container) {
+        this.content = document.createElement('div');
+        this.content.classList.add('welcomePageFocusElement');
+        this.content.tabIndex = 0;
+        this.content.style.outlineStyle = 'none';
+        this.scrollbar = ( new DomScrollableElement(this.content, {
+            horizontal: 1 ,
+            vertical: 1
+        }));
+        this.disposables.add(this.scrollbar);
+        container.appendChild(this.scrollbar.getDomNode());
+        this.registerFocusHandlers();
+        this.registerClickHandler();
+        this.disposables.add(this.scrollbar.onScroll(e => this.updatedScrollPosition()));
+    }
+    updatedScrollPosition() {
+        const scrollDimensions = this.scrollbar.getScrollDimensions();
+        const scrollPosition = this.scrollbar.getScrollPosition();
+        const scrollHeight = scrollDimensions.scrollHeight;
+        if (scrollHeight && this.input instanceof WalkThroughInput) {
+            const scrollTop = scrollPosition.scrollTop;
+            const height = scrollDimensions.height;
+            this.input.relativeScrollPosition(scrollTop / scrollHeight, (scrollTop + height) / scrollHeight);
+        }
+    }
+    onTouchChange(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        const scrollPosition = this.scrollbar.getScrollPosition();
+        this.scrollbar.setScrollPosition({ scrollTop: scrollPosition.scrollTop - event.translationY });
+    }
+    addEventListener(element, type, listener, useCapture) {
+        element.addEventListener(type, listener, useCapture);
+        return toDisposable(() => { element.removeEventListener(type, listener, useCapture); });
+    }
+    registerFocusHandlers() {
+        this.disposables.add(this.addEventListener(this.content, 'mousedown', e => {
+            this.focus();
+        }));
+        this.disposables.add(this.addEventListener(this.content, 'focus', e => {
+            this.editorFocus.set(true);
+        }));
+        this.disposables.add(this.addEventListener(this.content, 'blur', e => {
+            this.editorFocus.reset();
+        }));
+        this.disposables.add(this.addEventListener(this.content, 'focusin', (e) => {
+            if (e.target instanceof HTMLElement && e.target.classList.contains('zone-widget-container')) {
+                const scrollPosition = this.scrollbar.getScrollPosition();
+                this.content.scrollTop = scrollPosition.scrollTop;
+                this.content.scrollLeft = scrollPosition.scrollLeft;
+            }
+            if (e.target instanceof HTMLElement) {
+                this.lastFocus = e.target;
+            }
+        }));
+    }
+    registerClickHandler() {
+        this.content.addEventListener('click', event => {
+            for (let node = event.target; node; node = node.parentNode) {
+                if (node instanceof HTMLAnchorElement && node.href) {
+                    const baseElement = node.ownerDocument.getElementsByTagName('base')[0] || this.window.location;
+                    if (baseElement && node.href.indexOf(baseElement.href) >= 0 && node.hash) {
+                        const scrollTarget = this.content.querySelector(node.hash);
+                        const innerContent = this.content.firstElementChild;
+                        if (scrollTarget && innerContent) {
+                            const targetTop = scrollTarget.getBoundingClientRect().top - 20;
+                            const containerTop = innerContent.getBoundingClientRect().top;
+                            this.scrollbar.setScrollPosition({ scrollTop: targetTop - containerTop });
+                        }
+                    }
+                    else {
+                        this.open(( URI.parse(node.href)));
+                    }
+                    event.preventDefault();
+                    break;
+                }
+                else if (node instanceof HTMLButtonElement) {
+                    const href = node.getAttribute('data-href');
+                    if (href) {
+                        this.open(( URI.parse(href)));
+                    }
+                    break;
+                }
+                else if (node === event.currentTarget) {
+                    break;
+                }
+            }
+        });
+    }
+    open(uri) {
+        if (uri.scheme === 'command' && uri.path === 'git.clone' && !CommandsRegistry.getCommand('git.clone')) {
+            this.notificationService.info(( localizeWithPath(
+                'vs/workbench/contrib/welcomeWalkthrough/browser/walkThroughPart',
+                'walkThrough.gitNotFound',
+                "It looks like Git is not installed on your system."
+            )));
+            return;
+        }
+        this.openerService.open(this.addFrom(uri), { allowCommands: true });
+    }
+    addFrom(uri) {
+        if (uri.scheme !== 'command' || !(this.input instanceof WalkThroughInput)) {
+            return uri;
+        }
+        const query = uri.query ? JSON.parse(uri.query) : {};
+        query.from = this.input.getTelemetryFrom();
+        return uri.with({ query: JSON.stringify(query) });
+    }
+    layout(dimension) {
+        this.size = dimension;
+        size(this.content, dimension.width, dimension.height);
+        this.updateSizeClasses();
+        this.contentDisposables.forEach(disposable => {
+            if (disposable instanceof CodeEditorWidget) {
+                disposable.layout();
+            }
+        });
+        const walkthroughInput = this.input instanceof WalkThroughInput && this.input;
+        if (walkthroughInput && walkthroughInput.layout) {
+            walkthroughInput.layout(dimension);
+        }
+        this.scrollbar.scanDomNode();
+    }
+    updateSizeClasses() {
+        const innerContent = this.content.firstElementChild;
+        if (this.size && innerContent) {
+            innerContent.classList.toggle('max-height-685px', this.size.height <= 685);
+        }
+    }
+    focus() {
+        super.focus();
+        let active = this.content.ownerDocument.activeElement;
+        while (active && active !== this.content) {
+            active = active.parentElement;
+        }
+        if (!active) {
+            (this.lastFocus || this.content).focus();
+        }
+        this.editorFocus.set(true);
+    }
+    arrowUp() {
+        const scrollPosition = this.scrollbar.getScrollPosition();
+        this.scrollbar.setScrollPosition({ scrollTop: scrollPosition.scrollTop - this.getArrowScrollHeight() });
+    }
+    arrowDown() {
+        const scrollPosition = this.scrollbar.getScrollPosition();
+        this.scrollbar.setScrollPosition({ scrollTop: scrollPosition.scrollTop + this.getArrowScrollHeight() });
+    }
+    getArrowScrollHeight() {
+        let fontSize = this.configurationService.getValue('editor.fontSize');
+        if (typeof fontSize !== 'number' || fontSize < 1) {
+            fontSize = 12;
+        }
+        return 3 * fontSize;
+    }
+    pageUp() {
+        const scrollDimensions = this.scrollbar.getScrollDimensions();
+        const scrollPosition = this.scrollbar.getScrollPosition();
+        this.scrollbar.setScrollPosition({ scrollTop: scrollPosition.scrollTop - scrollDimensions.height });
+    }
+    pageDown() {
+        const scrollDimensions = this.scrollbar.getScrollDimensions();
+        const scrollPosition = this.scrollbar.getScrollPosition();
+        this.scrollbar.setScrollPosition({ scrollTop: scrollPosition.scrollTop + scrollDimensions.height });
+    }
+    setInput(input, options, context, token) {
+        const store = ( new DisposableStore());
+        this.contentDisposables.push(store);
+        this.content.innerText = '';
+        return super.setInput(input, options, context, token)
+            .then(async () => {
+            if (input.resource.path.endsWith('.md')) {
+                await this.extensionService.whenInstalledExtensionsRegistered();
+            }
+            return input.resolve();
+        })
+            .then(model => {
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const content = model.main;
+            if (!input.resource.path.endsWith('.md')) {
+                safeInnerHtml(this.content, content);
+                this.updateSizeClasses();
+                this.decorateContent();
+                this.contentDisposables.push(this.keybindingService.onDidUpdateKeybindings(() => this.decorateContent()));
+                input.onReady?.(this.content.firstElementChild, store);
+                this.scrollbar.scanDomNode();
+                this.loadTextEditorViewState(input);
+                this.updatedScrollPosition();
+                return;
+            }
+            const innerContent = document.createElement('div');
+            innerContent.classList.add('walkThroughContent');
+            const markdown = this.expandMacros(content);
+            safeInnerHtml(innerContent, markdown);
+            this.content.appendChild(innerContent);
+            model.snippets.forEach((snippet, i) => {
+                const model = snippet.textEditorModel;
+                if (!model) {
+                    return;
+                }
+                const id = `snippet-${model.uri.fragment}`;
+                const div = innerContent.querySelector(`#${id.replace(/[\\.]/g, '\\$&')}`);
+                const options = this.getEditorOptions(model.getLanguageId());
+                const telemetryData = {
+                    target: this.input instanceof WalkThroughInput ? this.input.getTelemetryFrom() : undefined,
+                    snippet: i
+                };
+                const editor = this.instantiationService.createInstance(CodeEditorWidget, div, options, {
+                    telemetryData: telemetryData
+                });
+                editor.setModel(model);
+                this.contentDisposables.push(editor);
+                const updateHeight = (initial) => {
+                    const lineHeight = editor.getOption(67 );
+                    const height = `${Math.max(model.getLineCount() + 1, 4) * lineHeight}px`;
+                    if (div.style.height !== height) {
+                        div.style.height = height;
+                        editor.layout();
+                        if (!initial) {
+                            this.scrollbar.scanDomNode();
+                        }
+                    }
+                };
+                updateHeight(true);
+                this.contentDisposables.push(editor.onDidChangeModelContent(() => updateHeight(false)));
+                this.contentDisposables.push(editor.onDidChangeCursorPosition(e => {
+                    const innerContent = this.content.firstElementChild;
+                    if (innerContent) {
+                        const targetTop = div.getBoundingClientRect().top;
+                        const containerTop = innerContent.getBoundingClientRect().top;
+                        const lineHeight = editor.getOption(67 );
+                        const lineTop = (targetTop + (e.position.lineNumber - 1) * lineHeight) - containerTop;
+                        const lineBottom = lineTop + lineHeight;
+                        const scrollDimensions = this.scrollbar.getScrollDimensions();
+                        const scrollPosition = this.scrollbar.getScrollPosition();
+                        const scrollTop = scrollPosition.scrollTop;
+                        const height = scrollDimensions.height;
+                        if (scrollTop > lineTop) {
+                            this.scrollbar.setScrollPosition({ scrollTop: lineTop });
+                        }
+                        else if (scrollTop < lineBottom - height) {
+                            this.scrollbar.setScrollPosition({ scrollTop: lineBottom - height });
+                        }
+                    }
+                }));
+                this.contentDisposables.push(this.configurationService.onDidChangeConfiguration(e => {
+                    if (e.affectsConfiguration('editor') && snippet.textEditorModel) {
+                        editor.updateOptions(this.getEditorOptions(snippet.textEditorModel.getLanguageId()));
+                    }
+                }));
+            });
+            this.updateSizeClasses();
+            this.multiCursorModifier();
+            this.contentDisposables.push(this.configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration('editor.multiCursorModifier')) {
+                    this.multiCursorModifier();
+                }
+            }));
+            input.onReady?.(innerContent, store);
+            this.scrollbar.scanDomNode();
+            this.loadTextEditorViewState(input);
+            this.updatedScrollPosition();
+            this.contentDisposables.push(Gesture.addTarget(innerContent));
+            this.contentDisposables.push(addDisposableListener(innerContent, EventType.Change, e => this.onTouchChange(e)));
+        });
+    }
+    getEditorOptions(language) {
+        const config = deepClone(this.configurationService.getValue('editor', { overrideIdentifier: language }));
+        return {
+            ...(isObject(config) ? config : Object.create(null)),
+            scrollBeyondLastLine: false,
+            scrollbar: {
+                verticalScrollbarSize: 14,
+                horizontal: 'auto',
+                useShadows: true,
+                verticalHasArrows: false,
+                horizontalHasArrows: false,
+                alwaysConsumeMouseWheel: false
+            },
+            overviewRulerLanes: 3,
+            fixedOverflowWidgets: false,
+            lineNumbersMinChars: 1,
+            minimap: { enabled: false },
+        };
+    }
+    expandMacros(input) {
+        return input.replace(/kb\(([a-z.\d\-]+)\)/gi, (match, kb) => {
+            const keybinding = this.keybindingService.lookupKeybinding(kb);
+            const shortcut = keybinding ? keybinding.getLabel() || '' : UNBOUND_COMMAND;
+            return `<span class="shortcut">${escape(shortcut)}</span>`;
+        });
+    }
+    decorateContent() {
+        const keys = this.content.querySelectorAll('.shortcut[data-command]');
+        Array.prototype.forEach.call(keys, (key) => {
+            const command = key.getAttribute('data-command');
+            const keybinding = command && this.keybindingService.lookupKeybinding(command);
+            const label = keybinding ? keybinding.getLabel() || '' : UNBOUND_COMMAND;
+            while (key.firstChild) {
+                key.removeChild(key.firstChild);
+            }
+            key.appendChild(document.createTextNode(label));
+        });
+        const ifkeys = this.content.querySelectorAll('.if_shortcut[data-command]');
+        Array.prototype.forEach.call(ifkeys, (key) => {
+            const command = key.getAttribute('data-command');
+            const keybinding = command && this.keybindingService.lookupKeybinding(command);
+            key.style.display = !keybinding ? 'none' : '';
+        });
+    }
+    multiCursorModifier() {
+        const labels = UILabelProvider.modifierLabels[OS];
+        const value = this.configurationService.getValue('editor.multiCursorModifier');
+        const modifier = labels[value === 'ctrlCmd' ? (OS === 2  ? 'metaKey' : 'ctrlKey') : 'altKey'];
+        const keys = this.content.querySelectorAll('.multi-cursor-modifier');
+        Array.prototype.forEach.call(keys, (key) => {
+            while (key.firstChild) {
+                key.removeChild(key.firstChild);
+            }
+            key.appendChild(document.createTextNode(modifier));
+        });
+    }
+    saveTextEditorViewState(input) {
+        const scrollPosition = this.scrollbar.getScrollPosition();
+        this.editorMemento.saveEditorState(this.group, input, {
+            viewState: {
+                scrollTop: scrollPosition.scrollTop,
+                scrollLeft: scrollPosition.scrollLeft
+            }
+        });
+    }
+    loadTextEditorViewState(input) {
+        const state = this.editorMemento.loadEditorState(this.group, input);
+        if (state) {
+            this.scrollbar.setScrollPosition(state.viewState);
+        }
+    }
+    clearInput() {
+        if (this.input instanceof WalkThroughInput) {
+            this.saveTextEditorViewState(this.input);
+        }
+        this.contentDisposables = dispose(this.contentDisposables);
+        super.clearInput();
+    }
+    saveState() {
+        if (this.input instanceof WalkThroughInput) {
+            this.saveTextEditorViewState(this.input);
+        }
+        super.saveState();
+    }
+    dispose() {
+        this.editorFocus.reset();
+        this.contentDisposables = dispose(this.contentDisposables);
+        this.disposables.dispose();
+        super.dispose();
+    }
+};
+WalkThroughPart = WalkThroughPart_1 = ( __decorate([
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, ITextResourceConfigurationService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IOpenerService)),
+    ( __param(6, IKeybindingService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, IConfigurationService)),
+    ( __param(10, INotificationService)),
+    ( __param(11, IExtensionService)),
+    ( __param(12, IEditorGroupsService))
+], WalkThroughPart));
+
+export { WALK_THROUGH_FOCUS, WalkThroughPart };