jiebi/CodeConvo huggingface dataset:
import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry'; import { Registry } from 'vs/platform/registry/common/platform'; import { InlineChatController } from 'vs/workbench/contrib/inlineChat/browser/inlineChatController'; <del> import { CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_LAST } from 'vs/workbench/contrib/inlineChat/common/inlineChat'; </del> import { INotebookActionContext, INotebookCellActionContext, NotebookAction, NotebookCellAction, NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT, findTargetCellEditor } from 'vs/workbench/contrib/notebook/browser/controller/coreActions'; import { CellEditState } from 'vs/workbench/contrib/notebook/browser/notebookBrowser'; import { CellKind, NOTEBOOK_EDITOR_CURSOR_BOUNDARY } from 'vs/workbench/contrib/notebook/common/notebookCommon';
weight: KeybindingWeight.WorkbenchContrib }, { <del> when: ContextKeyExpr.and( NOTEBOOK_EDITOR_FOCUSED, CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate(), ContextKeyExpr.equals('config.notebook.navigation.allowNavigateToSurroundingCells', true), ContextKeyExpr.and( ContextKeyExpr.has(InputFocusedContextKey), NOTEBOOK_EDITOR_CURSOR_BOUNDARY.notEqualsTo('top'), NOTEBOOK_EDITOR_CURSOR_BOUNDARY.notEqualsTo('none'), ), CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_LAST, EditorContextKeys.isEmbeddedDiffEditor.negate() ), primary: KeyCode.DownArrow, weight: KeybindingWeight.EditorCore }, { when: ContextKeyExpr.and( NOTEBOOK_EDITOR_FOCUSED, CONTEXT_ACCESSIBILITY_MODE_ENABLED.negate(), ContextKeyExpr.equals('config.notebook.navigation.allowNavigateToSurroundingCells', true), ContextKeyExpr.and( NOTEBOOK_CELL_TYPE.isEqualTo('markup'), NOTEBOOK_CELL_MARKDOWN_EDIT_MODE.isEqualTo(false), NOTEBOOK_CURSOR_NAVIGATION_MODE), CTX_INLINE_CHAT_FOCUSED, CTX_INLINE_CHAT_INNER_CURSOR_LAST, EditorContextKeys.isEmbeddedDiffEditor.negate() ), primary: KeyCode.DownArrow, weight: KeybindingWeight.EditorCore }, { </del> when: NOTEBOOK_EDITOR_FOCUSED, primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.PageDown, mac: { primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.PageDown, },
id: AccessibilityCommandId.AccessibleViewAcceptInlineCompletion, precondition: ContextKeyExpr.and(accessibleViewIsShown, ContextKeyExpr.equals(accessibleViewCurrentProviderId.key, AccessibleViewProviderId.InlineCompletions)), keybinding: { <del> primary: KeyMod.CtrlCmd | KeyCode.Enter, mac: { primary: KeyMod.WinCtrl | KeyCode.Enter }, </del> <ins> primary: KeyMod.CtrlCmd | KeyCode.Slash, mac: { primary: KeyMod.WinCtrl | KeyCode.Slash }, </ins> weight: KeybindingWeight.WorkbenchContrib }, icon: Codicon.check,
return undefined; } <ins> export async function getDocumentFormattingEditsWithSelectedProvider( workerService: IEditorWorkerService, languageFeaturesService: ILanguageFeaturesService, editorOrModel: ITextModel | IActiveCodeEditor, mode: FormattingMode, token: CancellationToken, ): Promise<TextEdit[] | undefined> { const model = isCodeEditor(editorOrModel) ? editorOrModel.getModel() : editorOrModel; const provider = getRealAndSyntheticDocumentFormattersOrdered(languageFeaturesService.documentFormattingEditProvider, languageFeaturesService.documentRangeFormattingEditProvider, model); const selected = await FormattingConflicts.select(provider, model, mode, FormattingKind.File); if (selected) { const rawEdits = await Promise.resolve(selected.provideDocumentFormattingEdits(model, model.getOptions(), token)).catch(onUnexpectedExternalError); return await workerService.computeMoreMinimalEdits(model.uri, rawEdits); } return undefined; } </ins> export function getOnTypeFormattingEdits( workerService: IEditorWorkerService, languageFeaturesService: ILanguageFeaturesService,
import { IEditorWorkerService } from 'vs/editor/common/services/editorWorker'; import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures'; import { ITextModelService } from 'vs/editor/common/services/resolverService'; <del> import { FormattingMode, formatDocumentWithSelectedProvider, getDocumentFormattingEditsUntilResult } from 'vs/editor/contrib/format/browser/format'; </del> <ins> import { FormattingMode, formatDocumentWithSelectedProvider, getDocumentFormattingEditsWithSelectedProvider } from 'vs/editor/contrib/format/browser/format'; </ins> import { Action2, MenuId, registerAction2 } from 'vs/platform/actions/common/actions'; import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey'; import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
const model = ref.object.textEditorModel; <del> const formatEdits = await getDocumentFormattingEditsUntilResult( </del> <ins> const formatEdits = await getDocumentFormattingEditsWithSelectedProvider( </ins> editorWorkerService, languageFeaturesService, model, <del> model.getOptions(), </del> <ins> FormattingMode.Explicit, </ins> CancellationToken.None );
const model = ref.object.textEditorModel; <del> // todo: eventually support cancellation. potential leak if cell deleted mid execution const formatEdits = await getDocumentFormattingEditsUntilResult( </del> <ins> const formatEdits = await getDocumentFormattingEditsWithSelectedProvider( </ins> this.editorWorkerService, this.languageFeaturesService, model, <del> model.getOptions(), </del> <ins> FormattingMode.Silent, </ins> CancellationToken.None );
import { ITextModelService } from 'vs/editor/common/services/resolverService'; import { ApplyCodeActionReason, applyCodeAction, getCodeActions } from 'vs/editor/contrib/codeAction/browser/codeAction'; import { CodeActionKind, CodeActionTriggerSource } from 'vs/editor/contrib/codeAction/common/types'; <del> import { getDocumentFormattingEditsUntilResult } from 'vs/editor/contrib/format/browser/format'; </del> <ins> import { FormattingMode, getDocumentFormattingEditsWithSelectedProvider } from 'vs/editor/contrib/format/browser/format'; </ins> import { SnippetController2 } from 'vs/editor/contrib/snippet/browser/snippetController2'; import { localize } from 'vs/nls'; import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
const model = ref.object.textEditorModel; <del> const formatEdits = await getDocumentFormattingEditsUntilResult( </del> <ins> const formatEdits = await getDocumentFormattingEditsWithSelectedProvider( </ins> this.editorWorkerService, this.languageFeaturesService, model, <del> model.getOptions(), </del> <ins> FormattingMode.Silent, </ins> token );
opts.selection = previousSelection; const editor = await window.showTextDocument(document, opts); // This should always be defined but just in case <del> if (previousVisibleRange) { editor.revealRange(previousVisibleRange); </del> <ins> if (previousVisibleRanges && previousVisibleRanges.length > 0) { let rangeToReveal = previousVisibleRanges[0]; if (previousSelection && previousVisibleRanges.length > 1) { // In case of multiple visible ranges, find the one that intersects with the selection rangeToReveal = previousVisibleRanges.find(r => r.intersection(previousSelection)) ?? rangeToReveal; } editor.revealRange(rangeToReveal); </ins> } } }
<meta charset="UTF-8"> <meta http-equiv="Content-Security-Policy" <del> content="default-src 'none'; script-src 'sha256-QA1gXilHYAUFCvp7MpjgcmyBCFzSKV0SpiecMU8aUVc=' 'self'; frame-src 'self'; style-src 'unsafe-inline';"> </del> <ins> content="default-src 'none'; script-src 'sha256-Ne5nVg2ZDLxLh1eqzYd1sGbOz022xlokwv+X6+HR1hw=' 'self'; frame-src 'self'; style-src 'unsafe-inline';"> </ins> <!-- Disable pinch zooming --> <meta name="viewport"
) { } showHover(options: IHoverDelegateOptions, focus?: boolean): IHoverWidget | undefined { <ins> // Only show the hover hint if the content is of a decent size const showHoverHint = ( options.content instanceof HTMLElement ? options.content.textContent ?? '' : typeof options.content === 'string' ? options.content : options.content.value ).length > 20; </ins> return this.hoverService.showHover({ ...options, persistence: { hideOnKeyDown: false, }, appearance: { <del> showHoverHint: true, </del> <ins> showHoverHint, </ins> skipFadeInAnimation: true, }, }, focus);
'editor.inlineSuggest.showToolbar': { type: 'string', default: defaults.showToolbar, <del> enum: ['always', 'onHover'], </del> <ins> enum: ['always', 'onHover', 'never'], </ins> enumDescriptions: [ nls.localize('inlineSuggest.showToolbar.always', "Show the inline suggestion toolbar whenever an inline suggestion is shown."), nls.localize('inlineSuggest.showToolbar.onHover', "Show the inline suggestion toolbar when hovering over an inline suggestion."), <ins> nls.localize('inlineSuggest.showToolbar.never', "Never show the inline suggestion toolbar."), </ins> ], description: nls.localize('inlineSuggest.showToolbar', "Controls when to show the inline suggestion toolbar."), },
return { enabled: boolean(input.enabled, this.defaultValue.enabled), mode: stringSet(input.mode, this.defaultValue.mode, ['prefix', 'subword', 'subwordSmart']), <del> showToolbar: stringSet(input.showToolbar, this.defaultValue.showToolbar, ['always', 'onHover']), </del> <ins> showToolbar: stringSet(input.showToolbar, this.defaultValue.showToolbar, ['always', 'onHover', 'never']), </ins> suppressSuggestions: boolean(input.suppressSuggestions, this.defaultValue.suppressSuggestions), keepOnBlur: boolean(input.keepOnBlur, this.defaultValue.keepOnBlur), };
} computeSync(anchor: HoverAnchor, lineDecorations: IModelDecoration[]): InlineCompletionsHover[] { <del> if (this._editor.getOption(EditorOption.inlineSuggest).showToolbar === 'always') { </del> <ins> if (this._editor.getOption(EditorOption.inlineSuggest).showToolbar !== 'onHover') { </ins> return []; }
const lastUnchangedRegions = this._unchangedRegions.get(); const lastUnchangedRegionsOrigRanges = lastUnchangedRegions.originalDecorationIds .map(id => model.original.getDecorationRange(id)) <del> .filter(r => !!r) .map(r => LineRange.fromRange(r!)); </del> <ins> .map(r => r ? LineRange.fromRange(r) : undefined); </ins> const lastUnchangedRegionsModRanges = lastUnchangedRegions.modifiedDecorationIds .map(id => model.modified.getDecorationRange(id)) <del> .filter(r => !!r) .map(r => LineRange.fromRange(r!)); </del> <ins> .map(r => r ? LineRange.fromRange(r) : undefined); </ins> const originalDecorationIds = model.original.deltaDecorations( lastUnchangedRegions.originalDecorationIds,
for (const r of newUnchangedRegions) { for (let i = 0; i < lastUnchangedRegions.regions.length; i++) { <del> if (r.originalUnchangedRange.intersectsStrict(lastUnchangedRegionsOrigRanges[i]) && r.modifiedUnchangedRange.intersectsStrict(lastUnchangedRegionsModRanges[i])) { </del> <ins> if (lastUnchangedRegionsOrigRanges[i] && r.originalUnchangedRange.intersectsStrict(lastUnchangedRegionsOrigRanges[i]!) && lastUnchangedRegionsModRanges[i] && r.modifiedUnchangedRange.intersectsStrict(lastUnchangedRegionsModRanges[i]!)) { </ins> r.setHiddenModifiedRange(lastUnchangedRegions.regions[i].getHiddenModifiedRange(undefined), tx); break; }
import { MarkdownString } from 'vs/base/common/htmlContent'; import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding'; import { LOCALIZED_START_INLINE_CHAT_STRING } from 'vs/workbench/contrib/inlineChat/browser/inlineChatActions'; <del> import { IBreakpoint, IDebugService } from 'vs/workbench/contrib/debug/common/debug'; </del> <ins> import { IBreakpoint, IDebugService, IDebugSession } from 'vs/workbench/contrib/debug/common/debug'; </ins> import { IPreferencesService } from 'vs/workbench/services/preferences/common/preferences'; import { URI } from 'vs/base/common/uri';
private _gutterDecorationID: string | undefined; private _inlineChatKeybinding: string | undefined; private _hasInlineChatSession: boolean = false; <ins> private _hasActiveDebugSession: boolean = false; private _debugSessions: Set<IDebugSession> = new Set(); </ins> private readonly _localToDispose = new DisposableStore(); private readonly _gutterDecorationOpaque: IModelDecorationOptions; private readonly _gutterDecorationTransparent: IModelDecorationOptions;
this._onEnablementOrModelChanged(); } })); <ins> this._register(this._debugService.onWillNewSession((session) => { this._debugSessions.add(session); if (!this._hasActiveDebugSession) { this._hasActiveDebugSession = true; this._onEnablementOrModelChanged(); } })); this._register(this._debugService.onDidEndSession((session) => { this._debugSessions.delete(session); if (this._debugSessions.size === 0) { this._hasActiveDebugSession = false; this._onEnablementOrModelChanged(); } })); </ins> this._register(this._inlineChatService.onDidChangeProviders(() => this._onEnablementOrModelChanged())); this._register(this._editor.onDidChangeModel(() => this._onEnablementOrModelChanged())); this._register(this._keybindingService.onDidUpdateKeybindings(() => {
private _onEnablementOrModelChanged(): void { // cancels the scheduler, removes editor listeners / removes decoration this._localToDispose.clear(); <del> if (!this._editor.hasModel() || this._hasInlineChatSession || this._showGutterIconMode() === ShowGutterIcon.Never || !this._hasProvider()) { </del> <ins> if (!this._editor.hasModel() || this._hasActiveDebugSession || this._hasInlineChatSession || this._showGutterIconMode() === ShowGutterIcon.Never || !this._hasProvider()) { </ins> return; } const editor = this._editor;
*--------------------------------------------------------------------------------------------*/ import { LazyStatefulPromise, raceTimeout } from 'vs/base/common/async'; <ins> import { onUnexpectedError } from 'vs/base/common/errors'; </ins> import { IDisposable, DisposableStore, toDisposable } from 'vs/base/common/lifecycle'; import { deepClone } from 'vs/base/common/objects'; <del> import { isObject } from 'vs/base/common/types'; </del> <ins> import { isDefined, isObject } from 'vs/base/common/types'; </ins> import { URI } from 'vs/base/common/uri'; import { ConstLazyPromise, IDocumentDiffItem, IMultiDiffEditorModel } from 'vs/editor/browser/widget/multiDiffEditorWidget/model'; import { MultiDiffEditorViewModel } from 'vs/editor/browser/widget/multiDiffEditorWidget/multiDiffEditorViewModel';
import { EditorInput } from 'vs/workbench/common/editor/editorInput'; import { ILanguageSupport } from 'vs/workbench/services/textfile/common/textfiles'; <ins> /* hot-reload:patch-prototype-methods */ </ins> export class MultiDiffEditorInput extends EditorInput implements ILanguageSupport { static readonly ID: string = 'workbench.input.multiDiffEditor';
private async _createModel(): Promise<IMultiDiffEditorModel & IDisposable> { const store = new DisposableStore(); <del> const rs = await Promise.all(this.resources.map(async r => ({ originalRef: r.original ? store.add(await this._textModelService.createModelReference(r.original)) : undefined, originalModel: !r.original ? store.add(this._modelService.createModel('', null)) : undefined, modifiedRef: r.modified ? store.add(await this._textModelService.createModelReference(r.modified)) : undefined, modifiedModel: !r.modified ? store.add(this._modelService.createModel('', null)) : undefined, title: r.resource.fsPath, }))); </del> <ins> const rs = (await Promise.all(this.resources.map(async r => { try { return { originalRef: r.original ? store.add(await this._textModelService.createModelReference(r.original)) : undefined, originalModel: !r.original ? store.add(this._modelService.createModel('', null)) : undefined, modifiedRef: r.modified ? store.add(await this._textModelService.createModelReference(r.modified)) : undefined, modifiedModel: !r.modified ? store.add(this._modelService.createModel('', null)) : undefined, title: r.resource.fsPath, }; } catch (e) { // e.g. "File seems to be binary and cannot be opened as text" console.error(e); onUnexpectedError(e); return undefined; } }))).filter(isDefined); </ins> const textResourceConfigurationService = this._textResourceConfigurationService;
this.logService.trace(`Extension signature verification details for ${extension.identifier.id} ${extension.version}:n${sigError.output}`); } if (verificationStatus === ExtensionSignaturetErrorCode.PackageIsInvalidZip || verificationStatus === ExtensionSignaturetErrorCode.SignatureArchiveIsInvalidZip) { <ins> try { // Delete the downloaded vsix before throwing the error await this.delete(location); } catch (error) { this.logService.error(error); } </ins> throw new ExtensionManagementError(CorruptZipMessage, ExtensionManagementErrorCode.CorruptZip); } } finally {
this._coordinatedRenderings.splice(renderingIndex, 1); if (this._coordinatedRenderings.length === 0) { <del> // There are no more renderings to coordinate => cancel animation frame if (this._animationFrameRunner !== null) { this._animationFrameRunner.dispose(); this._animationFrameRunner = null; </del> <ins> // There are no more renderings to coordinate => cancel animation frames for (const [_, disposable] of this._animationFrameRunners) { disposable.dispose(); </ins> } <ins> this._animationFrameRunners.clear(); </ins> } } }; } private _scheduleRender(window: CodeWindow): void { <del> if (this._animationFrameRunner === null) { </del> <ins> if (!this._animationFrameRunners.has(window)) { </ins> const runner = () => { <del> this._animationFrameRunner = null; </del> <ins> this._animationFrameRunners.delete(window); </ins> this._onRenderScheduled(); }; <del> this._animationFrameRunner = dom.runAtThisOrScheduleAtNextAnimationFrame(window, runner, 100); </del> <ins> this._animationFrameRunners.set(window, dom.runAtThisOrScheduleAtNextAnimationFrame(window, runner, 100)); </ins> } }
const ignoreImportantExtensionRecommendationStorageKey = 'extensionsAssistant/importantRecommendationsIgnore'; const donotShowWorkspaceRecommendationsStorageKey = 'extensionsAssistant/workspaceRecommendationsIgnore'; <del> const choiceNever = localize('neverShowAgain', "Don't Show Again"); </del> type RecommendationsNotificationActions = { onDidInstallRecommendedExtensions(extensions: IExtension[]): void;
searchValue = source === RecommendationSource.WORKSPACE ? '@recommended' : extensions.map(extensionId => `@id:${extensionId.identifier.id}`).join(' '); } <ins> const donotShowAgainLabel = source === RecommendationSource.WORKSPACE ? localize('donotShowAgain', "Don't Show Again for this Repository") : extensions.length > 1 ? localize('donotShowAgainExtension', "Don't Show Again for these Extensions") : localize('donotShowAgainExtensionSingle', "Don't Show Again for this Extension"); </ins> return raceCancellablePromises([ <del> this._registerP(this.showRecommendationsNotification(extensions, message, searchValue, source, recommendationsNotificationActions)), </del> <ins> this._registerP(this.showRecommendationsNotification(extensions, message, searchValue, donotShowAgainLabel, source, recommendationsNotificationActions)), </ins> this._registerP(this.waitUntilRecommendationsAreInstalled(extensions)) ]); } <del> private showRecommendationsNotification(extensions: IExtension[], message: string, searchValue: string, source: RecommendationSource, </del> <ins> private showRecommendationsNotification(extensions: IExtension[], message: string, searchValue: string, donotShowAgainLabel: string, source: RecommendationSource, </ins> { onDidInstallRecommendedExtensions, onDidShowRecommendedExtensions, onDidCancelRecommendedExtensions, onDidNeverShowRecommendedExtensionsAgain }: RecommendationsNotificationActions): CancelablePromise<RecommendationsNotificationResult> { return createCancelablePromise<RecommendationsNotificationResult>(async token => { let accepted = false;
applyStatusBarStyle(); applyIconStyle(); } <ins> if (this._completionModel && (e.hasChanged(EditorOption.fontInfo) || e.hasChanged(EditorOption.suggestFontSize) || e.hasChanged(EditorOption.suggestLineHeight))) { this._list.splice(0, this._list.length, this._completionModel.items); } </ins> })); this._ctxSuggestWidgetVisible = SuggestContext.Visible.bindTo(_contextKeyService);
readMore.style.width = lineHeightPx; }; <del> configureFont(); disposables.add(this._editor.onDidChangeConfiguration(e => { if (e.hasChanged(EditorOption.fontInfo) || e.hasChanged(EditorOption.suggestFontSize) || e.hasChanged(EditorOption.suggestLineHeight)) { configureFont(); } })); return { root, left, right, icon, colorspan, iconLabel, iconContainer, parametersLabel, qualifierLabel, detailsLabel, readMore, disposables }; </del> <ins> return { root, left, right, icon, colorspan, iconLabel, iconContainer, parametersLabel, qualifierLabel, detailsLabel, readMore, disposables, configureFont }; </ins> } renderElement(element: CompletionItem, index: number, data: ISuggestionTemplateData): void { <ins> data.configureFont(); </ins> const { completion } = element; data.root.id = getAriaId(index); data.colorspan.style.backgroundColor = '';
// Group editors count context groupEditorsCountContext.set(this.count); <del> })); </del> <ins> }; this._register(this.onDidModelChange(e => updateGroupContextKeys(e))); </ins> // Track the active editor and update context key that reflects // the dirty state of this editor <del> this._register(this.onDidActiveEditorChange(() => { observeActiveEditor(); })); </del> <ins> this._register(this.onDidActiveEditorChange(() => observeActiveEditor())); </ins> // Update context keys on startup observeActiveEditor(); <ins> updateGroupContextKeys({ kind: GroupModelChangeKind.EDITOR_ACTIVE }); updateGroupContextKeys({ kind: GroupModelChangeKind.GROUP_LOCKED }); </ins> } private registerContainerListeners(): void {
localize('voice.keywordActivation.inlineChat', "Keyword activation is enabled and listening for 'Hey Code' to start a voice chat session in the active editor."), localize('voice.keywordActivation.chatInContext', "Keyword activation is enabled and listening for 'Hey Code' to start a voice chat session in the active editor or view depending on keyboard focus.") ], <del> 'description': localize('voice.keywordActivation', "Controls whether the phrase 'Hey Code' should be speech recognized to start a voice chat session."), </del> <ins> 'description': localize('voice.keywordActivation', "Controls whether the keyword phrase 'Hey Code' is recognized to start a voice chat session. Enabling this will start recording from the microphone but the audio is processed locally and never sent to a server."), </ins> 'default': 'off', 'tags': ['accessibility', 'FeatureInsight'] }
"input.background": "#313131", "input.border": "#3C3C3C", "input.foreground": "#CCCCCC", <del> "input.placeholderForeground": "#818181", </del> <ins> "input.placeholderForeground": "#989898", </ins> "inputOption.activeBackground": "#2489DB82", "inputOption.activeBorder": "#2488DB", "keybindingLabel.foreground": "#CCCCCC",
"input.background": "#FFFFFF", "input.border": "#CECECE", "input.foreground": "#3B3B3B", <del> "input.placeholderForeground": "#868686", </del> <ins> "input.placeholderForeground": "#767676", </ins> "inputOption.activeBackground": "#BED6ED", "inputOption.activeBorder": "#005FB8", "inputOption.activeForeground": "#000000",
return -1; } <ins> if (result !== 0) { return result; } </ins> if (a.multiFileDiffEditorModifiedUri && b.multiFileDiffEditorModifiedUri) { result = comparePaths(a.multiFileDiffEditorModifiedUri.fsPath, b.multiFileDiffEditorModifiedUri.fsPath, true); } else if (a.multiFileDiffEditorModifiedUri) {
} else if (b.multiFileDiffEditorModifiedUri) { return -1; } <ins> if (result !== 0) { return result; } </ins> if (a.multiDiffEditorOriginalUri && b.multiDiffEditorOriginalUri) { result = comparePaths(a.multiDiffEditorOriginalUri.fsPath, b.multiDiffEditorOriginalUri.fsPath, true); } else if (a.multiDiffEditorOriginalUri) {