@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/README.md

@@ -236,6 +236,8 @@ Additionally, several packages that include the VSCode version of some services
   - Survey/feedback support
 - **Update**
   - Update detection, release notes...
+- **Localization**
+  - Register callbacks to update the display language from the VSCode UI (either from the `Set Display Language` command or from the extension gallery extension packs)
 
 Usage:
 

package/l10n.d.ts

@@ -1,4 +1,7 @@
-declare function registerLocalization(language: string, main: Record<string, Record<string, string>>, extensionTranslationsUris: Record<string, string>): void;
+declare function setAvailableLocales(locales: Set<string>): void;
+declare function isLocaleAvailable(locale: string): boolean;
+declare function registerLocalization(extensionId: string, language: string, main: Record<string, Record<string, string>>, extensionTranslationsUris: Record<string, string>): void;
 declare function getBuiltInExtensionTranslationsUris(language: string): Record<string, string> | undefined;
+declare function getExtensionIdProvidingCurrentLocale(): string | undefined;
 
-export { getBuiltInExtensionTranslationsUris, registerLocalization };
+export { getBuiltInExtensionTranslationsUris, getExtensionIdProvidingCurrentLocale, isLocaleAvailable, registerLocalization, setAvailableLocales };

package/l10n.js

@@ -1,13 +1,25 @@
 import { isInitialized, setLocale } from './vscode/src/vs/nls.js';
 const extensionTranslationsUri = {};
-function registerLocalization(language, main, extensionTranslationsUris) {
+let currentLocaleExtensionId;
+let availableLocales = new Set();
+function setAvailableLocales(locales) {
+    availableLocales = locales;
+}
+function isLocaleAvailable(locale) {
+    return ( availableLocales.has(locale));
+}
+function registerLocalization(extensionId, language, main, extensionTranslationsUris) {
     if (isInitialized()) {
         console.error('Some parts of VSCode are already initialized, make sure the language pack is loaded before anything else or some translations will be missing');
     }
     setLocale(language, main);
     extensionTranslationsUri[language] = extensionTranslationsUris;
+    currentLocaleExtensionId = extensionId;
 }
 function getBuiltInExtensionTranslationsUris(language) {
     return extensionTranslationsUri[language];
 }
-export { getBuiltInExtensionTranslationsUris, registerLocalization };
+function getExtensionIdProvidingCurrentLocale() {
+    return currentLocaleExtensionId;
+}
+export { getBuiltInExtensionTranslationsUris, getExtensionIdProvidingCurrentLocale, isLocaleAvailable, registerLocalization, setAvailableLocales };

package/missing-services.js

@@ -198,7 +198,8 @@ import { IAuthenticationAccessService } from './vscode/src/vs/workbench/services
 import { IAuthenticationUsageService } from './vscode/src/vs/workbench/services/authentication/browser/authenticationUsageService.js';
 import { ICustomEditorLabelService } from './vscode/src/vs/workbench/services/editor/common/customEditorLabelService.js';
 import { IExtensionsProfileScannerService } from './vscode/src/vs/platform/extensionManagement/common/extensionsProfileScannerService.js';
-import { getBuiltInExtensionTranslationsUris } from './l10n.js';
+import { createInstanceCapabilityEventMultiplexer } from './vscode/src/vs/workbench/contrib/terminal/browser/terminalEvents.js';
+import { getExtensionIdProvidingCurrentLocale, getBuiltInExtensionTranslationsUris } from './l10n.js';
 import { unsupported } from './tools.js';
 import { IFileDialogService } from './vscode/src/vs/platform/dialogs/common/dialogs.js';
 var _a;
@@ -1599,10 +1600,8 @@ registerSingleton(ITerminalService, class TerminalService {
         this.onAnyInstanceProcessIdReady = Event.None;
         this.onAnyInstanceSelectionChange = Event.None;
         this.onAnyInstanceTitleChange = Event.None;
-        this.createOnInstanceEvent = unsupported;
-        this.createOnInstanceCapabilityEvent = unsupported;
-        this.onInstanceEvent = unsupported;
-        this.onInstanceCapabilityEvent = unsupported;
+        this.createOnInstanceEvent = () => Event.None;
+        this.createOnInstanceCapabilityEvent = (capabilityId) => createInstanceCapabilityEventMultiplexer([], Event.None, Event.None, capabilityId, () => Event.None);
         this.createDetachedTerminal = unsupported;
         this.onDidChangeSelection = Event.None;
         this.detachedXterms = [];
@@ -2388,8 +2387,8 @@ registerSingleton(IInteractiveDocumentService, class InteractiveDocumentService
     }
 }, 1 );
 registerSingleton(IActiveLanguagePackService, class ActiveLanguagePackService {
-    getExtensionIdProvidingCurrentLocale() {
-        return Promise.resolve(undefined);
+    async getExtensionIdProvidingCurrentLocale() {
+        return getExtensionIdProvidingCurrentLocale();
     }
 }, 0 );
 registerSingleton(IRemoteUserDataProfilesService, class RemoteUserDataProfilesService {

package/override/vs/platform/userDataSync/common/extensionsSync.js

@@ -0,0 +1,4 @@
+export { LocalExtensionsProvider, parseExtensions, stringify } from '../../../../../vscode/src/vs/platform/userDataSync/common/extensionsSync.js';
+class ExtensionsSynchroniser {}
+class AbstractExtensionsInitializer {}
+export { AbstractExtensionsInitializer, ExtensionsSynchroniser };

package/override/vs/platform/userDataSync/common/globalStateSync.js

@@ -0,0 +1,5 @@
+export { LocalGlobalStateProvider, stringify } from '../../../../../vscode/src/vs/platform/userDataSync/common/globalStateSync.js';
+class GlobalStateSynchroniser {}
+class UserDataSyncStoreTypeSynchronizer {}
+class GlobalStateInitializer {}
+export { GlobalStateInitializer, GlobalStateSynchroniser, UserDataSyncStoreTypeSynchronizer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -94,12 +94,12 @@
     }
   },
   "dependencies": {
-    "@codingame/monaco-vscode-files-service-override": "4.0.0",
-    "@codingame/monaco-vscode-quickaccess-service-override": "4.0.0",
-    "@codingame/monaco-vscode-extensions-service-override": "4.0.0",
-    "@codingame/monaco-vscode-environment-service-override": "4.0.0",
-    "@codingame/monaco-vscode-layout-service-override": "4.0.0",
-    "@codingame/monaco-vscode-host-service-override": "4.0.0",
-    "@codingame/monaco-vscode-base-service-override": "4.0.0"
+    "@codingame/monaco-vscode-extensions-service-override": "4.1.0",
+    "@codingame/monaco-vscode-files-service-override": "4.1.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "4.1.0",
+    "@codingame/monaco-vscode-environment-service-override": "4.1.0",
+    "@codingame/monaco-vscode-layout-service-override": "4.1.0",
+    "@codingame/monaco-vscode-host-service-override": "4.1.0",
+    "@codingame/monaco-vscode-base-service-override": "4.1.0"
   }
 }

package/services.d.ts

@@ -73,6 +73,8 @@ export { IRemoteAuthorityResolverService } from './vscode/src/vs/platform/remote
 export { IRemoteSocketFactoryService } from './vscode/src/vs/platform/remote/common/remoteSocketFactoryService.js';
 export { IFilesConfigurationService } from './vscode/src/vs/workbench/services/filesConfiguration/common/filesConfigurationService.js';
 export { ILabelService } from './vscode/src/vs/platform/label/common/label.js';
+export { ILanguagePackService } from './vscode/src/vs/platform/languagePacks/common/languagePacks.js';
+export { ILocaleService } from './vscode/src/vs/workbench/services/localization/common/locale.js';
 export { IActivityService, IBadge } from './vscode/src/vs/workbench/services/activity/common/activity.js';
 export { IHoverService } from './vscode/src/vs/platform/hover/browser/hover.js';
 export { IExplorerService } from './vscode/src/vs/workbench/contrib/files/browser/files.js';

package/services.js

@@ -136,6 +136,8 @@ export { IRemoteSocketFactoryService } from './vscode/src/vs/platform/remote/com
 export { IFilesConfigurationService } from './vscode/src/vs/workbench/services/filesConfiguration/common/filesConfigurationService.js';
 export { ILabelService } from './vscode/src/vs/platform/label/common/label.js';
 export { IWorkbenchLayoutService } from './vscode/src/vs/workbench/services/layout/browser/layoutService.js';
+export { ILanguagePackService } from './vscode/src/vs/platform/languagePacks/common/languagePacks.js';
+export { ILocaleService } from './vscode/src/vs/workbench/services/localization/common/locale.js';
 export { IActivityService } from './vscode/src/vs/workbench/services/activity/common/activity.js';
 export { IHoverService } from './vscode/src/vs/platform/hover/browser/hover.js';
 export { IExplorerService } from './vscode/src/vs/workbench/contrib/files/browser/files.js';

package/vscode/src/vs/base/browser/hash.js

@@ -0,0 +1,15 @@
+import { VSBuffer } from '../common/buffer.js';
+import { toHexString, StringSHA1 } from '../common/hash.js';
+async function sha1Hex(str) {
+    if (globalThis?.crypto?.subtle) {
+        const buffer = VSBuffer.fromString(str, { dontUseNodeBuffer: true }).buffer;
+        const hash = await globalThis.crypto.subtle.digest({ name: 'sha-1' }, buffer);
+        return toHexString(hash);
+    }
+    else {
+        const computer = ( new StringSHA1());
+        computer.update(str);
+        return computer.digest();
+    }
+}
+export { sha1Hex };

package/vscode/src/vs/base/browser/ui/icons/iconSelectBox.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".icon-select-box>.icon-select-box-container{height:100%}.icon-select-box .icon-select-icons-container{height:100%;outline:0!important}.icon-select-box .icon-select-icons-container>.icon-container{align-items:center;border-radius:5px;cursor:pointer;display:inline-flex;font-size:20px;justify-content:center}.icon-select-box .icon-select-icons-container>.icon-container.focused{background-color:var(--vscode-quickInputList-focusBackground);color:var(--vscode-quickInputList-focusForeground)}.icon-select-box .icon-select-icons-container>.icon-container:hover:not(.focused){background-color:var(--vscode-toolbar-hoverBackground);color:var(--vscode-list-hoverForeground)}.icon-select-box .icon-select-id-container .icon-select-id-label{height:24px;opacity:.8;padding:10px}.icon-select-box .icon-select-id-container .icon-select-id-label .highlight{color:var(--vscode-list-highlightForeground);font-weight:700}";
+n(css,{});
+export { css, css as default };

package/vscode/src/vs/base/browser/ui/icons/iconSelectBox.js

@@ -0,0 +1,246 @@
+import './iconSelectBox.css.js';
+import { $, append, clearNode, addDisposableListener, EventType } from '../../dom.js';
+import { alert } from '../aria/aria.js';
+import { InputBox } from '../inputbox/inputBox.js';
+import { DomScrollableElement } from '../scrollbar/scrollableElement.js';
+import { Emitter } from '../../../common/event.js';
+import { Disposable, MutableDisposable, DisposableStore } from '../../../common/lifecycle.js';
+import { ThemeIcon } from '../../../common/themables.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { HighlightedLabel } from '../highlightedlabel/highlightedLabel.js';
+class IconSelectBox extends Disposable {
+    static { this.InstanceCount = 0; }
+    constructor(options) {
+        super();
+        this.options = options;
+        this.domId = `icon_select_box_id_${++IconSelectBox.InstanceCount}`;
+        this._onDidSelect = this._register(( new Emitter()));
+        this.onDidSelect = this._onDidSelect.event;
+        this.renderedIcons = [];
+        this.focusedItemIndex = 0;
+        this.numberOfElementsPerRow = 1;
+        this.iconContainerWidth = 36;
+        this.iconContainerHeight = 36;
+        this.domNode = $('.icon-select-box');
+        this._register(this.create());
+    }
+    create() {
+        const disposables = ( new DisposableStore());
+        const iconSelectBoxContainer = append(this.domNode, $('.icon-select-box-container'));
+        iconSelectBoxContainer.style.margin = '10px 15px';
+        const iconSelectInputContainer = append(iconSelectBoxContainer, $('.icon-select-input-container'));
+        iconSelectInputContainer.style.paddingBottom = '10px';
+        this.inputBox = disposables.add(( new InputBox(iconSelectInputContainer, undefined, {
+            placeholder: ( localizeWithPath(
+                'vs/base/browser/ui/icons/iconSelectBox',
+                'iconSelect.placeholder',
+                "Search icons"
+            )),
+            inputBoxStyles: this.options.inputBoxStyles,
+        })));
+        const iconsContainer = this.iconsContainer = $('.icon-select-icons-container', { id: `${this.domId}_icons` });
+        iconsContainer.role = 'listbox';
+        iconsContainer.tabIndex = 0;
+        this.scrollableElement = disposables.add(( new DomScrollableElement(iconsContainer, {
+            useShadows: false,
+            horizontal: 2 ,
+        })));
+        append(iconSelectBoxContainer, this.scrollableElement.getDomNode());
+        if (this.options.showIconInfo) {
+            this.iconIdElement = this._register(( new HighlightedLabel(
+                append(append(iconSelectBoxContainer, $('.icon-select-id-container')), $('.icon-select-id-label'))
+            )));
+        }
+        const iconsDisposables = disposables.add(( new MutableDisposable()));
+        iconsDisposables.value = this.renderIcons(this.options.icons, [], iconsContainer);
+        this.scrollableElement.scanDomNode();
+        disposables.add(this.inputBox.onDidChange(value => {
+            const icons = [], matches = [];
+            for (const icon of this.options.icons) {
+                const match = this.matchesContiguous(value, icon.id);
+                if (match) {
+                    icons.push(icon);
+                    matches.push(match);
+                }
+            }
+            if (icons.length) {
+                iconsDisposables.value = this.renderIcons(icons, matches, iconsContainer);
+                this.scrollableElement?.scanDomNode();
+            }
+        }));
+        this.inputBox.inputElement.role = 'combobox';
+        this.inputBox.inputElement.ariaHasPopup = 'menu';
+        this.inputBox.inputElement.ariaAutoComplete = 'list';
+        this.inputBox.inputElement.ariaExpanded = 'true';
+        this.inputBox.inputElement.setAttribute('aria-controls', iconsContainer.id);
+        return disposables;
+    }
+    renderIcons(icons, matches, container) {
+        const disposables = ( new DisposableStore());
+        clearNode(container);
+        const focusedIcon = this.renderedIcons[this.focusedItemIndex]?.icon;
+        let focusedIconIndex = 0;
+        const renderedIcons = [];
+        if (icons.length) {
+            for (let index = 0; index < icons.length; index++) {
+                const icon = icons[index];
+                const iconContainer = append(container, $('.icon-container', { id: `${this.domId}_icons_${index}` }));
+                iconContainer.style.width = `${this.iconContainerWidth}px`;
+                iconContainer.style.height = `${this.iconContainerHeight}px`;
+                iconContainer.title = icon.id;
+                iconContainer.role = 'button';
+                iconContainer.setAttribute('aria-setsize', `${icons.length}`);
+                iconContainer.setAttribute('aria-posinset', `${index + 1}`);
+                append(iconContainer, $(ThemeIcon.asCSSSelector(icon)));
+                renderedIcons.push({ icon, element: iconContainer, highlightMatches: matches[index] });
+                disposables.add(addDisposableListener(iconContainer, EventType.CLICK, (e) => {
+                    e.stopPropagation();
+                    this.setSelection(index);
+                }));
+                if (icon === focusedIcon) {
+                    focusedIconIndex = index;
+                }
+            }
+        }
+        else {
+            const noResults = ( localizeWithPath(
+                'vs/base/browser/ui/icons/iconSelectBox',
+                'iconSelect.noResults',
+                "No results"
+            ));
+            append(container, $('.icon-no-results', undefined, noResults));
+            alert(noResults);
+        }
+        this.renderedIcons.splice(0, this.renderedIcons.length, ...renderedIcons);
+        this.focusIcon(focusedIconIndex);
+        return disposables;
+    }
+    focusIcon(index) {
+        const existing = this.renderedIcons[this.focusedItemIndex];
+        if (existing) {
+            existing.element.classList.remove('focused');
+        }
+        this.focusedItemIndex = index;
+        const renderedItem = this.renderedIcons[index];
+        if (renderedItem) {
+            renderedItem.element.classList.add('focused');
+        }
+        if (this.inputBox) {
+            if (renderedItem) {
+                this.inputBox.inputElement.setAttribute('aria-activedescendant', renderedItem.element.id);
+            }
+            else {
+                this.inputBox.inputElement.removeAttribute('aria-activedescendant');
+            }
+        }
+        if (this.iconIdElement) {
+            if (renderedItem) {
+                this.iconIdElement.set(renderedItem.icon.id, renderedItem.highlightMatches);
+            }
+            else {
+                this.iconIdElement.set('');
+            }
+        }
+        this.reveal(index);
+    }
+    reveal(index) {
+        if (!this.scrollableElement) {
+            return;
+        }
+        if (index < 0 || index >= this.renderedIcons.length) {
+            return;
+        }
+        const element = this.renderedIcons[index].element;
+        if (!element) {
+            return;
+        }
+        const { height } = this.scrollableElement.getScrollDimensions();
+        const { scrollTop } = this.scrollableElement.getScrollPosition();
+        if (element.offsetTop + this.iconContainerHeight > scrollTop + height) {
+            this.scrollableElement.setScrollPosition({ scrollTop: element.offsetTop + this.iconContainerHeight - height });
+        }
+        else if (element.offsetTop < scrollTop) {
+            this.scrollableElement.setScrollPosition({ scrollTop: element.offsetTop });
+        }
+    }
+    matchesContiguous(word, wordToMatchAgainst) {
+        const matchIndex = wordToMatchAgainst.toLowerCase().indexOf(word.toLowerCase());
+        if (matchIndex !== -1) {
+            return [{ start: matchIndex, end: matchIndex + word.length }];
+        }
+        return null;
+    }
+    layout(dimension) {
+        this.domNode.style.width = `${dimension.width}px`;
+        this.domNode.style.height = `${dimension.height}px`;
+        const iconsContainerWidth = dimension.width - 30;
+        this.numberOfElementsPerRow = Math.floor(iconsContainerWidth / this.iconContainerWidth);
+        if (this.numberOfElementsPerRow === 0) {
+            throw new Error('Insufficient width');
+        }
+        const extraSpace = iconsContainerWidth % this.iconContainerWidth;
+        const iconElementMargin = Math.floor(extraSpace / this.numberOfElementsPerRow);
+        for (const { element } of this.renderedIcons) {
+            element.style.marginRight = `${iconElementMargin}px`;
+        }
+        const containerPadding = extraSpace % this.numberOfElementsPerRow;
+        if (this.iconsContainer) {
+            this.iconsContainer.style.paddingLeft = `${Math.floor(containerPadding / 2)}px`;
+            this.iconsContainer.style.paddingRight = `${Math.ceil(containerPadding / 2)}px`;
+        }
+        if (this.scrollableElement) {
+            this.scrollableElement.getDomNode().style.height = `${this.iconIdElement ? dimension.height - 80 : dimension.height - 40}px`;
+            this.scrollableElement.scanDomNode();
+        }
+    }
+    getFocus() {
+        return [this.focusedItemIndex];
+    }
+    setSelection(index) {
+        if (index < 0 || index >= this.renderedIcons.length) {
+            throw new Error(`Invalid index ${index}`);
+        }
+        this.focusIcon(index);
+        this._onDidSelect.fire(this.renderedIcons[index].icon);
+    }
+    clearInput() {
+        if (this.inputBox) {
+            this.inputBox.value = '';
+        }
+    }
+    focus() {
+        this.inputBox?.focus();
+        this.focusIcon(0);
+    }
+    focusNext() {
+        this.focusIcon((this.focusedItemIndex + 1) % this.renderedIcons.length);
+    }
+    focusPrevious() {
+        this.focusIcon((this.focusedItemIndex - 1 + this.renderedIcons.length) % this.renderedIcons.length);
+    }
+    focusNextRow() {
+        let nextRowIndex = this.focusedItemIndex + this.numberOfElementsPerRow;
+        if (nextRowIndex >= this.renderedIcons.length) {
+            nextRowIndex = (nextRowIndex + 1) % this.numberOfElementsPerRow;
+            nextRowIndex = nextRowIndex >= this.renderedIcons.length ? 0 : nextRowIndex;
+        }
+        this.focusIcon(nextRowIndex);
+    }
+    focusPreviousRow() {
+        let previousRowIndex = this.focusedItemIndex - this.numberOfElementsPerRow;
+        if (previousRowIndex < 0) {
+            const numberOfRows = Math.floor(this.renderedIcons.length / this.numberOfElementsPerRow);
+            previousRowIndex = this.focusedItemIndex + (this.numberOfElementsPerRow * numberOfRows) - 1;
+            previousRowIndex = previousRowIndex < 0
+                ? this.renderedIcons.length - 1
+                : previousRowIndex >= this.renderedIcons.length
+                    ? previousRowIndex - this.numberOfElementsPerRow
+                    : previousRowIndex;
+        }
+        this.focusIcon(previousRowIndex);
+    }
+    getFocusedIcon() {
+        return this.renderedIcons[this.focusedItemIndex].icon;
+    }
+}
+export { IconSelectBox };

package/vscode/src/vs/base/common/amd.js

@@ -0,0 +1,101 @@
+class LoaderStats {
+    static get() {
+        const amdLoadScript = ( new Map());
+        const amdInvokeFactory = ( new Map());
+        const nodeRequire = ( new Map());
+        const nodeEval = ( new Map());
+        function mark(map, stat) {
+            if (( map.has(stat.detail))) {
+                return;
+            }
+            map.set(stat.detail, -stat.timestamp);
+        }
+        function diff(map, stat) {
+            const duration = map.get(stat.detail);
+            if (!duration) {
+                return;
+            }
+            if (duration >= 0) {
+                return;
+            }
+            map.set(stat.detail, duration + stat.timestamp);
+        }
+        let stats = [];
+        if (typeof require === 'function' && typeof require.getStats === 'function') {
+            stats = require.getStats().slice(0).sort((a, b) => a.timestamp - b.timestamp);
+        }
+        for (const stat of stats) {
+            switch (stat.type) {
+                case 10 :
+                    mark(amdLoadScript, stat);
+                    break;
+                case 11 :
+                case 12 :
+                    diff(amdLoadScript, stat);
+                    break;
+                case 21 :
+                    mark(amdInvokeFactory, stat);
+                    break;
+                case 22 :
+                    diff(amdInvokeFactory, stat);
+                    break;
+                case 33 :
+                    mark(nodeRequire, stat);
+                    break;
+                case 34 :
+                    diff(nodeRequire, stat);
+                    break;
+                case 31 :
+                    mark(nodeEval, stat);
+                    break;
+                case 32 :
+                    diff(nodeEval, stat);
+                    break;
+            }
+        }
+        let nodeRequireTotal = 0;
+        nodeRequire.forEach(value => nodeRequireTotal += value);
+        function to2dArray(map) {
+            const res = [];
+            map.forEach((value, index) => res.push([index, value]));
+            return res;
+        }
+        return {
+            amdLoad: to2dArray(amdLoadScript),
+            amdInvoke: to2dArray(amdInvokeFactory),
+            nodeRequire: to2dArray(nodeRequire),
+            nodeEval: to2dArray(nodeEval),
+            nodeRequireTotal
+        };
+    }
+    static toMarkdownTable(header, rows) {
+        let result = '';
+        const lengths = [];
+        header.forEach((cell, ci) => {
+            lengths[ci] = cell.length;
+        });
+        rows.forEach(row => {
+            row.forEach((cell, ci) => {
+                if (typeof cell === 'undefined') {
+                    cell = row[ci] = '-';
+                }
+                const len = ( cell.toString()).length;
+                lengths[ci] = Math.max(len, lengths[ci]);
+            });
+        });
+        header.forEach((cell, ci) => { result += `| ${cell + ' '.repeat(lengths[ci] - ( cell.toString()).length)} `; });
+        result += '|\n';
+        header.forEach((_cell, ci) => { result += `| ${'-'.repeat(lengths[ci])} `; });
+        result += '|\n';
+        rows.forEach(row => {
+            row.forEach((cell, ci) => {
+                if (typeof cell !== 'undefined') {
+                    result += `| ${cell + ' '.repeat(lengths[ci] - ( cell.toString()).length)} `;
+                }
+            });
+            result += '|\n';
+        });
+        return result;
+    }
+}
+export { LoaderStats };

package/vscode/src/vs/base/common/console.js

@@ -0,0 +1,60 @@
+import './path.js';
+import './platform.js';
+function parse(entry) {
+    const args = [];
+    let stack;
+    try {
+        const parsedArguments = JSON.parse(entry.arguments);
+        const stackArgument = parsedArguments[parsedArguments.length - 1];
+        if (stackArgument && stackArgument.__$stack) {
+            parsedArguments.pop();
+            stack = stackArgument.__$stack;
+        }
+        args.push(...parsedArguments);
+    }
+    catch (error) {
+        args.push('Unable to log remote console arguments', entry.arguments);
+    }
+    return { args, stack };
+}
+function findFirstFrame(stack) {
+    if (!stack) {
+        return stack;
+    }
+    const newlineIndex = stack.indexOf('\n');
+    if (newlineIndex === -1) {
+        return stack;
+    }
+    return stack.substring(0, newlineIndex);
+}
+function log(entry, label) {
+    const { args, stack } = parse(entry);
+    const isOneStringArg = typeof args[0] === 'string' && args.length === 1;
+    let topFrame = findFirstFrame(stack);
+    if (topFrame) {
+        topFrame = `(${topFrame.trim()})`;
+    }
+    let consoleArgs = [];
+    if (typeof args[0] === 'string') {
+        if (topFrame && isOneStringArg) {
+            consoleArgs = [`%c[${label}] %c${args[0]} %c${topFrame}`, color('blue'), color(''), color('grey')];
+        }
+        else {
+            consoleArgs = [`%c[${label}] %c${args[0]}`, color('blue'), color(''), ...args.slice(1)];
+        }
+    }
+    else {
+        consoleArgs = [`%c[${label}]%`, color('blue'), ...args];
+    }
+    if (topFrame && !isOneStringArg) {
+        consoleArgs.push(topFrame);
+    }
+    if (typeof console[entry.severity] !== 'function') {
+        throw new Error('Unknown console method');
+    }
+    console[entry.severity].apply(console, consoleArgs);
+}
+function color(color) {
+    return `color: ${color}`;
+}
+export { log, parse };

package/vscode/src/vs/base/common/objects.js

@@ -1,4 +1,4 @@
-import { isUndefinedOrNull, isObject, isTypedArray } from './types.js';
+import { isObject, isUndefinedOrNull, isTypedArray } from './types.js';
 function deepClone(obj) {
     if (!obj || typeof obj !== 'object') {
         return obj;