@codingame/monaco-vscode-api 5.1.2-segmenter.1 → 5.2.0

package/README.md

@@ -250,7 +250,7 @@ await initialize({
     // Open a new editor here and return it
     // It will be called when for instance the user ctrl+click on an import
   }),
-  ...getConfigurationServiceOverride(vscode.Uri.file('/tmp/'))
+  ...getConfigurationServiceOverride()
 })
 
 updateUserConfiguration(`{

package/extensions.d.ts

@@ -100,6 +100,7 @@ export { IExtensionContributions } from './vscode/src/vs/platform/extensions/com
 import { IDisposable } from './vscode/src/vs/base/common/lifecycle.js';
 export { ITranslations } from './vscode/src/vs/platform/extensionManagement/common/extensionNls.js';
 import { ExtensionHostKind } from './vscode/src/vs/workbench/services/extensions/common/extensionHostKind.js';
+export { ExtensionFileMetadata } from './service-override/files.js';
 
 type ApiFactory = (extensionId?: string) => Promise<typeof vscode>;
 declare function registerLocalApiFactory(_apiFactory: ApiFactory): void;

package/extensions.js

@@ -13,31 +13,20 @@ import { IWorkbenchExtensionEnablementService } from './vscode/src/vs/workbench/
 import { StandaloneServices } from './vscode/src/vs/editor/standalone/browser/standaloneServices.js';
 import { ExtensionManifestTranslator } from './vscode/src/vs/platform/extensionManagement/common/extensionsScannerService.js';
 import { language } from './vscode/src/vs/base/common/platform.js';
-import { CustomSchemas, registerExtensionFile } from '@codingame/monaco-vscode-files-service-override';
+import { CustomSchemas, registerExtensionFile, RegisteredUriFile } from '@codingame/monaco-vscode-files-service-override';
 import { waitServicesReady } from './lifecycle.js';
-import { throttle, memoized } from './tools.js';
+import { throttle } from './tools.js';
 import { setDefaultApi } from './api.js';
 import { getBuiltInExtensionTranslationsUris } from './l10n.js';
 let apiFactory;
 function registerLocalApiFactory(_apiFactory) {
     apiFactory = _apiFactory;
 }
-function registerExtensionFileUrl(extensionLocation, filePath, url, mimeType) {
+function registerExtensionFileUrl(extensionLocation, filePath, url, metadataOrMimeType) {
     const fileDisposable = new DisposableStore();
     fileDisposable.add(FileAccess.registerStaticBrowserUri(joinPath(extensionLocation, filePath), ( URI.parse(url))));
-    fileDisposable.add(registerExtensionFile(extensionLocation, filePath, memoized(async () => {
-        const response = await fetch(url, {
-            headers: mimeType != null
-                ? {
-                    Accept: mimeType
-                }
-                : {}
-        });
-        if (response.status !== 200) {
-            throw new Error(response.statusText);
-        }
-        return new Uint8Array(await response.arrayBuffer());
-    })));
+    const metadata = typeof metadataOrMimeType === 'string' ? { mimeType: metadataOrMimeType } : metadataOrMimeType;
+    fileDisposable.add(registerExtensionFile(new RegisteredUriFile(joinPath(extensionLocation, filePath), url, metadata)));
     return fileDisposable;
 }
 const deltaExtensions = throttle(async ({ toAdd, toRemove }) => {
@@ -129,8 +118,8 @@ function registerExtension(manifest, extHostKind, { path = '/', system = false,
         }
     };
     if (extHostKind !== 3 ) {
-        function registerFileUrl(path, url, mimeType) {
-            return registerExtensionFileUrl(location, path, url, mimeType);
+        function registerFileUrl(path, url, metadataOrMimeType) {
+            return registerExtensionFileUrl(location, path, url, metadataOrMimeType);
         }
         api = {
             ...api,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "5.1.2-segmenter.1",
+  "version": "5.2.0",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -99,12 +99,12 @@
   "dependencies": {
     "@vscode/iconv-lite-umd": "0.7.0",
     "jschardet": "3.0.0",
-    "@codingame/monaco-vscode-extensions-service-override": "5.1.2-segmenter.1",
-    "@codingame/monaco-vscode-files-service-override": "5.1.2-segmenter.1",
-    "@codingame/monaco-vscode-quickaccess-service-override": "5.1.2-segmenter.1",
-    "@codingame/monaco-vscode-environment-service-override": "5.1.2-segmenter.1",
-    "@codingame/monaco-vscode-layout-service-override": "5.1.2-segmenter.1",
-    "@codingame/monaco-vscode-host-service-override": "5.1.2-segmenter.1",
-    "@codingame/monaco-vscode-base-service-override": "5.1.2-segmenter.1"
+    "@codingame/monaco-vscode-quickaccess-service-override": "5.2.0",
+    "@codingame/monaco-vscode-files-service-override": "5.2.0",
+    "@codingame/monaco-vscode-extensions-service-override": "5.2.0",
+    "@codingame/monaco-vscode-environment-service-override": "5.2.0",
+    "@codingame/monaco-vscode-layout-service-override": "5.2.0",
+    "@codingame/monaco-vscode-host-service-override": "5.2.0",
+    "@codingame/monaco-vscode-base-service-override": "5.2.0"
   }
 }

package/service-override/files.d.ts

@@ -1,72 +1,120 @@
 import { IEditorOverrideServices } from '../vscode/src/vs/editor/standalone/browser/standaloneServices.js';
 export { InMemoryFileSystemProvider } from '../vscode/src/vs/platform/files/common/inMemoryFilesystemProvider.js';
 import { URI } from '../vscode/src/vs/base/common/uri.js';
-import { FileType, IStat, IFileSystemProviderWithFileReadWriteCapability, IFileChange, IWatchOptions, IFileWriteOptions, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProvider, FileSystemProviderCapabilities, FileChangeType } from '../vscode/src/vs/platform/files/common/files.js';
+import { FileType, IStat, IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability, IFileChange, IFileReadStreamOptions, IFileWriteOptions, IWatchOptions, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProvider, FileSystemProviderCapabilities, FileChangeType } from '../vscode/src/vs/platform/files/common/files.js';
 export { FilePermission, FileSystemProviderError, FileSystemProviderErrorCode } from '../vscode/src/vs/platform/files/common/files.js';
 import { Disposable, IDisposable } from '../vscode/src/vs/base/common/lifecycle.js';
 import { Emitter, Event } from '../vscode/src/vs/base/common/event.js';
 export { HTMLFileSystemProvider } from '../vscode/src/vs/platform/files/browser/htmlFileSystemProvider.js';
 import { IndexedDBFileSystemProvider } from '../vscode/src/vs/platform/files/browser/indexedDBFileSystemProvider.js';
 export { IndexedDB } from '../vscode/src/vs/base/browser/indexedDB.js';
+import { ReadableStreamEvents } from '../vscode/src/vs/base/common/stream.js';
+import { CancellationToken } from '../vscode/src/vs/base/common/cancellation.js';
 
-declare abstract class RegisteredFile {
+interface _RegisteredNode {
+    type: FileType;
+    stats(): Promise<IStat>;
+    onDidDelete: Event<void>;
+    onDidChange: Event<void>;
+}
+interface RegisteredFileNode extends _RegisteredNode {
+    type: FileType.File;
+    uri: URI;
+    read(): Promise<Uint8Array>;
+    readStream?(): Promise<ReadableStream<Uint8Array>>;
+    write(content: Uint8Array): Promise<void>;
+    delete(): void;
+}
+interface RegisteredDirectoryNode extends _RegisteredNode {
+    type: FileType.Directory;
+    addChild(name: string, node: RegisteredNode): IDisposable;
+    deleteChild(name: string): boolean;
+    getChildren(name: string): RegisteredNode | undefined;
+    read(): [string, FileType][];
+}
+type RegisteredNode = RegisteredFileNode | RegisteredDirectoryNode;
+declare abstract class RegisteredFile implements RegisteredFileNode {
     uri: URI;
     private readonly;
     protected ctime: number;
     protected mtime: number;
-    readonly type: FileType;
+    readonly type = FileType.File;
     protected _onDidChange: Emitter<void>;
     onDidChange: Event<void>;
     protected _onDidDelete: Emitter<void>;
     onDidDelete: Event<void>;
-    protected _onDidRename: Emitter<{
-        from: URI;
-        to: URI;
-    }>;
-    onDidRename: Event<{
-        from: URI;
-        to: URI;
-    }>;
     constructor(uri: URI, readonly: boolean);
     stats(): Promise<IStat>;
-    getSize(): Promise<number>;
-    abstract read(): Promise<string | Uint8Array>;
-    abstract write(content: string): Promise<void>;
+    abstract getSize(): Promise<number>;
     delete(): Promise<void>;
-    rename(to: URI): Promise<void>;
+    abstract read(): Promise<Uint8Array>;
+    abstract write(content: Uint8Array): Promise<void>;
 }
 declare class RegisteredReadOnlyFile extends RegisteredFile {
-    read: () => Promise<string | Uint8Array>;
-    constructor(uri: URI, read: () => Promise<string | Uint8Array>);
+    read: () => Promise<Uint8Array>;
+    private size;
+    constructor(uri: URI, read: () => Promise<Uint8Array>, size: number);
+    getSize(): Promise<number>;
+    write(): Promise<void>;
+    delete(): Promise<void>;
+}
+interface ExtensionFileMetadata {
+    mimeType?: string;
+    size?: number;
+}
+declare class RegisteredUriFile extends RegisteredFile {
+    private url;
+    private metadata?;
+    constructor(location: URI, url: string, metadata?: ExtensionFileMetadata | undefined);
+    private fetch;
+    getSize(): Promise<number>;
+    read(): Promise<Uint8Array>;
+    readStream(): Promise<ReadableStream<Uint8Array>>;
     write(): Promise<void>;
     delete(): Promise<void>;
-    rename(): Promise<void>;
 }
 declare class RegisteredMemoryFile extends RegisteredFile {
     private content;
-    constructor(uri: URI, content: string);
-    read(): Promise<string | Uint8Array>;
-    write(content: string): Promise<void>;
+    constructor(uri: URI, content: string | Uint8Array);
+    getSize(): Promise<number>;
+    read(): Promise<Uint8Array>;
+    write(content: Uint8Array): Promise<void>;
 }
-declare class RegisteredFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
-    private files;
-    capabilities: number;
-    constructor(readonly: boolean);
+declare class RegisteredFileSystemProvider extends Disposable implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithOpenReadWriteCloseCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability {
+    private memoryFdCounter;
+    private readonly fdMemory;
+    private rootByAuthority;
     onDidChangeCapabilities: Event<any>;
     _onDidChangeFile: Emitter<readonly IFileChange[]>;
     onDidChangeFile: Event<readonly IFileChange[]>;
-    private formatUri;
-    registerFile(file: RegisteredFile): IDisposable;
+    capabilities: number;
+    constructor(readonly: boolean);
+    open(resource: URI): Promise<number>;
+    close(fd: number): Promise<void>;
+    read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    write(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number>;
+    private _lookupRoot;
+    private _lookup;
+    private _lookupAsDirectory;
+    private _lookupAsFile;
+    registerFile(file: RegisteredFileNode): IDisposable;
     stat(resource: URI): Promise<IStat>;
+    readdirSync(resource: URI): [string, FileType][];
     readdir(resource: URI): Promise<[string, FileType][]>;
     readFile(resource: URI): Promise<Uint8Array>;
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
     watch(): IDisposable;
-    writeFile(resource: URI, content: Uint8Array): Promise<void>;
+    writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
+    rename(): Promise<void>;
+    mkdirSync(resource: URI): RegisteredDirectoryNode;
+    mkdir(): Promise<void>;
+    private deleteSync;
     delete(resource: URI): Promise<void>;
-    rename(from: URI, to: URI): Promise<void>;
-    mkdir(): Promise<never>;
+    private _bufferedChanges;
+    private _fireSoonHandle?;
+    private _fireSoon;
 }
-declare class OverlayFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability {
+declare class OverlayFileSystemProvider implements IFileSystemProviderWithFileReadWriteCapability, IFileSystemProviderWithFileReadStreamCapability, IFileSystemProviderWithFileAtomicReadCapability, IFileSystemProviderWithFileAtomicWriteCapability, IFileSystemProviderWithFileAtomicDeleteCapability {
     private providers;
     register(priority: number, provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
     get delegates(): IFileSystemProviderWithFileReadWriteCapability[];
@@ -77,9 +125,11 @@ declare class OverlayFileSystemProvider implements IFileSystemProviderWithFileRe
     onDidChangeOverlays: Event<void>;
     capabilities: number;
     private readFromDelegates;
+    private readFromDelegatesSync;
     private writeToDelegates;
     stat(resource: URI): Promise<IStat>;
     readFile(resource: URI): Promise<Uint8Array>;
+    readFileStream(resource: URI, opts: IFileReadStreamOptions, token: CancellationToken): ReadableStreamEvents<Uint8Array>;
     readdir(resource: URI): Promise<[string, FileType][]>;
     watch(resource: URI, opts: IWatchOptions): IDisposable;
     writeFile(resource: URI, content: Uint8Array, opts: IFileWriteOptions): Promise<void>;
@@ -135,7 +185,7 @@ declare function getServiceOverride(): IEditorOverrideServices;
  * the default file system provider for a given scheme.
  */
 declare function registerCustomProvider(scheme: string, provider: IFileSystemProvider): void;
-declare function registerExtensionFile(extensionLocation: URI, filePath: string, getContent: () => Promise<string | Uint8Array>): IDisposable;
+declare function registerExtensionFile(file: RegisteredFileNode): IDisposable;
 /**
  * Can be used to create a file before the fileService is initialized
  */
@@ -162,4 +212,4 @@ declare function registerHTMLFileSystemProvider(): void;
  */
 declare function registerFileSystemOverlay(priority: number, provider: IFileSystemProviderWithFileReadWriteCapability): IDisposable;
 
-export { CustomSchemas, DelegateFileSystemProvider, EmptyFileSystemProvider, FileChangeType, FileSystemProviderCapabilities, FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, IndexedDBFileSystemProvider, OverlayFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, createIndexedDBProviders, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay, registerHTMLFileSystemProvider };
+export { CustomSchemas, DelegateFileSystemProvider, EmptyFileSystemProvider, type ExtensionFileMetadata, FileChangeType, FileSystemProviderCapabilities, FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions, IndexedDBFileSystemProvider, OverlayFileSystemProvider, RegisteredFile, RegisteredFileSystemProvider, RegisteredMemoryFile, RegisteredReadOnlyFile, RegisteredUriFile, createIndexedDBProviders, getServiceOverride as default, initFile, registerCustomProvider, registerExtensionFile, registerFileSystemOverlay, registerHTMLFileSystemProvider };

package/vscode/src/vs/editor/common/core/wordCharacterClassifier.d.ts

@@ -7,22 +7,17 @@ declare const enum WordCharacterClass {
 }
 declare class WordCharacterClassifier extends CharacterClassifier<WordCharacterClass> {
     readonly intlSegmenterLocales: Intl.UnicodeBCP47LocaleIdentifier[];
+    private readonly _segmenter;
+    private _cachedLine;
+    private _cachedSegments;
     constructor(wordSeparators: string, intlSegmenterLocales: Intl.UnicodeBCP47LocaleIdentifier[]);
     findPrevIntlWordBeforeOrAtOffset(line: string, offset: number): IntlWordSegmentData | null;
     findNextIntlWordAtOrAfterOffset(lineContent: string, offset: number): IntlWordSegmentData | null;
     private _getIntlSegmenterWordsOnLine;
+    private _filterWordSegments;
+    private _isWordLike;
 }
-interface IntlWordSegmentData {
-    /** A string containing the segment extracted from the original input string. */
-    segment: string;
-    /** The code unit index in the original input string at which the segment begins. */
-    index: number;
-    /** The complete input string that was segmented. */
-    input: string;
-    /**
-     * A boolean value only if granularity is "word"; otherwise, undefined.
-     * If granularity is "word", then isWordLike is true when the segment is word-like (i.e., consists of letters/numbers/ideographs/etc.); otherwise, false.
-     */
+interface IntlWordSegmentData extends Intl.SegmentData {
     isWordLike: true;
 }
 

package/vscode/src/vs/editor/common/core/wordCharacterClassifier.js

@@ -3,7 +3,16 @@ import { CharacterClassifier } from './characterClassifier.js';
 class WordCharacterClassifier extends CharacterClassifier {
     constructor(wordSeparators, intlSegmenterLocales) {
         super(0 );
+        this._segmenter = null;
+        this._cachedLine = null;
+        this._cachedSegments = [];
         this.intlSegmenterLocales = intlSegmenterLocales;
+        if (this.intlSegmenterLocales.length > 0) {
+            this._segmenter = new Intl.Segmenter(this.intlSegmenterLocales, { granularity: 'word' });
+        }
+        else {
+            this._segmenter = null;
+        }
         for (let i = 0, len = wordSeparators.length; i < len; i++) {
             this.set(wordSeparators.charCodeAt(i), 2 );
         }
@@ -30,7 +39,30 @@ class WordCharacterClassifier extends CharacterClassifier {
         return null;
     }
     _getIntlSegmenterWordsOnLine(line) {
-        return [];
+        if (!this._segmenter) {
+            return [];
+        }
+        if (this._cachedLine === line) {
+            return this._cachedSegments;
+        }
+        this._cachedLine = line;
+        this._cachedSegments = this._filterWordSegments(this._segmenter.segment(line));
+        return this._cachedSegments;
+    }
+    _filterWordSegments(segments) {
+        const result = [];
+        for (const segment of segments) {
+            if (this._isWordLike(segment)) {
+                result.push(segment);
+            }
+        }
+        return result;
+    }
+    _isWordLike(segment) {
+        if (segment.isWordLike) {
+            return true;
+        }
+        return false;
     }
 }
 const wordClassifierCache = ( new LRUCache(10));

package/vscode/src/vs/platform/extensions/common/extensions.d.ts

@@ -1004,6 +1004,264 @@ interface IViewsWelcome {
      */
     readonly enablement?: string;
 }
+interface INamedProblemPattern extends IProblemPattern {
+    /**
+     * The name of the problem pattern.
+     */
+    name: string;
+    /**
+     * A human readable label
+     */
+    label?: string;
+}
+interface ICheckedProblemPattern extends IProblemPattern {
+    /**
+    * The regular expression to find a problem in the console output of an
+    * executed task.
+    */
+    regexp: string;
+}
+type MultiLineCheckedProblemPattern = ICheckedProblemPattern[];
+interface INamedMultiLineCheckedProblemPattern {
+    /**
+     * The name of the problem pattern.
+     */
+    name: string;
+    /**
+     * A human readable label
+     */
+    label?: string;
+    /**
+     * The actual patterns
+     */
+    patterns: MultiLineCheckedProblemPattern;
+}
+type NamedProblemPatterns = (INamedProblemPattern | INamedMultiLineCheckedProblemPattern)[];
+interface IProblemPattern {
+    /**
+    * The regular expression to find a problem in the console output of an
+    * executed task.
+    */
+    regexp?: string;
+    /**
+    * Whether the pattern matches a whole file, or a location (file/line)
+    *
+    * The default is to match for a location. Only valid on the
+    * first problem pattern in a multi line problem matcher.
+    */
+    kind?: string;
+    /**
+    * The match group index of the filename.
+    * If omitted 1 is used.
+    */
+    file?: number;
+    /**
+    * The match group index of the problem's location. Valid location
+    * patterns are: (line), (line,column) and (startLine,startColumn,endLine,endColumn).
+    * If omitted the line and column properties are used.
+    */
+    location?: number;
+    /**
+    * The match group index of the problem's line in the source file.
+    *
+    * Defaults to 2.
+    */
+    line?: number;
+    /**
+    * The match group index of the problem's column in the source file.
+    *
+    * Defaults to 3.
+    */
+    column?: number;
+    /**
+    * The match group index of the problem's end line in the source file.
+    *
+    * Defaults to undefined. No end line is captured.
+    */
+    endLine?: number;
+    /**
+    * The match group index of the problem's end column in the source file.
+    *
+    * Defaults to undefined. No end column is captured.
+    */
+    endColumn?: number;
+    /**
+    * The match group index of the problem's severity.
+    *
+    * Defaults to undefined. In this case the problem matcher's severity
+    * is used.
+    */
+    severity?: number;
+    /**
+    * The match group index of the problem's code.
+    *
+    * Defaults to undefined. No code is captured.
+    */
+    code?: number;
+    /**
+    * The match group index of the message. If omitted it defaults
+    * to 4 if location is specified. Otherwise it defaults to 5.
+    */
+    message?: number;
+    /**
+    * Specifies if the last pattern in a multi line problem matcher should
+    * loop as long as it does match a line consequently. Only valid on the
+    * last problem pattern in a multi line problem matcher.
+    */
+    loop?: boolean;
+}
+/**
+* A watching pattern
+*/
+interface IWatchingPattern {
+    /**
+    * The actual regular expression
+    */
+    regexp?: string;
+    /**
+    * The match group index of the filename. If provided the expression
+    * is matched for that file only.
+    */
+    file?: number;
+}
+/**
+* A description to track the start and end of a watching task.
+*/
+interface IBackgroundMonitor {
+    /**
+    * If set to true the watcher is in active mode when the task
+    * starts. This is equals of issuing a line that matches the
+    * beginsPattern.
+    */
+    activeOnStart?: boolean;
+    /**
+    * If matched in the output the start of a watching task is signaled.
+    */
+    beginsPattern?: string | IWatchingPattern;
+    /**
+    * If matched in the output the end of a watching task is signaled.
+    */
+    endsPattern?: string | IWatchingPattern;
+}
+interface INamedProblemMatcher {
+    /**
+    * This name can be used to refer to the
+    * problem matcher from within a task.
+    */
+    name: string;
+    /**
+     * A human readable label.
+     */
+    label?: string;
+    /**
+     * The name of a base problem matcher to use. If specified the
+     * base problem matcher will be used as a template and properties
+     * specified here will replace properties of the base problem
+     * matcher
+     */
+    base?: string;
+    /**
+     * The owner of the produced VSCode problem. This is typically
+     * the identifier of a VSCode language service if the problems are
+     * to be merged with the one produced by the language service
+     * or a generated internal id. Defaults to the generated internal id.
+     */
+    owner?: string;
+    /**
+     * A human-readable string describing the source of this problem.
+     * E.g. 'typescript' or 'super lint'.
+     */
+    source?: string;
+    /**
+    * Specifies to which kind of documents the problems found by this
+    * matcher are applied. Valid values are:
+    *
+    *   "allDocuments": problems found in all documents are applied.
+    *   "openDocuments": problems found in documents that are open
+    *   are applied.
+    *   "closedDocuments": problems found in closed documents are
+    *   applied.
+    */
+    applyTo?: string;
+    /**
+    * The severity of the VSCode problem produced by this problem matcher.
+    *
+    * Valid values are:
+    *   "error": to produce errors.
+    *   "warning": to produce warnings.
+    *   "info": to produce infos.
+    *
+    * The value is used if a pattern doesn't specify a severity match group.
+    * Defaults to "error" if omitted.
+    */
+    severity?: string;
+    /**
+    * Defines how filename reported in a problem pattern
+    * should be read. Valid values are:
+    *  - "absolute": the filename is always treated absolute.
+    *  - "relative": the filename is always treated relative to
+    *    the current working directory. This is the default.
+    *  - ["relative", "path value"]: the filename is always
+    *    treated relative to the given path value.
+    *  - "autodetect": the filename is treated relative to
+    *    the current workspace directory, and if the file
+    *    does not exist, it is treated as absolute.
+    *  - ["autodetect", "path value"]: the filename is treated
+    *    relative to the given path value, and if it does not
+    *    exist, it is treated as absolute.
+    *  - ["search", { include?: "" | []; exclude?: "" | [] }]: The filename
+    *    needs to be searched under the directories named by the "include"
+    *    property and their nested subdirectories. With "exclude" property
+    *    present, the directories should be removed from the search. When
+    *    `include` is not unprovided, the current workspace directory should
+    *    be used as the default.
+    */
+    fileLocation?: string | string[] | ['search', ISearchFileLocationArgs];
+    /**
+    * The name of a predefined problem pattern, the inline definition
+    * of a problem pattern or an array of problem patterns to match
+    * problems spread over multiple lines.
+    */
+    pattern?: string | IProblemPattern | IProblemPattern[];
+    /**
+    * A regular expression signaling that a watched tasks begins executing
+    * triggered through file watching.
+    */
+    watchedTaskBeginsRegExp?: string;
+    /**
+    * A regular expression signaling that a watched tasks ends executing.
+    */
+    watchedTaskEndsRegExp?: string;
+    /**
+     * @deprecated Use background instead.
+     */
+    watching?: IBackgroundMonitor;
+    background?: IBackgroundMonitor;
+}
+type ISearchFileLocationArgs = {
+    include?: string | string[];
+    exclude?: string | string[];
+};
+interface ITypescriptServerPlugin {
+    /**
+     * Name of the plugin as listed in the package.json.
+     */
+    name: string;
+    /**
+     * Should the plugin be loaded when using workspace versions of TypeScript?
+     */
+    enableForWorkspaceTypeScriptVersions: boolean;
+}
+interface IHtmlLanguageParticipant {
+    /**
+     * The id of the language that participates with HTML language server.
+     */
+    languageId: string;
+    /**
+     * Whether the language participates with HTML auto insertions. If not specified, defaults to <code>true</code>.
+     */
+    autoInsert: boolean;
+}
 interface IExtensionContributions {
     /**
      * Contributes terminal functionality.
@@ -1170,6 +1428,28 @@ interface IExtensionContributions {
      * Contributed views welcome content. Welcome content will be rendered in tree based views whenever they have no meaningful content to display, ie. the File Explorer when no folder is open. Such content is useful as in-product documentation to drive users to use certain features before they are available. A good example would be a `Clone Repository` button in the File Explorer welcome view.
      */
     readonly viewsWelcome?: IViewsWelcome[];
+    /**
+     * Contributes problem matchers
+     */
+    readonly problemMatchers?: INamedProblemMatcher[];
+    /**
+     * Contributes problem patterns
+     */
+    readonly problemPatterns?: NamedProblemPatterns;
+    /**
+     * Contributed TypeScript server plugins.
+     */
+    readonly typescriptServerPlugins?: ITypescriptServerPlugin[];
+    /**
+     * A list of languages that participate with the HTML language server.
+     */
+    readonly htmlLanguageParticipants?: IHtmlLanguageParticipant[];
+    readonly html?: {
+        customData?: string[];
+    };
+    readonly css?: {
+        customData?: string[];
+    };
 }
 interface IExtensionCapabilities {
     readonly virtualWorkspaces?: ExtensionVirtualWorkspaceSupport;
@@ -1319,4 +1599,4 @@ interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest {
 }
 type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
 
-export { ExtensionIdentifier, ExtensionIdentifierMap, ExtensionType, type ExtensionUntrustedWorkspaceSupport, type ExtensionUntrustedWorkspaceSupportType, type ExtensionVirtualWorkspaceSupport, type ExtensionVirtualWorkspaceSupportType, type IAuthenticationContribution, type IBreakpoint, type ICodeActionContribution, type ICodeActionContributionAction, type IColor, type IColorTheme, type ICommand, type IConfiguration, type IDebugVisualizationContribution, type IDebugger, type IDocumentation, type IDocumentationRefactoring, type IExtension, type IExtensionCapabilities, type IExtensionContributions, type IExtensionDescription, type IExtensionIdentifier, type IExtensionManifest, type IGrammar, type IIcon, type IIconTheme, type IInteractiveSession, type IJSONValidation, type IKeyBinding, type ILanguage, type ILocalizationContribution, type IMenu, type INotebookEntry, type INotebookRendererContribution, type IProductTheme, type IRelaxedExtensionDescription, type IRelaxedExtensionManifest, type IRemoteHelp, type ISemanticTokenModifiers, type ISemanticTokenScopes, type ISemanticTokenTypes, type ISnippet, type IStartEntry, type IStatusBarItem, type ISubMenu, type ITaskDefinitions, type ITerminal, type ITerminalQuickFix, type ITranslation, type IView, type IViewContainer, type IViewsWelcome, type IWalkthrough, type IWalkthroughStep, type LimitedWorkspaceSupportType, type NotebookPreload, TargetPlatform };
+export { ExtensionIdentifier, ExtensionIdentifierMap, ExtensionType, type ExtensionUntrustedWorkspaceSupport, type ExtensionUntrustedWorkspaceSupportType, type ExtensionVirtualWorkspaceSupport, type ExtensionVirtualWorkspaceSupportType, type IAuthenticationContribution, type IBackgroundMonitor, type IBreakpoint, type ICheckedProblemPattern, type ICodeActionContribution, type ICodeActionContributionAction, type IColor, type IColorTheme, type ICommand, type IConfiguration, type IDebugVisualizationContribution, type IDebugger, type IDocumentation, type IDocumentationRefactoring, type IExtension, type IExtensionCapabilities, type IExtensionContributions, type IExtensionDescription, type IExtensionIdentifier, type IExtensionManifest, type IGrammar, type IHtmlLanguageParticipant, type IIcon, type IIconTheme, type IInteractiveSession, type IJSONValidation, type IKeyBinding, type ILanguage, type ILocalizationContribution, type IMenu, type INamedMultiLineCheckedProblemPattern, type INamedProblemMatcher, type INamedProblemPattern, type INotebookEntry, type INotebookRendererContribution, type IProblemPattern, type IProductTheme, type IRelaxedExtensionDescription, type IRelaxedExtensionManifest, type IRemoteHelp, type ISearchFileLocationArgs, type ISemanticTokenModifiers, type ISemanticTokenScopes, type ISemanticTokenTypes, type ISnippet, type IStartEntry, type IStatusBarItem, type ISubMenu, type ITaskDefinitions, type ITerminal, type ITerminalQuickFix, type ITranslation, type ITypescriptServerPlugin, type IView, type IViewContainer, type IViewsWelcome, type IWalkthrough, type IWalkthroughStep, type IWatchingPattern, type LimitedWorkspaceSupportType, type MultiLineCheckedProblemPattern, type NamedProblemPatterns, type NotebookPreload, TargetPlatform };