jiebi/CodeConvo huggingface dataset:
return this.doReadFileStream(provider, resource, options, token); } <del> private async doReadFileStream(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability | IFileSystemProviderWithFileReadStreamCapability | IFileSystemProviderWithFileReadCapability, resource: URI, options?: IReadFileOptions & IReadFileStreamOptions & { preferUnbuffered?: boolean }, token?: CancellationToken): Promise<IFileStreamContent> { </del> <ins> private async doReadFileStream(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithOpenReadWriteCloseCapability | IFileSystemProviderWithFileReadStreamCapability, resource: URI, options?: IReadFileOptions & IReadFileStreamOptions & { preferUnbuffered?: boolean }, token?: CancellationToken): Promise<IFileStreamContent> { </ins> // install a cancellation token that gets cancelled // when any error occurs. this allows us to resolve
return stream; } <del> private readFileUnbuffered(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithFileAtomicReadCapability | IFileSystemProviderWithFileReadCapability, resource: URI, options?: IReadFileOptions & IReadFileStreamOptions): VSBufferReadableStream { </del> <ins> private readFileUnbuffered(provider: IFileSystemProviderWithFileReadWriteCapability | IFileSystemProviderWithFileAtomicReadCapability, resource: URI, options?: IReadFileOptions & IReadFileStreamOptions): VSBufferReadableStream { </ins> const stream = newWriteableStream<VSBuffer>(data => VSBuffer.concat(data)); // Read the file into the stream async but do not wait for
return !!(provider.capabilities & FileSystemProviderCapabilities.FileReadStream); } <del> export interface IFileSystemProviderWithFileReadCapability extends IFileSystemProvider { readFile(resource: URI): Promise<Uint8Array>; } export function hasFileReadCapability(provider: IFileSystemProvider): provider is IFileSystemProviderWithFileReadCapability { return !!(provider.capabilities & FileSystemProviderCapabilities.Readonly); } </del> export interface IFileSystemProviderWithFileAtomicReadCapability extends IFileSystemProvider { readFile(resource: URI, opts?: IFileAtomicReadOptions): Promise<Uint8Array>; }
import { Disposable, IDisposable } from 'vs/base/common/lifecycle'; import { Event } from 'vs/base/common/event'; import { URI } from 'vs/base/common/uri'; <del> import { FilePermission, FileSystemProviderCapabilities, FileSystemProviderErrorCode, FileType, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadCapability, IStat, IWatchOptions } from 'vs/platform/files/common/files'; </del> <ins> import { FilePermission, FileSystemProviderCapabilities, FileSystemProviderErrorCode, FileType, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IStat, IWatchOptions } from 'vs/platform/files/common/files'; </ins> import { ChangeType, decodeEditSessionFileContent, EDIT_SESSIONS_SCHEME, IEditSessionsStorageService } from 'vs/workbench/contrib/editSessions/common/editSessions'; <ins> import { NotSupportedError } from 'vs/base/common/errors'; </ins> <del> export class EditSessionsFileSystemProvider implements IFileSystemProviderWithFileReadCapability { </del> <ins> export class EditSessionsFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability { </ins> static readonly SCHEMA = EDIT_SESSIONS_SCHEME;
@IEditSessionsStorageService private editSessionsStorageService: IEditSessionsStorageService, ) { } <del> readonly capabilities: FileSystemProviderCapabilities = FileSystemProviderCapabilities.Readonly; </del> <ins> readonly capabilities: FileSystemProviderCapabilities = FileSystemProviderCapabilities.Readonly + FileSystemProviderCapabilities.FileReadWrite; </ins> async readFile(resource: URI): Promise<Uint8Array> { const match = /(?<ref>[^/]+)/(?<folderName>[^/]+)/(?<filePath>.*)/.exec(resource.path.substring(1));
const outputElement = (prev.firstChild as HTMLElement | null); if (outputElement && outputElement.getAttribute('output-mime-type') === outputInfo.mime) { // same stream <del> const text = outputInfo.text(); const element = document.createElement('span'); </del> <ins> // find child with same id const existing = outputElement.querySelector(`[output-item-id="${outputInfo.id}"]`) as HTMLElement | null; if (existing) { clearContainer(existing); } const text = outputInfo.text(); const element = existing ?? document.createElement('span'); element.classList.add('output-stream'); element.setAttribute('output-item-id', outputInfo.id); </ins> insertOutput(outputInfo.id, [text], ctx.settings.lineLimit, ctx.settings.outputScrolling, element); outputElement.appendChild(element); return;
// Move .zshrc into $ZDOTDIR as the way to activate the script const zdotdir = path.join(os.tmpdir(), `${os.userInfo().username}-vscode-zsh`); envMixin['ZDOTDIR'] = zdotdir; <del> const userZdotdir = env?.ZDOTDIR ?? os.homedir(); </del> <ins> const userZdotdir = env?.ZDOTDIR ?? os.homedir() ?? `~`; </ins> envMixin['USER_ZDOTDIR'] = userZdotdir; const filesToCopy: IShellIntegrationConfigInjection['filesToCopy'] = []; filesToCopy.push({
return URL.createObjectURL(blob); } <del> const result = new URL(scriptPath); COI.addSearchParam(result.searchParams, true, true); result.hash = label; return result.href; </del> <ins> const start = scriptPath.lastIndexOf('?'); const end = scriptPath.lastIndexOf('#', start); const params = start > 0 ? new URLSearchParams(scriptPath.substring(start + 1, ~end ? end : undefined)) : new URLSearchParams(); COI.addSearchParam(params, true, true); const search = params.toString(); if (!search) { return `${scriptPath}#${label}`; } else { return `${scriptPath}?${params.toString()}#${label}`; } </ins> } // ESM-comment-end
private hideTwistiesOfChildlessElements: boolean = false; private shouldRenderIndentGuides: boolean = false; <del> private renderedIndentGuides = new SetMap<ITreeNode<T, TFilterData>, HTMLDivElement>(); </del> private activeIndentNodes = new Set<ITreeNode<T, TFilterData>>(); private indentGuidesDisposable: IDisposable = Disposable.None;
private modelProvider: () => ITreeModel<T, TFilterData, TRef>, onDidChangeCollapseState: Event<ICollapseStateChangeEvent<T, TFilterData>>, private activeNodes: Collection<ITreeNode<T, TFilterData>>, <ins> private renderedIndentGuides: SetMap<ITreeNode<T, TFilterData>, HTMLDivElement>, </ins> options: ITreeRendererOptions = {} ) { this.templateId = renderer.templateId;
const onDidChangeCollapseStateRelay = new Relay<ICollapseStateChangeEvent<T, TFilterData>>(); const onDidChangeActiveNodes = new Relay<ITreeNode<T, TFilterData>[]>(); const activeNodes = this.disposables.add(new EventCollection(onDidChangeActiveNodes.event)); <del> this.renderers = renderers.map(r => new TreeRenderer<T, TFilterData, TRef, any>(r, () => this.model, onDidChangeCollapseStateRelay.event, activeNodes, _options)); </del> <ins> const renderedIndentGuides = new SetMap<ITreeNode<T, TFilterData>, HTMLDivElement>(); this.renderers = renderers.map(r => new TreeRenderer<T, TFilterData, TRef, any>(r, () => this.model, onDidChangeCollapseStateRelay.event, activeNodes, renderedIndentGuides, _options)); </ins> for (const r of this.renderers) { this.disposables.add(r); }
[ localize('openExternalDialogButtonRetry', "Try again"), localize('openExternalDialogButtonInstall', "Install {0}", this.productService.nameLong), <del> localize('openExternalDialogButtonContinue', "Continue here") </del> <ins> localize('openExternalDialogButtonCancel', "Cancel") </ins> ], { cancelId: 2, <del> detail: localize('openExternalDialogDetail', "We tried opening {0} on your computer.", this.productService.nameLong) </del> <ins> detail: localize( 'openExternalDialogDetail.v2', "We launched {0} on your computer.nnIf {1} did not launch, try again or install it below.", this.productService.nameLong, this.productService.nameLong, ) </ins> }, );
const repositoryPath = await window.withProgress( opts, <del> (progress, token) => this.git.clone(url!, { parentPath: parentPath!, progress, recursive: options.recursive }, token) </del> <ins> (progress, token) => this.git.clone(url!, { parentPath: parentPath!, progress, recursive: options.recursive, ref: options.ref }, token) </ins> ); <del> const refToCheckoutAfterClone = options.ref; if (refToCheckoutAfterClone !== undefined) { await window.withProgress( { location: ProgressLocation.Notification, title: localize('checking out ref', "Checking out ref '{0}'...", options.ref) }, async () => { await this.model.openRepository(repositoryPath); const repository = this.model.getRepository(repositoryPath); await repository?.checkout(refToCheckoutAfterClone); }); } </del> const config = workspace.getConfiguration('git'); const openAfterClone = config.get<'always' | 'alwaysNewWindow' | 'whenNoFolderOpen' | 'prompt'>('openAfterClone');
color: var(--vscode-descriptionForeground); } <ins> .monaco-workbench .merge-editor .code-view.result > .header > .description { display: inline; flex-shrink: 1; } .monaco-workbench .merge-editor .code-view.result > .header > .detail { flex-shrink: 0; } .monaco-workbench .merge-editor .code-view.result > .header > .toolbar { flex-shrink: 0; } </ins> .monaco-workbench .merge-editor .code-view > .header > span.description .codicon { font-size: 14px; color: var(--vscode-descriptionForeground);
/* Right aligned */ <del> .monaco-workbench .activitybar.right > .content :not(.monaco-menu) > .monaco-action-bar .action-label:not(.codicon) { </del> <ins> .monaco-workbench .activitybar.right > .content :not(.monaco-menu) > .monaco-action-bar .action-label:not(.codicon):not(.profile-activity-item) { </ins> margin-left: 0; padding: 0 48px 0 0; background-position: calc(100% - 9px) center;
flex-shrink: 0; } <ins> .monaco-workbench .part > .title > .title-actions .start-debug-action-item .codicon-debug-start { width: 18px; height: 21px; padding-left: 2px; } </ins> .monaco-workbench .monaco-action-bar .start-debug-action-item .configuration .monaco-select-box { border: none; margin-top: 0px;
return; } <del> if (matchesScheme(link, Schemas.command)) { const ret = /command:workbench.action.openLargeOutput?(.*)/.exec(link); if (ret && ret.length === 2) { const outputId = ret[1]; this.openerService.open(CellUri.generateCellOutputUri(this.documentUri, outputId)); return; } console.warn('Command links are deprecated and will be removed, use message passing instead: https://github.com/microsoft/vscode/issues/123601'); } if (matchesScheme(link, Schemas.command)) { if (this.workspaceTrustManagementService.isWorkspaceTrusted()) { this.openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: true }); } else { console.warn('Command links are disabled in untrusted workspaces'); } } else if (matchesSomeScheme(link, Schemas.vscodeNotebookCell, Schemas.http, Schemas.https, Schemas.mailto)) { this.openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: true }); </del> <ins> if (matchesSomeScheme(link, Schemas.vscodeNotebookCell, Schemas.http, Schemas.https, Schemas.mailto)) { this.openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: false }); </ins> } }));
} case 'clicked-link': { let linkToOpen: URI | string | undefined; if (matchesScheme(data.href, Schemas.command)) { <del> const ret = /command:workbench.action.openLargeOutput?(.*)/.exec(data.href); if (ret && ret.length === 2) { const outputId = ret[1]; const group = this.editorGroupService.activeGroup; if (group) { if (group.activeEditor) { group.pinEditor(group.activeEditor); </del> <ins> // We allow a very limited set of commands const uri = URI.parse(data.href); switch (uri.path) { case 'workbench.action.openLargeOutput': { const outputId = uri.query; const group = this.editorGroupService.activeGroup; if (group) { if (group.activeEditor) { group.pinEditor(group.activeEditor); } </ins> } <del> } this.openerService.open(CellUri.generateCellOutputUri(this.documentUri, outputId)); return; </del> <ins> this.openerService.open(CellUri.generateCellOutputUri(this.documentUri, outputId)); return; } case 'github-issues.authNow': case 'workbench.extensions.search': case 'workbench.action.openSettings': { this.openerService.open(data.href, { fromUserGesture: true, allowCommands: true, fromWorkspace: true }); return; } </ins> } <ins> return; </ins> } <del> if (matchesSomeScheme(data.href, Schemas.http, Schemas.https, Schemas.mailto, Schemas.command, Schemas.vscodeNotebookCell, Schemas.vscodeNotebook)) { </del> <ins> if (matchesSomeScheme(data.href, Schemas.http, Schemas.https, Schemas.mailto, Schemas.vscodeNotebookCell, Schemas.vscodeNotebook)) { </ins> linkToOpen = data.href; } else if (!/^[w-]+:/.test(data.href)) { const fragmentStartIndex = data.href.lastIndexOf('#');
import { StartupProfiler } from './startupProfiler'; import { StartupTimings } from './startupTimings'; import { RendererProfiling } from 'vs/workbench/contrib/performance/electron-sandbox/rendererAutoProfiler'; <ins> import { IConfigurationRegistry, Extensions as ConfigExt } from 'vs/platform/configuration/common/configurationRegistry'; import { localize } from 'vs/nls'; </ins> Registry.as<IWorkbenchContributionsRegistry>(Extensions.Workbench).registerWorkbenchContribution(
StartupTimings, LifecyclePhase.Eventually ); <ins> Registry.as<IConfigurationRegistry>(ConfigExt.Configuration).registerConfiguration({ id: 'application', order: 100, type: 'object', 'properties': { 'application.experimental.rendererProfiling': { type: 'boolean', default: false, markdownDescription: localize('experimental.rendererProfiling', "When enabled slow renderers are automatically profiled") } } }); </ins>
import { timeout } from 'vs/base/common/async'; import { generateUuid } from 'vs/base/common/uuid'; <ins> import { IConfigurationService } from 'vs/platform/configuration/common/configuration'; </ins> import { IEnvironmentService } from 'vs/platform/environment/common/environment'; import { ILogService } from 'vs/platform/log/common/log'; import { INativeHostService } from 'vs/platform/native/electron-sandbox/native';
return; } <ins> if (!configService.getValue('application.experimental.rendererProfiling')) { logService.debug(`[perf] SLOW task detected (${maxDuration}ms) but renderer profiling is disabled via 'application.experimental.rendererProfiling'`); return; } </ins> const sessionId = generateUuid(); // start heartbeat monitoring logService.warn(`[perf] Renderer reported VERY LONG TASK (${maxDuration}ms), starting profiling session '${sessionId}'`);
totalTime: sample.totalTime, percentage: sample.percentage, functionName: sample.location, <del> callstack: sample.caller.map(c => `${c.percentage}|${c.location}`).join('<'), extensionId: '' </del> <ins> callstack: sample.caller.map(c => c.location).join('<'), extensionId: '<<renderer>>' </ins> }; this._telemetryService.publicLog2<TelemetrySampleData, TelemetrySampleDataClassification>('prof.freeze.sample', data);
], "action": "comment", "addLabel": "info-needed", <del> "comment": "Thanks for reporting this issue! Unfortunately, it's hard for us to understand what issue you're seeing. Please help us out by providing a screen recording showing exactly what isn't working as expected. While we can work with most standard formats, `.gif` files are preferred as they are displayed inline on GitHub. You may find https://gifcap.dev helpful as a browser-based gif recording tool.nnIf the issue depends on keyboard input, you can help us by enabling screencast mode for the recording (`Developer: Toggle Screencast Mode` in the command palette).nnHappy coding!" </del> <ins> "comment": "Thanks for reporting this issue! Unfortunately, it's hard for us to understand what issue you're seeing. Please help us out by providing a screen recording showing exactly what isn't working as expected. While we can work with most standard formats, `.gif` files are preferred as they are displayed inline on GitHub. You may find https://gifcap.dev helpful as a browser-based gif recording tool.nnIf the issue depends on keyboard input, you can help us by enabling screencast mode for the recording (`Developer: Toggle Screencast Mode` in the command palette). Lastly, please attach this file via the GitHub web interface as emailed responses will strip files out from the issue.nnHappy coding!" </ins> }, { "__comment__": "Allows folks on the team to label issues by commenting: `label My-Label` ",
"git": { "name": "chromium", "repositoryUrl": "https://chromium.googlesource.com/chromium/src", <del> "commitHash": "16e28102fdf876ce6d136674ba66343ede07441f" </del> <ins> "commitHash": "a8a8309404d39efa9c624d7aee0e27562721e522" </ins> } }, "licenseDetail": [
"cssnano": "^4.1.11", "debounce": "^1.0.0", "deemon": "^1.8.0", <del> "electron": "19.1.8", </del> <ins> "electron": "19.1.9", </ins> "eslint": "8.7.0", "eslint-plugin-header": "3.1.1", "eslint-plugin-jsdoc": "^39.3.2",
resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.207.tgz#9c3310ebace2952903d05dcaba8abe3a4ed44c01" integrity sha512-piH7MJDJp4rJCduWbVvmUd59AUne1AFBJ8JaRQvk0KzNTSUnZrVXHCZc+eg+CGE4OujkcLJznhGKD6tuAshj5Q== <del> electron@19.1.8: version "19.1.8" resolved "https://registry.yarnpkg.com/electron/-/electron-19.1.8.tgz#3ce19c270ca86d05bbf0df5ceeaea2d23edc7083" integrity sha512-UfPQdFjgKI0xCm1V5sV3iAVOs0kCwAE91xWzV5tI7ij14yOkxTdXp9BqTzFaSbQYLYxn6q1BUUe1nlzjJjzAnw== </del> <ins> electron@19.1.9: version "19.1.9" resolved "https://registry.yarnpkg.com/electron/-/electron-19.1.9.tgz#01995eea4014f7cdb2f616f5f3492d4ed6f5e4f0" integrity sha512-XT5LkTzIHB+ZtD3dTmNnKjVBWrDWReCKt9G1uAFLz6uJMEVcIUiYO+fph5pLXETiBw/QZBx8egduMEfIccLx+g== </ins> dependencies: "@electron/get" "^1.14.1" "@types/node" "^16.11.26"
*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> .monaco-editor .contentWidgets .codicon-light-bulb, .monaco-editor .contentWidgets .codicon-lightbulb-autofix { </del> <ins> .monaco-editor .lightBulbWidget { </ins> display: flex; align-items: center; justify-content: center; } <del> .monaco-editor .contentWidgets .codicon-light-bulb:hover, .monaco-editor .contentWidgets .codicon-lightbulb-autofix:hover { </del> <ins> .monaco-editor .lightBulbWidget:hover{ </ins> cursor: pointer; } <ins> .monaco-editor .lightBulbWidget.codicon-light-bulb { color: var(--vscode-editorLightBulb-foreground); } .monaco-editor .lightBulbWidget.codicon-lightbulb-autofix { color: var(--vscode-editorLightBulbAutoFix-foreground, var(--vscode-editorLightBulb-foreground)); } .monaco-editor .lightBulbWidget:before { position: relative; z-index: 2; } .monaco-editor .lightBulbWidget:after { position: absolute; top: 0; left: 0; content: ''; display: block; width: 100%; height: 100%; opacity: 0.3; background-color: var(--vscode-editor-background); z-index: 1; } </ins>
import type { CodeActionSet, CodeActionTrigger } from 'vs/editor/contrib/codeAction/common/types'; import * as nls from 'vs/nls'; import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; <del> import { editorBackground, editorLightBulbAutoFixForeground, editorLightBulbForeground } from 'vs/platform/theme/common/colorRegistry'; import { IColorTheme, ICssStyleCollector, registerThemingParticipant } from 'vs/platform/theme/common/themeService'; </del> namespace LightBulbState {
private static readonly _posPref = [ContentWidgetPositionPreference.EXACT]; <del> private readonly _domNode: HTMLDivElement; </del> <ins> private readonly _domNode: HTMLElement; </ins> private readonly _onClick = this._register(new Emitter<{ x: number; y: number; actions: CodeActionSet; trigger: CodeActionTrigger }>()); public readonly onClick = this._onClick.event;
@IKeybindingService keybindingService: IKeybindingService ) { super(); <del> this._domNode = document.createElement('div'); this._domNode.className = Codicon.lightBulb.classNames; </del> <ins> this._domNode = dom.$('div.lightBulbWidget'); </ins> this._register(Gesture.ignoreTarget(this._domNode)); this._editor.addContentWidget(this);
this._domNode.title = value; } } <del> registerThemingParticipant((theme: IColorTheme, collector: ICssStyleCollector) => { const editorBackgroundColor = theme.getColor(editorBackground)?.transparent(0.7); // Lightbulb Icon const editorLightBulbForegroundColor = theme.getColor(editorLightBulbForeground); if (editorLightBulbForegroundColor) { collector.addRule(` .monaco-editor .contentWidgets ${Codicon.lightBulb.cssSelector} { color: ${editorLightBulbForegroundColor}; background-color: ${editorBackgroundColor}; }`); } // Lightbulb Auto Fix Icon const editorLightBulbAutoFixForegroundColor = theme.getColor(editorLightBulbAutoFixForeground); if (editorLightBulbAutoFixForegroundColor) { collector.addRule(` .monaco-editor .contentWidgets ${Codicon.lightbulbAutofix.cssSelector} { color: ${editorLightBulbAutoFixForegroundColor}; background-color: ${editorBackgroundColor}; }`); } }); </del>
# This makes sure the model is included in the package !@vscode/vscode-languagedetection/model/** <ins> # Ensure only the required telemetry pieces are loaded in web to reduce bundle size @microsoft/1ds-core-js/** @microsoft/1ds-post-js/** @microsoft/applicationinsights-core-js/** @microsoft/applicationinsights-shims/** !@microsoft/1ds-core-js/dist/ms.core.min.js !@microsoft/1ds-post-js/dist/ms.post.min.js !@microsoft/applicationinsights-core-js/browser/applicationinsights-core-js.min.js !@microsoft/applicationinsights-shims/dist/umd/applicationinsights-shims.min.js </ins>
"pickerGroup.foreground": "#75715E", "input.background": "#414339", "inputOption.activeBorder": "#75715E", <del> "focusBorder": "#75715E", </del> <ins> "focusBorder": "#99947c", </ins> "editorWidget.background": "#1e1f1c", "debugToolBar.background": "#1e1f1c", "diffEditor.insertedTextBackground": "#4b661680", // middle of #272822 and #a6e22e
const handleTitleClickOrTouch = (e: MouseEvent | GestureEvent): void => { let target: HTMLElement; if (e instanceof MouseEvent) { <del> if (e.button !== 0 || (isMacintosh && e.ctrlKey)) { return undefined; // only for left mouse click (ctrl+click on macos is right-click) </del> <ins> if (e.button !== 0 /* middle/right mouse button */ || (isMacintosh && e.ctrlKey /* macOS context menu */)) { return undefined; </ins> } target = e.target as HTMLElement;
const handleClickOrTouch = (e: MouseEvent | GestureEvent, preserveFocus: boolean): void => { tab.blur(); // prevent flicker of focus outline on tab until editor got focus <del> if (e instanceof MouseEvent && e.button !== 0) { </del> <ins> if (e instanceof MouseEvent && (e.button !== 0 /* middle/right mouse button */ || (isMacintosh && e.ctrlKey /* macOS context menu */))) { </ins> if (e.button === 1) { e.preventDefault(); // required to prevent auto-scrolling (https://github.com/microsoft/vscode/issues/16690) } <del> return undefined; // only for left mouse click </del> <ins> return undefined; </ins> } if (this.originatesFromTabActionBar(e)) {
maxHeight = Math.min(maxHeight, this._hover.containerDomNode.clientHeight); this._hover.containerDomNode.style.maxHeight = `${maxHeight}px`; <ins> if (this._hover.contentsDomNode.clientHeight > maxHeight) { this._hover.contentsDomNode.style.height = `${maxHeight}px`; } if (this._hover.contentsDomNode.clientHeight < this._hover.contentsDomNode.scrollHeight) { // Add padding for a vertical scrollbar const extraRightPadding = `${this._hover.scrollbar.options.verticalScrollbarSize}px`; if (this._hover.contentsDomNode.style.paddingRight !== extraRightPadding) { this._hover.contentsDomNode.style.paddingRight = extraRightPadding; } } </ins> } private setHoverPointerPosition(target: TargetRect): void {
EditorPaneDescriptor.create( GettingStartedPage, GettingStartedPage.ID, <del> localize('getStarted', "Get Started") </del> <ins> localize('welcome', "Welcome") </ins> ), [ new SyncDescriptor(GettingStartedInput) ] ); <del> const category = { value: localize('getStarted', "Get Started"), original: 'Get Started' }; </del> <ins> const category = { value: localize('welcome', "Welcome"), original: 'Welcome' }; </ins> registerAction2(class extends Action2 { constructor() {