@codingame/monaco-vscode-welcome-service-override 1.85.1

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

@@ -0,0 +1,434 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/walkThroughPart.css.js';
+import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { Gesture, EventType } from 'monaco-editor/esm/vs/base/browser/touch.js';
+import * as strings from 'monaco-editor/esm/vs/base/common/strings.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { DisposableStore, toDisposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { EditorPane } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { WalkThroughInput } from './walkThroughInput.js';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { CodeEditorWidget } from 'monaco-editor/esm/vs/editor/browser/widget/codeEditorWidget.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { UILabelProvider } from 'monaco-editor/esm/vs/base/common/keybindingLabels.js';
+import { OS } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { getWindow, size, safeInnerHtml, addDisposableListener } from 'monaco-editor/esm/vs/base/browser/dom.js';
+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(telemetryService, themeService, textResourceConfigurationService, instantiationService, openerService, keybindingService, storageService, contextKeyService, configurationService, notificationService, extensionService, editorGroupService) {
+        super(WalkThroughPart_1.ID, 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] || getWindow(node).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(66 );
+                    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(66 );
+                        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">${strings.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();
+        if (this.group) {
+            this.editorMemento.saveEditorState(this.group, input, {
+                viewState: {
+                    scrollTop: scrollPosition.scrollTop,
+                    scrollLeft: scrollPosition.scrollLeft
+                }
+            });
+        }
+    }
+    loadTextEditorViewState(input) {
+        if (this.group) {
+            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(0, ITelemetryService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, ITextResourceConfigurationService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IOpenerService)),
+    ( __param(5, IKeybindingService)),
+    ( __param(6, IStorageService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IConfigurationService)),
+    ( __param(9, INotificationService)),
+    ( __param(10, IExtensionService)),
+    ( __param(11, IEditorGroupsService))
+], WalkThroughPart));
+
+export { WALK_THROUGH_FOCUS, WalkThroughPart };

package/vscode/src/vs/workbench/contrib/welcomeWalkthrough/common/walkThroughContentProvider.js

@@ -0,0 +1,75 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { marked } from 'monaco-editor/esm/vs/base/common/marked/marked.js';
+import { Schemas, FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { createTextBufferFactory } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+
+async function requireToContent(instantiationService, resource) {
+    if (!resource.query) {
+        throw new Error('Welcome: invalid resource');
+    }
+    const query = JSON.parse(resource.query);
+    if (!query.moduleId) {
+        throw new Error('Welcome: invalid resource');
+    }
+    const content = await FileAccess.toModuleContent(query.moduleId);
+    return instantiationService.invokeFunction(content);
+}
+let WalkThroughSnippetContentProvider = class WalkThroughSnippetContentProvider {
+    constructor(textModelResolverService, languageService, modelService, instantiationService) {
+        this.textModelResolverService = textModelResolverService;
+        this.languageService = languageService;
+        this.modelService = modelService;
+        this.instantiationService = instantiationService;
+        this.loads = ( new Map());
+        this.textModelResolverService.registerTextModelContentProvider(Schemas.walkThroughSnippet, this);
+    }
+    async textBufferFactoryFromResource(resource) {
+        let ongoing = this.loads.get(( resource.toString()));
+        if (!ongoing) {
+            ongoing = requireToContent(this.instantiationService, resource)
+                .then(content => createTextBufferFactory(content))
+                .finally(() => this.loads.delete(( resource.toString())));
+            this.loads.set(( resource.toString()), ongoing);
+        }
+        return ongoing;
+    }
+    async provideTextContent(resource) {
+        const factory = await this.textBufferFactoryFromResource(resource.with({ fragment: '' }));
+        let codeEditorModel = this.modelService.getModel(resource);
+        if (!codeEditorModel) {
+            const j = parseInt(resource.fragment);
+            let i = 0;
+            const renderer = new marked.Renderer();
+            renderer.code = (code, lang) => {
+                i++;
+                const languageId = typeof lang === 'string' ? this.languageService.getLanguageIdByLanguageName(lang) || '' : '';
+                const languageSelection = this.languageService.createById(languageId);
+                const model = this.modelService.createModel(code, languageSelection, resource.with({ fragment: `${i}.${lang}` }));
+                if (i === j) {
+                    codeEditorModel = model;
+                }
+                return '';
+            };
+            const textBuffer = factory.create(1 ).textBuffer;
+            const lineCount = textBuffer.getLineCount();
+            const range = ( new Range(1, 1, lineCount, textBuffer.getLineLength(lineCount) + 1));
+            const markdown = textBuffer.getValueInRange(range, 0 );
+            marked(markdown, { renderer });
+        }
+        return assertIsDefined(codeEditorModel);
+    }
+};
+WalkThroughSnippetContentProvider = ( __decorate([
+    ( __param(0, ITextModelService)),
+    ( __param(1, ILanguageService)),
+    ( __param(2, IModelService)),
+    ( __param(3, IInstantiationService))
+], WalkThroughSnippetContentProvider));
+
+export { WalkThroughSnippetContentProvider, requireToContent };

package/welcome.d.ts

@@ -0,0 +1,5 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+
+declare function getServiceOverride(): IEditorOverrideServices;
+
+export { getServiceOverride as default };

package/welcome.js

@@ -0,0 +1,25 @@
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { IWalkthroughsService, WalkthroughsService } from 'vscode/vscode/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStartedService';
+import { IFeaturedExtensionsService, FeaturedExtensionsService } from 'vscode/vscode/vs/workbench/contrib/welcomeGettingStarted/browser/featuredExtensionService';
+import './vscode/src/vs/workbench/contrib/welcomeGettingStarted/browser/gettingStarted.contribution.js';
+import './vscode/src/vs/workbench/contrib/welcomeWalkthrough/browser/walkThrough.contribution.js';
+import './vscode/src/vs/workbench/contrib/welcomeViews/common/viewsWelcome.contribution.js';
+import './vscode/src/vs/workbench/contrib/welcomeViews/common/newFile.contribution.js';
+import svgAssets from './vscode/src/vs/workbench/contrib/welcomeGettingStarted/common/media/all.svg.js';
+import pngAssets from './vscode/src/vs/workbench/contrib/welcomeGettingStarted/common/media/all.png.js';
+import { FileAccess } from 'monaco-editor/esm/vs/base/common/network.js';
+import { registerAssets } from 'vscode/assets';
+
+registerAssets(svgAssets);
+registerAssets(pngAssets);
+FileAccess.registerModuleContentProvider('vs/workbench/contrib/welcomeWalkthrough/browser/editor/vs_code_editor_walkthrough', () => import('./vscode/src/vs/workbench/contrib/welcomeWalkthrough/browser/editor/vs_code_editor_walkthrough.js').then(module => module.default ?? module));
+FileAccess.registerModuleContentProvider('vs/workbench/contrib/welcomeGettingStarted/common/media/theme_picker', () => import('./vscode/src/vs/workbench/contrib/welcomeGettingStarted/common/media/theme_picker.js').then(module => module.default ?? module));
+FileAccess.registerModuleContentProvider('vs/workbench/contrib/welcomeGettingStarted/common/media/notebookProfile', () => import('./vscode/src/vs/workbench/contrib/welcomeGettingStarted/common/media/notebookProfile.js').then(module => module.default ?? module));
+function getServiceOverride() {
+    return {
+        [( IWalkthroughsService.toString())]: new SyncDescriptor(WalkthroughsService, [], true),
+        [( IFeaturedExtensionsService.toString())]: new SyncDescriptor(FeaturedExtensionsService, [], true)
+    };
+}
+
+export { getServiceOverride as default };