jiebi/CodeConvo huggingface dataset:
} }); <ins> function overrideActionForActiveExtensionEditorWebview(command: MultiCommand | undefined, f: (webview: Webview) => void) { command?.addImplementation(105, (accessor) => { const editorService = accessor.get(IEditorService); const editor = editorService.activeEditorPane; if (editor instanceof ExtensionEditor) { if (editor.activeWebview) { f(editor.activeWebview); return true; } } return false; }); } overrideActionForActiveExtensionEditorWebview(CopyAction, webview => webview.copy()); overrideActionForActiveExtensionEditorWebview(CutAction, webview => webview.cut()); overrideActionForActiveExtensionEditorWebview(PasteAction, webview => webview.paste()); </ins> const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench); class ExtensionsContributions implements IWorkbenchContribution {
}; return this._commands.executeCommand<modes.CompletionList>('_executeCompletionItemProvider', args).then(result => { if (result) { <del> const items = result.suggestions.map(suggestion => typeConverters.CompletionItem.to(suggestion)); </del> <ins> const items = result.suggestions.map(suggestion => typeConverters.CompletionItem.to(suggestion, this._commands.converter)); </ins> return new types.CompletionList(items, result.incomplete); } return undefined;
import { LogLevel as _MainLogLevel } from 'vs/platform/log/common/log'; import { coalesce, isNonEmptyArray } from 'vs/base/common/arrays'; import { RenderLineNumbersType } from 'vs/editor/common/config/editorOptions'; <ins> import { CommandsConverter } from 'vs/workbench/api/common/extHostCommands'; </ins> export interface PositionLike { line: number;
export namespace CompletionItem { <del> export function to(suggestion: modes.CompletionItem): types.CompletionItem { </del> <ins> export function to(suggestion: modes.CompletionItem, converter?: CommandsConverter): types.CompletionItem { </ins> const result = new types.CompletionItem(suggestion.label); result.insertText = suggestion.insertText; result.kind = CompletionItemKind.to(suggestion.kind);
result.range = editorRange.Range.isIRange(suggestion.range) ? Range.to(suggestion.range) : undefined; result.range2 = editorRange.Range.isIRange(suggestion.range) ? undefined : { inserting: Range.to(suggestion.range.insert), replacing: Range.to(suggestion.range.replace) }; result.keepWhitespace = typeof suggestion.insertTextRules === 'undefined' ? false : Boolean(suggestion.insertTextRules & modes.CompletionItemInsertTextRule.KeepWhitespace); <del> // 'inserText'-logic </del> <ins> // 'insertText'-logic </ins> if (typeof suggestion.insertTextRules !== 'undefined' && suggestion.insertTextRules & modes.CompletionItemInsertTextRule.InsertAsSnippet) { result.insertText = new types.SnippetString(suggestion.insertText); } else { result.insertText = suggestion.insertText; result.textEdit = result.range instanceof types.Range ? new types.TextEdit(result.range, result.insertText) : undefined; } <del> // TODO additionalEdits, command </del> <ins> if (suggestion.additionalTextEdits && suggestion.additionalTextEdits.length > 0) { result.additionalTextEdits = suggestion.additionalTextEdits.map(e => TextEdit.to(e as modes.TextEdit)); } result.command = converter && suggestion.command ? converter.fromInternal(suggestion.command) : undefined; </ins> return result; }
this.ignoreSelectionChangedEvent = true; try { this.tree.setSelection([element]); <del> this.tree.reveal(element); </del> <ins> // If the element is outside of the screen bounds, // position it in the middle if (this.tree.getRelativeTop(element) === null) { this.tree.reveal(element, 0.5); } else { this.tree.reveal(element); } </ins> } catch (e) { } finally { this.ignoreSelectionChangedEvent = false;
// Create directories as needed for (let i = directoriesToCreate.length - 1; i >= 0; i--) { directory = joinPath(directory, directoriesToCreate[i]); <del> await provider.mkdir(directory); </del> <ins> try { await provider.mkdir(directory); } catch (error) { if (toFileSystemProviderErrorCode(error) !== FileSystemProviderErrorCode.FileExists) { // For mkdirp() we tolerate that the mkdir() call fails // in case the folder already exists. This follows node.js // own implementation of fs.mkdir({ recursive: true }) and // reduces the chances of race conditions leading to errors // if multiple calls try to create the same folders // As such, we only throw an error here if it is other than // the fact that the file already exists. // (see also https://github.com/microsoft/vscode/issues/89834) throw error; } } </ins> } }
import { NullLogService } from 'vs/platform/log/common/log'; import { isLinux, isWindows } from 'vs/base/common/platform'; import { DisposableStore } from 'vs/base/common/lifecycle'; <del> import { isEqual } from 'vs/base/common/resources'; </del> <ins> import { isEqual, joinPath } from 'vs/base/common/resources'; </ins> import { VSBuffer, VSBufferReadable, streamToBufferReadableStream, VSBufferReadableStream, bufferToReadable, bufferToStream, streamToBuffer } from 'vs/base/common/buffer'; import { find } from 'vs/base/common/arrays';
assert.ok(!error); }); <ins> test('writeFile - no error when writing to same non-existing folder multiple times different new files', async () => { const newFolder = URI.file(join(testDir, 'some', 'new', 'folder')); const file1 = joinPath(newFolder, 'file-1'); const file2 = joinPath(newFolder, 'file-2'); const file3 = joinPath(newFolder, 'file-3'); // this essentially verifies that the mkdirp logic implemented // in the file service is able to receive multiple requests for // the same folder and will not throw errors if another racing // call succeeded first. const newContent = 'Updates to the small file'; await Promise.all([ service.writeFile(file1, VSBuffer.fromString(newContent)), service.writeFile(file2, VSBuffer.fromString(newContent)), service.writeFile(file3, VSBuffer.fromString(newContent)) ]); assert.ok(service.exists(file1)); assert.ok(service.exists(file2)); assert.ok(service.exists(file3)); }); test('writeFile - error when writing to folder that is a file', async () => { const existingFile = URI.file(join(testDir, 'my-file')); await service.createFile(existingFile); const newFile = joinPath(existingFile, 'file-1'); let error; const newContent = 'Updates to the small file'; try { await service.writeFile(newFile, VSBuffer.fromString(newContent)); } catch (e) { error = e; } assert.ok(error); }); </ins> const runWatchTests = isLinux; (runWatchTests ? test : test.skip)('watch - file', done => {
await app.workbench.editors.newUntitledFile(); const untitled = 'Untitled-1'; <del> const textToTypeInUntitled = 'Hello, Untitled Code'; </del> <ins> const textToTypeInUntitled = untitled; </ins> await app.workbench.editor.waitForTypeInEditor(untitled, textToTypeInUntitled); const readmeMd = 'readme.md';
await stableApp.workbench.editors.newUntitledFile(); const untitled = 'Untitled-1'; <del> const textToTypeInUntitled = 'Hello, Untitled Code'; </del> <ins> const textToTypeInUntitled = untitled; </ins> await stableApp.workbench.editor.waitForTypeInEditor(untitled, textToTypeInUntitled); const readmeMd = 'readme.md';
} // file system error <del> throw new FileSystemError(err.message, err.name as files.FileSystemProviderErrorCode); </del> <ins> switch (err.name) { case files.FileSystemProviderErrorCode.FileExists: throw FileSystemError.FileExists(err.message); case files.FileSystemProviderErrorCode.FileNotFound: throw FileSystemError.FileNotFound(err.message); case files.FileSystemProviderErrorCode.FileNotADirectory: throw FileSystemError.FileNotADirectory(err.message); case files.FileSystemProviderErrorCode.FileIsADirectory: throw FileSystemError.FileIsADirectory(err.message); case files.FileSystemProviderErrorCode.NoPermissions: throw FileSystemError.NoPermissions(err.message); case files.FileSystemProviderErrorCode.Unavailable: throw FileSystemError.Unavailable(err.message); default: throw new FileSystemError(err.message, err.name as files.FileSystemProviderErrorCode); } </ins> } }
return new FileSystemError(messageOrUri, FileSystemProviderErrorCode.Unavailable, FileSystemError.Unavailable); } <ins> readonly code?: string; </ins> constructor(uriOrMessage?: string | URI, code: FileSystemProviderErrorCode = FileSystemProviderErrorCode.Unknown, terminator?: Function) { super(URI.isUri(uriOrMessage) ? uriOrMessage.toString(true) : uriOrMessage); <ins> this.code = terminator?.name; </ins> // mark the error as file system provider error so that // we can extract the error code on the receiving side markAsFileSystemProviderError(this, code);
*--------------------------------------------------------------------------------------------*/ import { URI } from 'vs/base/common/uri'; <del> import { IFileSystemProviderWithFileReadWriteCapability, FileSystemProviderCapabilities, IFileChange, IWatchOptions, IStat, FileOverwriteOptions, FileType, FileDeleteOptions, FileWriteOptions, FileChangeType, FileSystemProviderErrorCode } from 'vs/platform/files/common/files'; </del> <ins> import { IFileSystemProviderWithFileReadWriteCapability, FileSystemProviderCapabilities, IFileChange, IWatchOptions, IStat, FileOverwriteOptions, FileType, FileDeleteOptions, FileWriteOptions, FileChangeType } from 'vs/platform/files/common/files'; </ins> import { Disposable, IDisposable } from 'vs/base/common/lifecycle'; import { Event, Emitter } from 'vs/base/common/event'; import { VSBuffer } from 'vs/base/common/buffer';
size: 0 }; } <del> return Promise.reject(new FileSystemError(resource, FileSystemProviderErrorCode.FileNotFound)); </del> <ins> return Promise.reject(FileSystemError.FileNotFound(resource)); </ins> } async readdir(resource: URI): Promise<[string, FileType][]> { const hasKey = await this.hasKey(resource.path); if (hasKey) { <del> return Promise.reject(new FileSystemError(resource, FileSystemProviderErrorCode.FileNotADirectory)); </del> <ins> return Promise.reject(FileSystemError.FileNotADirectory(resource)); </ins> } const keys = await this.getAllKeys(); const files: Map<string, [string, FileType]> = new Map<string, [string, FileType]>();
async readFile(resource: URI): Promise<Uint8Array> { const hasKey = await this.hasKey(resource.path); if (!hasKey) { <del> return Promise.reject(new FileSystemError(resource, FileSystemProviderErrorCode.FileNotFound)); </del> <ins> return Promise.reject(FileSystemError.FileNotFound(resource)); </ins> } const value = await this.getValue(resource.path); return VSBuffer.fromString(value).buffer;
}): Disposable; } //#endregion <ins> //#region export interface FileSystem { /** * Check if a given file system supports writing files. * * Keep in mind that just because a file system supports writing, that does * not mean that writes will always succeed. There may be permissions issues * or other errors that prevent writing a file. * * @param scheme The scheme of the filesystem, for example `file` or `git`. * * @return `true` if the file system supports writing, `false` if it does not * support writing (i.e. it is readonly), and `undefined` if VS Code does not * know about the filesystem. */ isWritableFileSystem(scheme: string): boolean | undefined; } //#endregion </ins> }
const extHostEditorInsets = rpcProtocol.set(ExtHostContext.ExtHostEditorInsets, new ExtHostEditorInsets(rpcProtocol.getProxy(MainContext.MainThreadEditorInsets), extHostEditors, initData.environment)); const extHostDiagnostics = rpcProtocol.set(ExtHostContext.ExtHostDiagnostics, new ExtHostDiagnostics(rpcProtocol, extHostLogService)); const extHostLanguageFeatures = rpcProtocol.set(ExtHostContext.ExtHostLanguageFeatures, new ExtHostLanguageFeatures(rpcProtocol, uriTransformer, extHostDocuments, extHostCommands, extHostDiagnostics, extHostLogService, extHostApiDeprecation)); <del> const extHostFileSystem = rpcProtocol.set(ExtHostContext.ExtHostFileSystem, new ExtHostFileSystem(rpcProtocol, extHostLanguageFeatures)); </del> <ins> const extHostFileSystem = rpcProtocol.set(ExtHostContext.ExtHostFileSystem, new ExtHostFileSystem(rpcProtocol, extHostLanguageFeatures, extHostConsumerFileSystem)); </ins> const extHostFileSystemEvent = rpcProtocol.set(ExtHostContext.ExtHostFileSystemEventService, new ExtHostFileSystemEventService(rpcProtocol, extHostLogService, extHostDocumentsAndEditors)); const extHostQuickOpen = rpcProtocol.set(ExtHostContext.ExtHostQuickOpen, new ExtHostQuickOpen(rpcProtocol, extHostWorkspace, extHostCommands)); const extHostSCM = rpcProtocol.set(ExtHostContext.ExtHostSCM, new ExtHostSCM(rpcProtocol, extHostCommands, extHostLogService));
private _linkProviderRegistration?: IDisposable; private _handlePool: number = 0; <del> constructor(mainContext: IMainContext, private _extHostLanguageFeatures: ExtHostLanguageFeatures) { </del> <ins> constructor(mainContext: IMainContext, private _extHostLanguageFeatures: ExtHostLanguageFeatures, private readonly _fileSystemConsumer: IExtHostConsumerFileSystem) { </ins> this._proxy = mainContext.getProxy(MainContext.MainThreadFileSystem); // register used schemes
import { VSBuffer } from 'vs/base/common/buffer'; import { createDecorator } from 'vs/platform/instantiation/common/instantiation'; import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService'; <ins> import { IDisposable, toDisposable } from 'vs/base/common/lifecycle'; </ins> export class ExtHostConsumerFileSystem implements vscode.FileSystem {
copy(source: vscode.Uri, destination: vscode.Uri, options?: { overwrite?: boolean; }): Promise<void> { return this._proxy.$copy(source, destination, { ...{ overwrite: false }, ...options }).catch(ExtHostConsumerFileSystem._handleError); } <ins> isWritableFileSystem(scheme: string): boolean | undefined { const entry = this._schemes.get(scheme); if (entry) { return !entry.isReadonly; } return undefined; } </ins> private static _handleError(err: any): never { // generic error if (!(err instanceof Error)) {
default: throw new FileSystemError(err.message, err.name as files.FileSystemProviderErrorCode); } } <ins> /* internal */ _registerScheme(scheme: string, options: { readonly isReadonly?: boolean }): IDisposable { this._schemes.set(scheme, options); return toDisposable(() => { return this._schemes.delete(scheme); }); } </ins> } export interface IExtHostConsumerFileSystem extends ExtHostConsumerFileSystem { }
} ]; <ins> const directives390: Directive[] = [ ...directives, { value: '@ts-expect-error', description: localize( 'ts-expect-error', "Suppresses @ts-check errors on the next line of a file, expecting at least one to exist.") } ]; </ins> class DirectiveCommentCompletionProvider implements vscode.CompletionItemProvider { <ins> private readonly directives: Directive[]; </ins> constructor( private readonly client: ITypeScriptServiceClient, <del> ) { } </del> <ins> ) { this.directives = client.apiVersion.gte(API.v390) ? directives390 : directives; } </ins> public provideCompletionItems( document: vscode.TextDocument,
const prefix = line.slice(0, position.character); const match = prefix.match(/^s*//+s?(@[a-zA-Z-]*)?$/); if (match) { <del> return directives.map(directive => { </del> <ins> return this.directives.map(directive => { </ins> const item = new vscode.CompletionItem(directive.value, vscode.CompletionItemKind.Snippet); item.detail = directive.description; item.range = new vscode.Range(position.line, Math.max(0, position.character - (match[1] ? match[1].length : 0)), position.line, position.character);
public static readonly v350 = API.fromSimpleString('3.5.0'); public static readonly v380 = API.fromSimpleString('3.8.0'); public static readonly v381 = API.fromSimpleString('3.8.1'); <ins> public static readonly v390 = API.fromSimpleString('3.9.0'); </ins> public static fromVersionString(versionString: string): API { let version = semver.valid(versionString);
easy = 42; ||| <del> >**Tip:** You can also enable the checks workspace or application wide by adding |"javascript.implicitProjectConfig.checkJs": true| to your workspace or user settings and explicitly ignoring files or lines using |// @ts-nocheck| and |// @ts-ignore|. Check out the docs on [JavaScript in VS Code](https://code.visualstudio.com/docs/languages/javascript) to learn more. </del> <ins> >**Tip:** You can also enable the checks workspace or application wide by adding |"javascript.implicitProjectConfig.checkJs": true| to your workspace or user settings and explicitly ignoring files or lines using |// @ts-nocheck| and |// @ts-expect-error|. Check out the docs on [JavaScript in VS Code](https://code.visualstudio.com/docs/languages/javascript) to learn more. </ins> ## Thanks!
SymbolInformation, SymbolKind, CompletionItem, Location, SignatureHelp, SignatureInformation, ParameterInformation, Definition, TextEdit, TextDocument, Diagnostic, DiagnosticSeverity, Range, CompletionItemKind, Hover, MarkedString, DocumentHighlight, DocumentHighlightKind, CompletionList, Position, FormattingOptions, FoldingRange, FoldingRangeKind, SelectionRange, <del> LanguageMode, Settings, SemanticTokenData </del> <ins> LanguageMode, Settings, SemanticTokenData, Workspace </ins> } from './languageModes'; import { getWordAtText, startsWith, isWhitespaceOnly, repeat } from '../utils/strings'; import { HTMLDocumentRegions } from './embeddedSupport';
jquery_d_ts = join(__dirname, '../../lib/jquery.d.ts'); // from source } <del> export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocumentRegions>, languageId: 'javascript' | 'typescript'): LanguageMode { </del> <ins> export function getJavaScriptMode(documentRegions: LanguageModelCache<HTMLDocumentRegions>, languageId: 'javascript' | 'typescript', workspace: Workspace): LanguageMode { </ins> let jsDocuments = getLanguageModelCache<TextDocument>(10, 60, document => documentRegions.get(document).getEmbeddedDocument(languageId)); const workingFile = languageId === 'javascript' ? 'vscode://javascript/1.js' : 'vscode://javascript/2.ts'; // the same 'file' is used for all contents <del> let compilerOptions: ts.CompilerOptions = { allowNonTsExtensions: true, allowJs: true, lib: ['lib.es6.d.ts'], target: ts.ScriptTarget.Latest, moduleResolution: ts.ModuleResolutionKind.Classic }; </del> <ins> let compilerOptions: ts.CompilerOptions = { allowNonTsExtensions: true, allowJs: true, lib: ['lib.es6.d.ts'], target: ts.ScriptTarget.Latest, moduleResolution: ts.ModuleResolutionKind.Classic, experimentalDecorators: false }; </ins> let currentTextDocument: TextDocument; let scriptFileVersion: number = 0; function updateCurrentTextDocument(doc: TextDocument) {
getId() { return languageId; }, <del> doValidation(document: TextDocument): Diagnostic[] { </del> <ins> doValidation(document: TextDocument, settings = workspace.settings): Diagnostic[] { </ins> updateCurrentTextDocument(document); <ins> host.getCompilationSettings()['experimentalDecorators'] = settings && settings.javascript && settings.javascript.implicitProjectConfig.experimentalDecorators; </ins> const syntaxDiagnostics: ts.Diagnostic[] = jsLanguageService.getSyntacticDiagnostics(workingFile); const semanticDiagnostics = jsLanguageService.getSemanticDiagnostics(workingFile); return syntaxDiagnostics.concat(semanticDiagnostics).map((diag: ts.Diagnostic): Diagnostic => {
modes['css'] = getCSSMode(cssLanguageService, documentRegions, workspace); } if (supportedLanguages['javascript']) { <del> modes['javascript'] = getJavaScriptMode(documentRegions, 'javascript'); modes['typescript'] = getJavaScriptMode(documentRegions, 'typescript'); </del> <ins> modes['javascript'] = getJavaScriptMode(documentRegions, 'javascript', workspace); modes['typescript'] = getJavaScriptMode(documentRegions, 'typescript', workspace); </ins> } return { getModeAtPosition(document: TextDocument, position: Position): LanguageMode | undefined {
if (this.canSelectMany) { this.ui.list.domFocus(); } <del> event.preventDefault(); </del> <ins> dom.EventHelper.stop(event, true); </ins> break; case KeyCode.PageDown: this.ui.list.focus(QuickInputListFocus.NextPage); if (this.canSelectMany) { this.ui.list.domFocus(); } <del> event.preventDefault(); </del> <ins> dom.EventHelper.stop(event, true); </ins> break; case KeyCode.PageUp: this.ui.list.focus(QuickInputListFocus.PreviousPage); if (this.canSelectMany) { this.ui.list.domFocus(); } <del> event.preventDefault(); </del> <ins> dom.EventHelper.stop(event, true); </ins> break; case KeyCode.RightArrow: if (!this._canAcceptInBackground) {
case KeyCode.Home: if (event.ctrlKey && !event.shiftKey && !event.altKey && !event.metaKey) { this.ui.list.focus(QuickInputListFocus.First); <del> event.preventDefault(); </del> <ins> dom.EventHelper.stop(event, true); </ins> } break; case KeyCode.End: if (event.ctrlKey && !event.shiftKey && !event.altKey && !event.metaKey) { this.ui.list.focus(QuickInputListFocus.Last); <del> event.preventDefault(); </del> <ins> dom.EventHelper.stop(event, true); </ins> } break; }
"languages": [{ "id": "shellscript", "aliases": ["Shell Script", "shellscript", "bash", "sh", "zsh", "ksh", "csh"], <del> "extensions": [".sh", ".bash", ".bashrc", ".bash_aliases", ".bash_profile", ".bash_login", ".ebuild", ".install", ".profile", ".bash_logout", ".zsh", ".zshrc", ".zprofile", ".zlogin", ".zlogout", ".zshenv", ".zsh-theme", ".ksh", ".csh", ".cshrc"], </del> <ins> "extensions": [ ".sh", ".bash", ".bashrc", ".bash_aliases", ".bash_profile", ".bash_login", ".ebuild", ".install", ".profile", ".bash_logout", ".zsh", ".zshrc", ".zprofile", ".zlogin", ".zlogout", ".zshenv", ".zsh-theme", ".ksh", ".csh", ".cshrc", ".tcshrc", ".yashrc", ".yash_profile" ], </ins> "filenames": [ <del> "APKBUILD", "PKGBUILD", ".envrc" ], "firstLine": "^#!.*b(bash|zsh|sh|tcsh|ksh|ash|qsh|csh).*|^#s*-*-[^*]*mode:s*shell-script[^*]*-*-", </del> <ins> "APKBUILD", "PKGBUILD", ".envrc", ".hushlogin", "zshrc", "zshenv", "zlogin", "zprofile", "zlogout", "bashrc_Apple_Terminal", "zshrc_Apple_Terminal" ], "firstLine": "^#!.*b(bash|zsh|sh|ksh|dtksh|pdksh|mksh|ash|dash|yash|sh|csh|jcsh|tcsh|itcsh).*|^#s*-*-[^*]*mode:s*shell-script[^*]*-*-", </ins> "configuration": "./language-configuration.json", "mimetypes": ["text/x-shellscript"] }],
"pickerGroup.foreground": "#b0b0b0", "terminal.ansiWhite": "#ffffff", "inputOption.activeBorder": "#3655b5", <del> "focusBorder": "#3655b5" </del> <ins> "focusBorder": "#3655b5", "terminal.ansiBlack": "#1e1e1e", "terminal.ansiRed": "#C4265E", // the bright color with ~75% transparent on the background "terminal.ansiGreen": "#86B42B", "terminal.ansiYellow": "#B3B42B", "terminal.ansiBlue": "#6A7EC8", "terminal.ansiMagenta": "#8C6BC8", "terminal.ansiCyan": "#56ADBC", "terminal.ansiWhite": "#e3e3dd", "terminal.ansiBrightBlack": "#666666", "terminal.ansiBrightRed": "#f92672", "terminal.ansiBrightGreen": "#A6E22E", "terminal.ansiBrightYellow": "#e2e22e", // hue shifted #A6E22E "terminal.ansiBrightBlue": "#819aff", // hue shifted #AE81FF "terminal.ansiBrightMagenta": "#AE81FF", "terminal.ansiBrightCyan": "#66D9EF", "terminal.ansiBrightWhite": "#f8f8f2" </ins> }, "tokenColors": [ {
return false; } <del> const context = await this.requestService.request({ url: this.url }, CancellationToken.None); // The update server replies with 204 (No Content) when no // update is available - that's all we want to know. return context.res.statusCode === 204; </del> <ins> try { const context = await this.requestService.request({ url: this.url }, CancellationToken.None); // The update server replies with 204 (No Content) when no // update is available - that's all we want to know. return context.res.statusCode === 204; } catch (error) { this.logService.error('update#isLatestVersion(): failed to check for updates'); this.logService.error(error); return undefined; } </ins> } async _applySpecificUpdate(packagePath: string): Promise<void> {
"opn": "^6.0.0", "optimist": "0.3.5", "p-all": "^1.0.0", <del> "playwright": "0.15.0", </del> <ins> "playwright": "1.0.1", </ins> "pump": "^1.0.1", "queue": "3.0.6", "rcedit": "^1.1.0",