jiebi/CodeConvo huggingface dataset:
end set -e VSCODE_PATH_PREFIX <del> # Apply EnvironmentVariableCollections if needed if test -n "$VSCODE_ENV_REPLACE" set ITEMS (string split : $VSCODE_ENV_REPLACE) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" (echo -e "$split[2]") </del> <ins> set -g __vsc_applied_env_vars 0 function __vsc_apply_env_vars if test $__vsc_applied_env_vars -eq 1; return </ins> end <del> set -e VSCODE_ENV_REPLACE end if test -n "$VSCODE_ENV_PREPEND" set ITEMS (string split : $VSCODE_ENV_PREPEND) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" (echo -e "$split[2]")"$$split[1]" # avoid -p as it adds a space </del> <ins> set -l __vsc_applied_env_vars 1 # Apply EnvironmentVariableCollections if needed if test -n "$VSCODE_ENV_REPLACE" set ITEMS (string split : $VSCODE_ENV_REPLACE) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" (echo -e "$split[2]") end set -e VSCODE_ENV_REPLACE </ins> end <del> set -e VSCODE_ENV_PREPEND end if test -n "$VSCODE_ENV_APPEND" set ITEMS (string split : $VSCODE_ENV_APPEND) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" "$$split[1]"(echo -e "$split[2]") # avoid -a as it adds a space </del> <ins> if test -n "$VSCODE_ENV_PREPEND" set ITEMS (string split : $VSCODE_ENV_PREPEND) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" (echo -e "$split[2]")"$$split[1]" # avoid -p as it adds a space end set -e VSCODE_ENV_PREPEND end if test -n "$VSCODE_ENV_APPEND" set ITEMS (string split : $VSCODE_ENV_APPEND) for B in $ITEMS set split (string split = $B) set -gx "$split[1]" "$$split[1]"(echo -e "$split[2]") # avoid -a as it adds a space end set -e VSCODE_ENV_APPEND </ins> end <del> set -e VSCODE_ENV_APPEND </del> end # Handle the shell integration nonce
group: 'navigation/execute', when: ContextKeyExpr.and( executeNotebookCondition, <del> ContextKeyExpr.or(NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated(), NOTEBOOK_HAS_SOMETHING_RUNNING.toNegated()), </del> <ins> ContextKeyExpr.or( NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated(), NOTEBOOK_HAS_SOMETHING_RUNNING.toNegated(), ), ContextKeyExpr.and(NOTEBOOK_HAS_SOMETHING_RUNNING, NOTEBOOK_INTERRUPTIBLE_KERNEL.toNegated())?.negate(), </ins> ContextKeyExpr.equals('config.notebook.globalToolbar', true) ) }
return await this.run(Operation.Ignore, async () => { const ignoreFile = `${this.repository.root}${path.sep}.gitignore`; const textToAppend = files <del> .map(uri => relativePath(this.repository.root, uri.fsPath).replace(//g, '/')) </del> <ins> .map(uri => relativePath(this.repository.root, uri.fsPath) .replace(/|[/g, match => match === '' ? '/' : `${match}`)) </ins> .join('n'); const document = await new Promise(c => fs.exists(ignoreFile, c))
"./vs/*" ] }, <ins> "target": "es2022", "useDefineForClassFields": false, </ins> "lib": [ <del> "ES2016", "ES2017.Object", "ES2017.String", "ES2017.Intl", "ES2017.TypedArrays", "ES2018.AsyncIterable", "ES2018.AsyncGenerator", "ES2018.Promise", "ES2018.Regexp", "ES2018.Intl", "ES2019.Array", "ES2019.Object", "ES2019.String", "ES2019.Symbol", "ES2020.BigInt", "ES2020.Promise", "ES2020.String", "ES2020.Symbol.WellKnown", "ES2020.Intl", "ES2021.Promise", "ES2021.String", "ES2021.WeakRef", </del> <ins> "ES2022", </ins> "DOM", "DOM.Iterable", "WebWorker.ImportScripts"
export abstract class ErrorHandler { <del> static { </del> <ins> static async installEarlyHandler(accessor: ServicesAccessor): Promise<void> { </ins> // increase number of stack frames (from 10, https://github.com/v8/v8/wiki/Stack-Trace-API) Error.stackTraceLimit = 100; <del> } static async installEarlyHandler(accessor: ServicesAccessor): Promise<void> { </del> // does NOT dependent of extension information, can be installed immediately, and simply forwards // to the log service and main thread errors const logService = accessor.get(ILogService);
private async initialize(): Promise<void> { await this.extensionsScannerService.initializeDefaultProfileExtensions(); <del> await this.onDidChangeProfiles(this.userDataProfilesService.profiles, []); </del> <ins> await this.onDidChangeProfiles(this.userDataProfilesService.profiles); </ins> this.registerListeners(); await this.uninstallExtensionsNotInProfiles(); } private registerListeners(): void { <del> this._register(this.userDataProfilesService.onDidChangeProfiles(e => this.onDidChangeProfiles(e.added, e.removed))); </del> <ins> this._register(this.userDataProfilesService.onDidChangeProfiles(e => this.onDidChangeProfiles(e.added))); </ins> this._register(this.extensionsProfileScannerService.onAddExtensions(e => this.onAddExtensions(e))); this._register(this.extensionsProfileScannerService.onDidAddExtensions(e => this.onDidAddExtensions(e))); this._register(this.extensionsProfileScannerService.onRemoveExtensions(e => this.onRemoveExtensions(e)));
this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e))); } <del> private async onDidChangeProfiles(added: readonly IUserDataProfile[], removed: readonly IUserDataProfile[]): Promise<void> { </del> <ins> private async onDidChangeProfiles(added: readonly IUserDataProfile[]): Promise<void> { </ins> try { <del> await Promise.all(removed.map(profile => { this.extensionsProfileWatchDisposables.deleteAndDispose(profile.id); return this.removeExtensionsFromProfile(profile.extensionsResource); })); </del> if (added.length) { await Promise.all(added.map(profile => { this.extensionsProfileWatchDisposables.set(profile.id, combinedDisposable(
} } <del> private async removeExtensionsFromProfile(removedProfile: URI): Promise<void> { for (const key of [...this.allExtensions.keys()]) { this.removeExtensionWithKey(key, removedProfile); } await this.uninstallExtensionsNotInProfiles(); } </del> private async uninstallExtensionsNotInProfiles(toUninstall?: IExtension[]): Promise<void> { if (!toUninstall) { const installed = await this.extensionManagementService.scanAllUserInstalledExtensions();
this.logService.error(error); } } <del> try { if (this.profiles.length === 1) { await this.fileService.del(this.profilesHome, { recursive: true }); } else { await this.fileService.del(profile.location, { recursive: true }); } } catch (error) { this.logService.error(error); } </del> } async setProfileForWorkspace(workspaceIdentifier: IAnyWorkspaceIdentifier, profileToSet: IUserDataProfile): Promise<void> {
// If HEAD is not published, make sure it is && !repository?.state.HEAD?.upstream ) { <del> const publishBranch = vscode.l10n.t('Publish Branch'); </del> <ins> const publishBranch = vscode.l10n.t('Publish Branch & Copy Link'); </ins> const selection = await vscode.window.showInformationMessage( vscode.l10n.t('The current branch is not published to the remote. Would you like to publish your branch before copying a link?'), { modal: true },
} const uncommittedChanges = [...repository.state.workingTreeChanges, ...repository.state.indexChanges]; <del> if (uncommittedChanges.find((c) => c.uri.toString() === file.toString())) { </del> <ins> if (uncommittedChanges.find((c) => c.uri.toString() === file.toString()) && !repository.state.HEAD?.ahead && !repository.state.HEAD?.behind) { </ins> const commitChanges = vscode.l10n.t('Commit Changes'); const copyAnyway = vscode.l10n.t('Copy Anyway'); const selection = await vscode.window.showWarningMessage(
throw new vscode.CancellationError(); } } else if (repository.state.HEAD?.ahead) { <del> const pushCommits = vscode.l10n.t('Push Commits'); </del> <ins> const pushCommits = vscode.l10n.t('Push Commits & Copy Link'); </ins> const selection = await vscode.window.showInformationMessage( vscode.l10n.t('The current branch has unpublished commits. Would you like to push your commits before copying a link?'), { modal: true },
} await repository.push(); <ins> } else if (repository.state.HEAD?.behind) { const pull = vscode.l10n.t('Pull Changes & Copy Link'); const selection = await vscode.window.showInformationMessage( vscode.l10n.t('The current branch is not up to date. Would you like to pull before copying a link?'), { modal: true }, pull ); if (selection !== pull) { throw new vscode.CancellationError(); } await repository.pull(); </ins> } await repository.status();
if (sessionData) { this._persistedSessions = this.deserializeChats(sessionData); const countsForLog = Object.keys(this._persistedSessions).length; <del> this.trace('constructor', `Restored ${countsForLog} persisted sessions`); </del> <ins> if (countsForLog > 0) { this.trace('constructor', `Restored ${countsForLog} persisted sessions`); } </ins> } else { this._persistedSessions = {}; <del> this.trace('constructor', 'No persisted sessions'); </del> } this._transferred = this.getTransferredSession();
.filter(session => session.requests.length)); allSessions.sort((a, b) => (b.creationDate ?? 0) - (a.creationDate ?? 0)); allSessions = allSessions.slice(0, maxPersistedSessions); <del> this.trace('onWillSaveState', `Persisting ${allSessions.length} sessions`); </del> <ins> if (allSessions.length) { this.trace('onWillSaveState', `Persisting ${allSessions.length} sessions`); } </ins> const serialized = JSON.stringify(allSessions); <del> this.trace('onWillSaveState', `Persisting ${serialized.length} chars`); </del> <ins> if (allSessions.length) { this.trace('onWillSaveState', `Persisting ${serialized.length} chars`); } </ins> this.storageService.store(serializedChatKey, serialized, StorageScope.WORKSPACE, StorageTarget.MACHINE); }
await this.configurationEditing.writeConfiguration(editableConfigurationTarget, { key, value }, { scopes: overrides, ...options }); switch (editableConfigurationTarget) { case EditableConfigurationTarget.USER_LOCAL: <del> if (this.applicationConfiguration && this.configurationRegistry.getConfigurationProperties()[key].scope === ConfigurationScope.APPLICATION) { </del> <ins> if (this.applicationConfiguration && this.configurationRegistry.getConfigurationProperties()[key]?.scope === ConfigurationScope.APPLICATION) { </ins> await this.reloadApplicationConfiguration(); } else { await this.reloadLocalUserConfiguration();
this._logService.debug(`TextAreaSyncAddon#updateCommandAndCursor: no line`); return; } <del> if (!!currentCommand.commandStartX) { </del> <ins> if (currentCommand.commandStartX !== undefined) { </ins> this._currentCommand = commandLine.substring(currentCommand.commandStartX); this._cursorX = buffer.cursorX - currentCommand.commandStartX; } else {
return this._proxy.setTerminalLayoutInfo(args); } async getTerminalLayoutInfo(args: IGetTerminalLayoutInfoArgs): Promise<ITerminalsLayoutInfo | undefined> { <del> return await this._proxy.getTerminalLayoutInfo(args); </del> <ins> // This is optional as we want reconnect requests to go through only if the pty host exists. // Revive is handled specially as reviveTerminalProcesses is guaranteed to be called before // the request for layout info. return this._optionalProxy?.getTerminalLayoutInfo(args); </ins> } async requestDetachInstance(workspaceId: string, instanceId: number): Promise<IProcessDetails | undefined> {
}; } catch (e) { this._logService.warn(`Couldn't get layout info, a terminal was probably disconnected`, e.message); <del> this._logService.info('Reattach to wrong terminal debug info - layout info by id', t); this._logService.info('Reattach to wrong terminal debug info - _revivePtyIdMap', Array.from(this._revivedPtyIdMap.values())); </del> <ins> this._logService.debug('Reattach to wrong terminal debug info - layout info by id', t); this._logService.debug('Reattach to wrong terminal debug info - _revivePtyIdMap', Array.from(this._revivedPtyIdMap.values())); this._logService.debug('Reattach to wrong terminal debug info - _ptys ids', Array.from(this._ptys.keys())); </ins> // this will be filtered out and not reconnected return { terminal: null,
// Revive processes if needed const serializedState = this._storageService.get(TerminalStorageKeys.TerminalBufferState, StorageScope.WORKSPACE); <del> const parsed = this._deserializeTerminalState(serializedState); if (!parsed) { return undefined; } try { // Note that remote terminals do not get their environment re-resolved unlike in local terminals mark('code/terminal/willReviveTerminalProcessesRemote'); await this._remoteTerminalChannel.reviveTerminalProcesses(parsed, Intl.DateTimeFormat().resolvedOptions().locale); mark('code/terminal/didReviveTerminalProcessesRemote'); this._storageService.remove(TerminalStorageKeys.TerminalBufferState, StorageScope.WORKSPACE); // If reviving processes, send the terminal layout info back to the pty host as it // will not have been persisted on application exit const layoutInfo = this._storageService.get(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); if (layoutInfo) { mark('code/terminal/willSetTerminalLayoutInfoRemote'); await this._remoteTerminalChannel.setTerminalLayoutInfo(JSON.parse(layoutInfo)); mark('code/terminal/didSetTerminalLayoutInfoRemote'); this._storageService.remove(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); </del> <ins> const reviveBufferState = this._deserializeTerminalState(serializedState); if (reviveBufferState && reviveBufferState.length > 0) { try { // Note that remote terminals do not get their environment re-resolved unlike in local terminals mark('code/terminal/willReviveTerminalProcessesRemote'); await this._remoteTerminalChannel.reviveTerminalProcesses(reviveBufferState, Intl.DateTimeFormat().resolvedOptions().locale); mark('code/terminal/didReviveTerminalProcessesRemote'); this._storageService.remove(TerminalStorageKeys.TerminalBufferState, StorageScope.WORKSPACE); // If reviving processes, send the terminal layout info back to the pty host as it // will not have been persisted on application exit const layoutInfo = this._storageService.get(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); if (layoutInfo) { mark('code/terminal/willSetTerminalLayoutInfoRemote'); await this._remoteTerminalChannel.setTerminalLayoutInfo(JSON.parse(layoutInfo)); mark('code/terminal/didSetTerminalLayoutInfoRemote'); this._storageService.remove(TerminalStorageKeys.TerminalLayoutInfo, StorageScope.WORKSPACE); } } catch (e: unknown) { this._logService.warn('RemoteTerminalBackend#getTerminalLayoutInfo Error', e && typeof e === 'object' && 'message' in e ? e.message : e); </ins> } <del> } catch (e: unknown) { this._logService.warn('RemoteTerminalBackend#getTerminalLayoutInfo Error', e && typeof e === 'object' && 'message' in e ? e.message : e); </del> } return this._remoteTerminalChannel.getTerminalLayoutInfo();
} } <ins> private storeTreeViewState() { this.storageService.store(ExplorerView.TREE_VIEW_STATE_STORAGE_KEY, JSON.stringify(this.tree.getViewState()), StorageScope.WORKSPACE, StorageTarget.MACHINE); } </ins> private setContextKeys(stat: ExplorerItem | null | undefined): void { const folders = this.contextService.getWorkspace().folders; const resource = stat ? stat.resource : folders[folders.length - 1].uri;
} const previousInput = this.tree.getInput(); <del> const promise = this.tree.setInput(input, viewState).then(async () => { </del> <ins> const promise = this.setTreeInputPromise = this.tree.setInput(input, viewState).then(async () => { </ins> if (Array.isArray(input)) { if (!viewState || previousInput instanceof ExplorerItem) { // There is no view state for this workspace (we transitioned from a folder workspace?), expand up to five roots.
// Set up nls if the user is not using the default language (English) const nlsConfig = {}; <del> const locale = window.localStorage.getItem('vscode.nls.locale') || navigator.language; </del> <ins> // Normalize locale to lowercase because translationServiceUrl is case-sensitive. // ref: https://github.com/microsoft/vscode/issues/187795 const locale = window.localStorage.getItem('vscode.nls.locale') || navigator.language.toLowerCase(); </ins> if (!locale.startsWith('en')) { nlsConfig['vs/nls'] = { availableLanguages: {
async setLocale(languagePackItem: ILanguagePackItem, _skipDialog = false): Promise<void> { const locale = languagePackItem.id; <del> if (locale === Language.value() || (!locale && Language.value() === navigator.language)) { </del> <ins> if (locale === Language.value() || (!locale && Language.value() === navigator.language.toLowerCase())) { </ins> return; } if (locale) {
const rerender = () => { this.gettingStartedCategories = this.gettingStartedService.getWalkthroughs(); this.featuredExtensions = this.featuredExtensionService.getExtensions(); <del> this.buildSlideThrottle.queue(async () => await this.buildCategoriesSlide()); </del> <ins> if (this.currentWalkthrough) { const existingSteps = this.currentWalkthrough.steps.map(step => step.id); const newCategory = this.gettingStartedCategories.find(category => this.currentWalkthrough?.id === category.id); if (newCategory) { const newSteps = newCategory.steps.map(step => step.id); if (!equals(newSteps, existingSteps)) { this.buildSlideThrottle.queue(() => this.buildCategoriesSlide()); } } } else { this.buildSlideThrottle.queue(() => this.buildCategoriesSlide()); } </ins> }; this._register(this.extensionManagementService.onDidInstallExtensions(async (result) => {
isEncryptionAvailable(): Promise<boolean>; } <ins> // The values provided to the `password-store` command line switch. // Notice that they are not the same as the values returned by // `getSelectedStorageBackend` in the `safeStorage` API. export const enum PasswordStoreCLIOption { kwallet = 'kwallet', kwallet5 = 'kwallet5', gnome = 'gnome', gnomeKeyring = 'gnome-keyring', gnomeLibsecret = 'gnome-libsecret', basic = 'basic' } // The values returned by `getSelectedStorageBackend` in the `safeStorage` API. </ins> export const enum KnownStorageProvider { unknown = 'unknown', basicText = 'basic_text',
import { safeStorage as safeStorageElectron, app } from 'electron'; import { isMacintosh, isWindows } from 'vs/base/common/platform'; <del> import { KnownStorageProvider, IEncryptionMainService } from 'vs/platform/encryption/common/encryptionService'; </del> <ins> import { KnownStorageProvider, IEncryptionMainService, PasswordStoreCLIOption } from 'vs/platform/encryption/common/encryptionService'; </ins> import { ILogService } from 'vs/platform/log/common/log'; // These APIs are currently only supported in our custom build of electron so
@ILogService private readonly logService: ILogService ) { // if this commandLine switch is set, the user has opted in to using basic text encryption <del> if (app.commandLine.getSwitchValue('password-store') === 'basic_text') { </del> <ins> if (app.commandLine.getSwitchValue('password-store') === PasswordStoreCLIOption.basic) { </ins> safeStorage.setUsePlainTextEncryption?.(true); } }
'disable-telemetry': { type: 'boolean' }, 'disable-updates': { type: 'boolean' }, 'disable-keytar': { type: 'boolean' }, <ins> 'password-store': { type: 'string' }, </ins> 'disable-workspace-trust': { type: 'boolean' }, 'disable-crash-reporter': { type: 'boolean' }, 'crash-reporter-directory': { type: 'string' },
import Severity from 'vs/base/common/severity'; import { localize } from 'vs/nls'; import { IDialogService } from 'vs/platform/dialogs/common/dialogs'; <del> import { IEncryptionService, KnownStorageProvider, isGnome, isKwallet } from 'vs/platform/encryption/common/encryptionService'; </del> <ins> import { IEncryptionService, KnownStorageProvider, PasswordStoreCLIOption, isGnome, isKwallet } from 'vs/platform/encryption/common/encryptionService'; </ins> import { IEnvironmentService } from 'vs/platform/environment/common/environment'; import { InstantiationType, registerSingleton } from 'vs/platform/instantiation/common/extensions'; import { ILogService } from 'vs/platform/log/common/log';
label: localize('usePlainText', "Use weaker encryption"), run: async () => { await this._encryptionService.setUsePlainTextEncryption(); <del> await this._jsonEditingService.write(this._environmentService.argvResource, [{ path: ['password-store'], value: 'basic_text' }], true); </del> <ins> await this._jsonEditingService.write(this._environmentService.argvResource, [{ path: ['password-store'], value: PasswordStoreCLIOption.basic }], true); </ins> this.reinitialize(); } };
const isPanelChat = typeof response !== 'string'; this._responsePendingAudioCue?.dispose(); this._runOnceScheduler?.cancel(); <ins> if (this._lastResponse === response?.toString()) { return; } this._lastResponse = response?.toString(); </ins> this._audioCueService.playAudioCue(AudioCue.chatResponseReceived, true); this._hasReceivedRequest = false; if (!response) {
*  Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ <del> import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry'; </del> import { ExtensionRecommendations, ExtensionRecommendation } from 'vs/workbench/contrib/extensions/browser/extensionRecommendations'; <del> import { INotificationService, Severity } from 'vs/platform/notification/common/notification'; import { EnablementState, IExtensionManagementServerService } from 'vs/workbench/services/extensionManagement/common/extensionManagement'; </del> <ins> import { EnablementState } from 'vs/workbench/services/extensionManagement/common/extensionManagement'; </ins> import { ExtensionRecommendationReason, IExtensionIgnoredRecommendationsService } from 'vs/workbench/services/extensionRecommendations/common/extensionRecommendations'; <del> import { IExtensionsViewPaneContainer, IExtensionsWorkbenchService, IExtension, VIEWLET_ID as EXTENSIONS_VIEWLET_ID } from 'vs/workbench/contrib/extensions/common/extensions'; import { CancellationToken } from 'vs/base/common/cancellation'; </del> <ins> import { IExtensionsWorkbenchService, IExtension } from 'vs/workbench/contrib/extensions/common/extensions'; </ins> import { localize } from 'vs/nls'; import { StorageScope, IStorageService, StorageTarget } from 'vs/platform/storage/common/storage'; import { IProductService } from 'vs/platform/product/common/productService';
import { basename, extname } from 'vs/base/common/resources'; import { match } from 'vs/base/common/glob'; import { URI } from 'vs/base/common/uri'; <del> import { Mimes } from 'vs/base/common/mime'; import { getMimeTypes } from 'vs/editor/common/services/languagesAssociations'; </del> import { IModelService } from 'vs/editor/common/services/model'; import { ILanguageService } from 'vs/editor/common/languages/language'; import { IExtensionRecommendationNotificationService, RecommendationsNotificationResult, RecommendationSource } from 'vs/platform/extensionRecommendations/common/extensionRecommendations';
import { DisposableStore } from 'vs/base/common/lifecycle'; import { CellUri } from 'vs/workbench/contrib/notebook/common/notebookCommon'; import { disposableTimeout } from 'vs/base/common/async'; <del> import { IPaneCompositePartService } from 'vs/workbench/services/panecomposite/browser/panecomposite'; import { ViewContainerLocation } from 'vs/workbench/common/views'; </del> import { IWorkspaceContextService } from 'vs/platform/workspace/common/workspace'; import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil'; import { isEmptyObject } from 'vs/base/common/types'; import { PLAINTEXT_LANGUAGE_ID } from 'vs/editor/common/languages/modesRegistry'; <del> type FileExtensionSuggestionClassification = { owner: 'sandy081'; comment: 'Response information when a file based reccommendation is suggested'; userReaction: { classification: 'SystemMetaData'; purpose: 'FeatureInsight'; comment: 'User reaction after showing the recommendation prompt. Eg., install, cancel, show, neverShowAgain' }; fileExtension: { classification: 'PublicNonPersonalData'; purpose: 'FeatureInsight'; comment: 'Extension of the file for which an extension is being recommended.' }; }; </del> const promptedRecommendationsStorageKey = 'fileBasedRecommendations/promptedRecommendations'; <del> const promptedFileExtensionsStorageKey = 'fileBasedRecommendations/promptedFileExtensions'; </del> const recommendationsStorageKey = 'extensionsAssistant/recommendations'; <del> const searchMarketplace = localize('searchMarketplace', "Search Marketplace"); </del> const milliSecondsInADay = 1000 * 60 * 60 * 24; export class FileBasedRecommendations extends ExtensionRecommendations {