@codingame/monaco-vscode-api 1.69.0 → 1.69.1

package/dist/languageConfiguration.js

@@ -11,10 +11,10 @@ import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/commo
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
 import { IndentAction } from 'monaco-editor/esm/vs/editor/common/languages/languageConfiguration.js';
+import { o as onServicesInitialized } from './tools.js';
 import { S as Services } from './services2.js';
 import { bd as DEFAULT_EXTENSION } from './extHost.js';
-import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
 function isStringArr(something) {
     if (!Array.isArray(something)) {
         return false;
@@ -909,19 +909,15 @@ const schema = {
 };
 const schemaRegistry = ( Registry.as(Extensions.JSONContribution));
 schemaRegistry.registerSchema(schemaId, schema);
-function setLanguageConfiguration(resource, getConfiguration) {
+function setLanguageConfiguration(path, getConfiguration) {
     const extension = Services.get().extension ?? DEFAULT_EXTENSION;
-    if (resource.scheme !== extension.extensionLocation.scheme) {
-        throw new Error(`The provided resource url should have the ${extension.extensionLocation.scheme} scheme`);
-    }
-    registerExtensionFile(resource, getConfiguration);
+    registerExtensionFile(joinPath(extension.extensionLocation, path), getConfiguration);
 }
-function initialize() {
-    const instantiationService = StandaloneServices.get(IInstantiationService);
+function initialize(instantiationService) {
     instantiationService.createInstance(LanguageConfigurationFileHandler);
 }
 function getServiceOverride() {
-    setTimeout(initialize);
+    onServicesInitialized(initialize);
     return {
         ...getServiceOverride$1()
     };

package/dist/languageService.js

@@ -1,5 +1,5 @@
 import { _ as __decorate, a as __param } from './tslib.es6.js';
-import { M as ExtensionsRegistry, I as IExtensionService } from './missing-services.js';
+import { h as ExtensionsRegistry, I as IExtensionService } from './missing-services.js';
 import { Y as FILES_ASSOCIATIONS_CONFIG } from './services2.js';
 import { parse } from 'monaco-editor/esm/vs/base/common/glob.js';
 import { posix } from 'monaco-editor/esm/vs/base/common/path.js';

package/dist/messages.js

@@ -54,6 +54,7 @@ import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+import { o as onServicesInitialized } from './tools.js';
 function isErrorWithActions(obj) {
     const candidate = obj;
     return candidate instanceof Error && Array.isArray(candidate.actions);
@@ -3591,11 +3592,10 @@ function getServiceOverride$1(container = document.body) {
         [( IWorkbenchLayoutService.toString())]: new SyncDescriptor(LayoutService, [container])
     };
 }
-function register() {
+function initialize(instantiationService) {
     const container = StandaloneServices.get(ILayoutService).container;
     container.classList.add('monaco-workbench');
-    const model = StandaloneServices.get(INotificationService).model;
-    const instantiationService = StandaloneServices.get(IInstantiationService);
+    const model = instantiationService.invokeFunction((accessor) => accessor.get(INotificationService)).model;
     const notificationsToasts = instantiationService.createInstance(NotificationsToasts, container, model);
     notificationsToasts.layout(getClientArea(container));
     const notificationsCenter = {
@@ -3611,10 +3611,10 @@ function register() {
         }
     };
     registerNotificationCommands(notificationsCenter, notificationsToasts, model);
-    StandaloneServices.get(IInstantiationService).createInstance(DialogHandlerContribution);
+    instantiationService.createInstance(DialogHandlerContribution);
 }
 function getServiceOverride(container) {
-    setTimeout(() => register());
+    onServicesInitialized(initialize);
     return {
         [( IDialogService.toString())]: new SyncDescriptor(DialogService),
         [( INotificationService.toString())]: new SyncDescriptor(NotificationService),

package/dist/missing-services.js

@@ -7290,4 +7290,4 @@ registerSingleton(ISnippetsService, class SnippetsService {
         this.getSnippetsSync = unsupported;
     }
 });
-export { isReadableBufferedStream as A, Barrier as B, listenStream as C, bufferedStreamToBuffer as D, Emitter as E, readableToBuffer as F, newWriteableBufferStream as G, newWriteableStream as H, IExtensionService as I, IUserDataProfileService as J, IKeyboardLayoutService as K, IPreferencesService as L, ExtensionsRegistry as M, NotImplementedError as N, ExtensionMessageCollector as O, parse as P, ITextMateService as Q, ResourceSet as R, getNodeType as S, IBrowserWorkbenchEnvironmentService as T, UserSettings as U, IHostColorSchemeService as V, IUserDataInitializationService as W, Sequencer as X, isProposedApiEnabled as a, readonly as b, checkProposedApiEnabled as c, disposed as d, ILifecycleService as e, IntervalCounter as f, assertAllDefined as g, ILanguageDetectionService as h, isStringArray as i, IPolicyService as j, IUserDataProfilesService as k, isEmptyObject as l, NullPolicyService as m, format2 as n, getServiceMachineId as o, ResourceQueue as p, isReadableStream as q, raceCancellationError as r, peekStream as s, peekReadable as t, unsupported as u, bufferToReadable as v, withUndefinedAsNull as w, streamToBuffer as x, consumeStream as y, transform as z };
+export { transform as A, Barrier as B, isReadableBufferedStream as C, listenStream as D, Emitter as E, bufferedStreamToBuffer as F, readableToBuffer as G, newWriteableBufferStream as H, IExtensionService as I, newWriteableStream as J, IUserDataProfileService as K, IKeyboardLayoutService as L, IPreferencesService as M, NotImplementedError as N, ExtensionMessageCollector as O, parse as P, ITextMateService as Q, ResourceSet as R, getNodeType as S, IBrowserWorkbenchEnvironmentService as T, UserSettings as U, IHostColorSchemeService as V, IUserDataInitializationService as W, Sequencer as X, isProposedApiEnabled as a, readonly as b, checkProposedApiEnabled as c, disposed as d, ILifecycleService as e, IntervalCounter as f, assertAllDefined as g, ExtensionsRegistry as h, isStringArray as i, ILanguageDetectionService as j, IPolicyService as k, IUserDataProfilesService as l, isEmptyObject as m, NullPolicyService as n, format2 as o, getServiceMachineId as p, ResourceQueue as q, raceCancellationError as r, isReadableStream as s, peekStream as t, unsupported as u, peekReadable as v, withUndefinedAsNull as w, bufferToReadable as x, streamToBuffer as y, consumeStream as z };

package/dist/modelEditor.js

@@ -1,5 +1,5 @@
 import { _ as __decorate, a as __param } from './tslib.es6.js';
-import { h as ILanguageDetectionService, w as withUndefinedAsNull, E as Emitter, u as unsupported } from './missing-services.js';
+import { j as ILanguageDetectionService, w as withUndefinedAsNull, E as Emitter, u as unsupported } from './missing-services.js';
 import { MutableDisposable, Disposable, toDisposable, ImmortalReference, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
 import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';

package/dist/monaco.d.ts

@@ -683,12 +683,6 @@ interface IContextKeyService {
     updateParent(parentContextKeyService: IContextKeyService): void;
 }
 
-/**
- * An interface for a JavaScript object that
- * acts a dictionary. The keys are strings.
- */
-declare type IStringDictionary<V> = Record<string, V>;
-
 declare type JSONSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'null' | 'array' | 'object';
 interface IJSONSchema {
     id?: string;
@@ -778,98 +772,6 @@ interface IJSONSchemaSnippet {
     bodyText?: string;
 }
 
-declare type PolicyName = string;
-
-declare enum EditPresentationTypes {
-    Multiline = "multilineText",
-    Singleline = "singlelineText"
-}
-declare const enum ConfigurationScope {
-    /**
-     * Application specific configuration, which can be configured only in local user settings.
-     */
-    APPLICATION = 1,
-    /**
-     * Machine specific configuration, which can be configured only in local and remote user settings.
-     */
-    MACHINE = 2,
-    /**
-     * Window specific configuration, which can be configured in the user or workspace settings.
-     */
-    WINDOW = 3,
-    /**
-     * Resource specific configuration, which can be configured in the user, workspace or folder settings.
-     */
-    RESOURCE = 4,
-    /**
-     * Resource specific configuration that can be configured in language specific settings
-     */
-    LANGUAGE_OVERRIDABLE = 5,
-    /**
-     * Machine specific configuration that can also be configured in workspace or folder settings.
-     */
-    MACHINE_OVERRIDABLE = 6
-}
-interface IPolicy {
-    /**
-     * The policy name.
-     */
-    readonly name: PolicyName;
-    /**
-     * The Code version in which this policy was introduced.
-     */
-    readonly minimumVersion: `${number}.${number}`;
-}
-interface IConfigurationPropertySchema extends IJSONSchema {
-    scope?: ConfigurationScope;
-    /**
-     * When restricted, value of this configuration will be read only from trusted sources.
-     * For eg., If the workspace is not trusted, then the value of this configuration is not read from workspace settings file.
-     */
-    restricted?: boolean;
-    /**
-     * When `false` this property is excluded from the registry. Default is to include.
-     */
-    included?: boolean;
-    /**
-     * List of tags associated to the property.
-     *  - A tag can be used for filtering
-     *  - Use `experimental` tag for marking the setting as experimental. **Note:** Defaults of experimental settings can be changed by the running experiments.
-     */
-    tags?: string[];
-    /**
-     * When enabled this setting is ignored during sync and user can override this.
-     */
-    ignoreSync?: boolean;
-    /**
-     * When enabled this setting is ignored during sync and user cannot override this.
-     */
-    disallowSyncIgnore?: boolean;
-    /**
-     * Labels for enumeration items
-     */
-    enumItemLabels?: string[];
-    /**
-     * When specified, controls the presentation format of string settings.
-     * Otherwise, the presentation format defaults to `singleline`.
-     */
-    editPresentation?: EditPresentationTypes;
-    /**
-     * When specified, gives an order number for the setting
-     * within the settings editor. Otherwise, the setting is placed at the end.
-     */
-    order?: number;
-    /**
-     * When specified, this setting's value can always be overwritten by
-     * a system-wide policy.
-     */
-    policy?: IPolicy;
-}
-declare const allSettings: {
-    properties: IStringDictionary<IConfigurationPropertySchema>;
-    patternProperties: IStringDictionary<IConfigurationPropertySchema>;
-};
-
 /**
  * Configuration options for auto indentation in the editor
  */
@@ -1862,6 +1764,171 @@ interface IconDefinition {
     fontCharacter: string;
 }
 
+declare class RGBA {
+    _rgbaBrand: void;
+    /**
+     * Red: integer in [0-255]
+     */
+    readonly r: number;
+    /**
+     * Green: integer in [0-255]
+     */
+    readonly g: number;
+    /**
+     * Blue: integer in [0-255]
+     */
+    readonly b: number;
+    /**
+     * Alpha: float in [0-1]
+     */
+    readonly a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+    static equals(a: RGBA, b: RGBA): boolean;
+}
+declare class HSLA {
+    _hslaBrand: void;
+    /**
+     * Hue: integer in [0, 360]
+     */
+    readonly h: number;
+    /**
+     * Saturation: float in [0, 1]
+     */
+    readonly s: number;
+    /**
+     * Luminosity: float in [0, 1]
+     */
+    readonly l: number;
+    /**
+     * Alpha: float in [0, 1]
+     */
+    readonly a: number;
+    constructor(h: number, s: number, l: number, a: number);
+    static equals(a: HSLA, b: HSLA): boolean;
+    /**
+     * Converts an RGB color value to HSL. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes r, g, and b are contained in the set [0, 255] and
+     * returns h in the set [0, 360], s, and l in the set [0, 1].
+     */
+    static fromRGBA(rgba: RGBA): HSLA;
+    private static _hue2rgb;
+    /**
+     * Converts an HSL color value to RGB. Conversion formula
+     * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+     * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and
+     * returns r, g, and b in the set [0, 255].
+     */
+    static toRGBA(hsla: HSLA): RGBA;
+}
+declare class HSVA {
+    _hsvaBrand: void;
+    /**
+     * Hue: integer in [0, 360]
+     */
+    readonly h: number;
+    /**
+     * Saturation: float in [0, 1]
+     */
+    readonly s: number;
+    /**
+     * Value: float in [0, 1]
+     */
+    readonly v: number;
+    /**
+     * Alpha: float in [0, 1]
+     */
+    readonly a: number;
+    constructor(h: number, s: number, v: number, a: number);
+    static equals(a: HSVA, b: HSVA): boolean;
+    static fromRGBA(rgba: RGBA): HSVA;
+    static toRGBA(hsva: HSVA): RGBA;
+}
+declare class Color {
+    static fromHex(hex: string): Color;
+    readonly rgba: RGBA;
+    private _hsla?;
+    get hsla(): HSLA;
+    private _hsva?;
+    get hsva(): HSVA;
+    constructor(arg: RGBA | HSLA | HSVA);
+    equals(other: Color | null): boolean;
+    /**
+     * http://www.w3.org/TR/WCAG20/#relativeluminancedef
+     * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.
+     */
+    getRelativeLuminance(): number;
+    private static _relativeLuminanceForComponent;
+    /**
+     * http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+     * Returns the contrast ration number in the set [1, 21].
+     */
+    getContrastRatio(another: Color): number;
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if darker color otherwise 'false'
+     */
+    isDarker(): boolean;
+    /**
+     *	http://24ways.org/2010/calculating-color-contrast
+     *  Return 'true' if lighter color otherwise 'false'
+     */
+    isLighter(): boolean;
+    isLighterThan(another: Color): boolean;
+    isDarkerThan(another: Color): boolean;
+    lighten(factor: number): Color;
+    darken(factor: number): Color;
+    transparent(factor: number): Color;
+    isTransparent(): boolean;
+    isOpaque(): boolean;
+    opposite(): Color;
+    blend(c: Color): Color;
+    makeOpaque(opaqueBackground: Color): Color;
+    flatten(...backgrounds: Color[]): Color;
+    private static _flatten;
+    private _toString?;
+    toString(): string;
+    static getLighterColor(of: Color, relative: Color, factor?: number): Color;
+    static getDarkerColor(of: Color, relative: Color, factor?: number): Color;
+    static readonly white: Color;
+    static readonly black: Color;
+    static readonly red: Color;
+    static readonly blue: Color;
+    static readonly green: Color;
+    static readonly cyan: Color;
+    static readonly lightgrey: Color;
+    static readonly transparent: Color;
+}
+declare namespace Color {
+    namespace Format {
+        namespace CSS {
+            function formatRGB(color: Color): string;
+            function formatRGBA(color: Color): string;
+            function formatHSL(color: Color): string;
+            function formatHSLA(color: Color): string;
+            /**
+             * Formats the color as #RRGGBB
+             */
+            function formatHex(color: Color): string;
+            /**
+             * Formats the color as #RRGGBBAA
+             * If 'compact' is set, colors without transparancy will be printed as #RRGGBB
+             */
+            function formatHexA(color: Color, compact?: boolean): string;
+            /**
+             * The default format will use HEX if opaque and RGBA otherwise.
+             */
+            function format(color: Color): string;
+            /**
+             * Converts an Hex color value to a Color.
+             * returns r, g, and b are contained in the set [0, 255]
+             * @param hex string (#RGB, #RGBA, #RRGGBB or #RRGGBBAA).
+             */
+            function parseHex(hex: string): Color | null;
+        }
+    }
+}
+
 interface IDataTransferFile {
     readonly name: string;
     readonly uri?: URI;
@@ -2012,6 +2079,54 @@ declare namespace IMarkerData {
     function makeKeyOptionalMessage(markerData: IMarkerData, useMessage: boolean): string;
 }
 
+declare type ColorIdentifier = string;
+declare const enum ColorTransformType {
+    Darken = 0,
+    Lighten = 1,
+    Transparent = 2,
+    OneOf = 3,
+    LessProminent = 4,
+    IfDefinedThenElse = 5
+}
+declare type ColorTransform = {
+    op: ColorTransformType.Darken;
+    value: ColorValue;
+    factor: number;
+} | {
+    op: ColorTransformType.Lighten;
+    value: ColorValue;
+    factor: number;
+} | {
+    op: ColorTransformType.Transparent;
+    value: ColorValue;
+    factor: number;
+} | {
+    op: ColorTransformType.OneOf;
+    values: readonly ColorValue[];
+} | {
+    op: ColorTransformType.LessProminent;
+    value: ColorValue;
+    background: ColorValue;
+    factor: number;
+    transparency: number;
+} | {
+    op: ColorTransformType.IfDefinedThenElse;
+    if: ColorIdentifier;
+    then: ColorValue;
+    else: ColorValue;
+};
+interface ColorDefaults {
+    light: ColorValue | null;
+    dark: ColorValue | null;
+    hcDark: ColorValue | null;
+    hcLight: ColorValue | null;
+}
+/**
+ * A Color Value is either a color literal, a reference to an other color or a derived color
+ */
+declare type ColorValue = Color | string | ColorIdentifier | ColorTransform;
+declare function registerColor(id: string, defaults: ColorDefaults | null, description: string, needsTransparency?: boolean, deprecationMessage?: string): ColorIdentifier;
+
 interface ThemeColor {
     id: string;
 }
@@ -4789,7 +4904,11 @@ interface IJSONContributionRegistry {
 declare const createConfiguredEditor: typeof create;
 declare const createConfiguredDiffEditor: typeof createDiffEditor;
 declare const Extensions: {
+    Configuration: string;
     JSONContribution: string;
 };
+declare type FileMatch = Partial<Record<string, string[]>>;
+declare function getJsonSchemas(fileMatchs?: FileMatch): monaco.languages.json.DiagnosticsOptions['schemas'];
+declare const onDidChangeJsonSchema: Event<string>;
 
-export { CommandsRegistry, DisposableStore, Extensions, FoldingController, FoldingModel, IJSONContributionRegistry, IJSONSchema, Registry, allSettings, createConfiguredDiffEditor, createConfiguredEditor, errorHandler, setCollapseStateForMatchingLines };
+export { CommandsRegistry, DisposableStore, Extensions, FoldingController, FoldingModel, IJSONContributionRegistry, IJSONSchema, Registry, createConfiguredDiffEditor, createConfiguredEditor, errorHandler, getJsonSchemas, onDidChangeJsonSchema, registerColor, setCollapseStateForMatchingLines };

package/dist/monaco.js

@@ -1,12 +1,16 @@
 import { _ as __decorate, a as __param } from './tslib.es6.js';
-import { c as createInjectedClass } from './injection.js';
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+export { registerColor } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
+import { c as createInjectedClass } from './injection.js';
 import { editorOptionsRegistry } from 'monaco-editor/esm/vs/editor/common/config/editorOptions.js';
 import { equals as equals$1 } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+export { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { Extensions as Extensions$1 } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
+import { Extensions as Extensions$2 } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 import { StandaloneDiffEditor, StandaloneEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
 import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
 import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
@@ -14,9 +18,7 @@ export { errorHandler } from 'monaco-editor/esm/vs/base/common/errors.js';
 export { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 export { FoldingController } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/folding.js';
 export { FoldingModel, setCollapseStateForMatchingLines } from 'monaco-editor/esm/vs/editor/contrib/folding/browser/foldingModel.js';
-export { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 export { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
-export { allSettings } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
 function equals(one, other) {
     if (one === other) {
         return true;
@@ -238,6 +240,22 @@ const createConfiguredDiffEditor = (domElement, options, override) => {
     return instantiationService.createInstance(ConfiguredStandaloneDiffEditor, domElement, options);
 };
 const Extensions = {
-    ...Extensions$1
+    ...Extensions$1,
+    ...Extensions$2
 };
-export { Extensions, createConfiguredDiffEditor, createConfiguredEditor };
+const registry = ( Registry.as(Extensions.JSONContribution));
+function getJsonSchemas(fileMatchs = {}) {
+    return Object.entries(registry.getSchemaContributions().schemas)
+        .filter(([uri]) => uri !== 'vscode://schemas/vscode-extensions')
+        .map(([uri, schema]) => {
+        const path = monaco.Uri.parse(uri).path;
+        const schemaName = path.slice(1);
+        return {
+            uri,
+            schema,
+            fileMatch: schemaName != null ? fileMatchs[schemaName] : undefined
+        };
+    });
+}
+const onDidChangeJsonSchema = registry.onDidChangeSchema;
+export { Extensions, createConfiguredDiffEditor, createConfiguredEditor, getJsonSchemas, onDidChangeJsonSchema };

package/dist/services2.js

@@ -420,4 +420,4 @@ var Services;
     }
     Services.install = install;
 })(Services || (Services = {})));
-export { ACTIVE_GROUP as A, FileOperationError as B, CancellationTokenSource as C, hasOpenReadWriteCloseCapability as D, hasReadWriteCapability as E, FileType as F, hasFileReadStreamCapability as G, toFileSystemProviderErrorCode as H, IFileService as I, ensureFileSystemProviderError as J, etag as K, FileOperationEvent as L, toFileOperationResult as M, NoOpNotification as N, ETAG_DISABLED as O, hasFileAtomicReadCapability as P, NotModifiedSinceFileOperationError as Q, hasFileFolderCopyCapability as R, Services as S, hasFileCloneCapability as T, FileSystemProviderError as U, createFileSystemProviderError as V, index as W, flatten as X, FILES_ASSOCIATIONS_CONFIG as Y, FilePermission as a, IUriIdentityService as b, IEditorService as c, IPaneCompositePartService as d, ITextFileService as e, IEditorGroupsService as f, IWorkbenchEnvironmentService as g, IWorkingCopyFileService as h, IPathService as i, IProductService as j, ILanguageStatusService as k, IHostService as l, ISnippetsService as m, coalesceInPlace as n, markAsFileSystemProviderError as o, productSchemaId as p, FileSystemProviderErrorCode as q, refineServiceDecorator as r, shuffle as s, mapArrayOrNot as t, SIDE_GROUP as u, delta as v, NotificationsFilter as w, NeverShowAgainScope as x, isPreferredGroup as y, FileChangesEvent as z };
+export { ACTIVE_GROUP as A, FileChangesEvent as B, CancellationTokenSource as C, FileOperationError as D, hasOpenReadWriteCloseCapability as E, FileType as F, hasReadWriteCapability as G, hasFileReadStreamCapability as H, IFileService as I, toFileSystemProviderErrorCode as J, ensureFileSystemProviderError as K, etag as L, FileOperationEvent as M, NoOpNotification as N, toFileOperationResult as O, ETAG_DISABLED as P, hasFileAtomicReadCapability as Q, NotModifiedSinceFileOperationError as R, Services as S, hasFileFolderCopyCapability as T, hasFileCloneCapability as U, createFileSystemProviderError as V, index as W, flatten as X, FILES_ASSOCIATIONS_CONFIG as Y, FilePermission as a, IUriIdentityService as b, IEditorService as c, IPaneCompositePartService as d, ITextFileService as e, IEditorGroupsService as f, IWorkbenchEnvironmentService as g, IWorkingCopyFileService as h, IPathService as i, IProductService as j, ILanguageStatusService as k, IHostService as l, ISnippetsService as m, coalesceInPlace as n, markAsFileSystemProviderError as o, productSchemaId as p, FileSystemProviderErrorCode as q, refineServiceDecorator as r, shuffle as s, mapArrayOrNot as t, SIDE_GROUP as u, delta as v, NotificationsFilter as w, NeverShowAgainScope as x, isPreferredGroup as y, FileSystemProviderError as z };

package/dist/snippets.js

@@ -1,4 +1,4 @@
-import { J as IUserDataProfileService, e as ILifecycleService, O as ExtensionMessageCollector, i as isStringArray, P as parse, S as getNodeType, M as ExtensionsRegistry, u as unsupported } from './missing-services.js';
+import { K as IUserDataProfileService, e as ILifecycleService, O as ExtensionMessageCollector, i as isStringArray, P as parse, S as getNodeType, h as ExtensionsRegistry } from './missing-services.js';
 import { m as ISnippetsService, I as IFileService, e as ITextFileService, S as Services } from './services2.js';
 import { _ as __decorate, a as __param } from './tslib.es6.js';
 import * as monacoSuggest from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggest.js';
@@ -12,7 +12,7 @@ import { SnippetParser, Placeholder, Variable, Text } from 'monaco-editor/esm/vs
 import { tail, insertInto } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { KnownSnippetVariableNames } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetVariables.js';
 import { l as languagesExtPoint } from './languageService.js';
-import { bd as DEFAULT_EXTENSION, bj as Range$2 } from './extHost.js';
+import { bd as DEFAULT_EXTENSION, bk as Range$2 } from './extHost.js';
 import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { getWordAtText } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
 import { isPatternInWord } from 'monaco-editor/esm/vs/base/common/filters.js';
@@ -25,13 +25,13 @@ import { I as IExtensionResourceLoaderService, r as registerExtensionFile } from
 import { DisposableStore, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
-import { IWorkspaceContextService, WorkspaceFolder } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { g as getExtensionPoint, c as consoleExtensionMessageHandler } from './tools.js';
+import { g as getExtensionPoint, c as consoleExtensionMessageHandler, o as onServicesInitialized } from './tools.js';
+import { g as getServiceOverride$1 } from './workspaceContext.js';
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 function setSnippetSuggestSupport (support) {
   if (monacoSuggest.setSnippetSuggestSupport != null) {
     monacoSuggest.setSnippetSuggestSupport(support);
@@ -840,49 +840,6 @@ SnippetsService = ( (__decorate([
     ( (__param(9, IInstantiationService))),
     ( (__param(10, ILanguageConfigurationService)))
 ], SnippetsService)));
-class SimpleWorkspaceContextService {
-    constructor() {
-        this.onDidChangeWorkspaceName = Event.None;
-        this.onWillChangeWorkspaceFolders = Event.None;
-        this.onDidChangeWorkspaceFolders = Event.None;
-        this.onDidChangeWorkbenchState = Event.None;
-        this.isCurrentWorkspace = unsupported;
-    }
-    getCompleteWorkspace() {
-        return Promise.resolve(this.getWorkspace());
-    }
-    getWorkspace() {
-        const workspaceFolders = Services.get().workspace?.workspaceFolders;
-        return {
-            id: '4064f6ec-cb38-4ad0-af64-ee6467e63c82',
-            folders: workspaceFolders?.map(folder => new WorkspaceFolder(folder)) ?? []
-        };
-    }
-    getWorkbenchState() {
-        const workspaceFoldersCount = Services.get().workspace?.workspaceFolders?.length ?? 1;
-        if (workspaceFoldersCount === 0) {
-            return 1 ;
-        }
-        else if (workspaceFoldersCount === 1) {
-            return 2 ;
-        }
-        else {
-            return 3 ;
-        }
-    }
-    getWorkspaceFolder(resource) {
-        const workspace = this.getWorkspace();
-        return workspace.folders.find(folder => folder.uri.scheme === resource.scheme && resource.path.startsWith(folder.uri.path)) ?? null;
-    }
-    isInsideWorkspace(resource) {
-        return this.getWorkspaceFolder(resource) != null;
-    }
-}
-function getServiceOverride$1() {
-    return {
-        [( IWorkspaceContextService.toString())]: new SyncDescriptor(SimpleWorkspaceContextService)
-    };
-}
 const snippetExtensionPoint = getExtensionPoint('snippets');
 function setSnippets(snippets, getContent, extension = Services.get().extension ?? DEFAULT_EXTENSION) {
     snippetExtensionPoint.acceptUsers([{
@@ -894,7 +851,11 @@ function setSnippets(snippets, getContent, extension = Services.get().extension
         registerExtensionFile(joinPath(extension.extensionLocation, snippet.path), () => getContent(snippet));
     }
 }
+function initialize(instantiationService) {
+    instantiationService.invokeFunction((accessor) => accessor.get(ISnippetsService));
+}
 function getServiceOverride() {
+    onServicesInitialized(initialize);
     return {
         ...getServiceOverride$1(),
         [( ISnippetsService.toString())]: new SyncDescriptor(SnippetsService)

package/dist/textmate.d.ts

@@ -676,7 +676,8 @@ interface ITMSyntaxExtensionPoint {
     unbalancedBracketScopes: string[];
 }
 
-declare function setGrammars<T extends ITMSyntaxExtensionPoint>(grammars: T[], getContent: (grammar: T) => Promise<string>, extension?: IExtensionDescription): void;
+declare type PartialITMSyntaxExtensionPoint = Partial<ITMSyntaxExtensionPoint> & Pick<ITMSyntaxExtensionPoint, 'path' | 'scopeName'>;
+declare function setGrammars<T extends PartialITMSyntaxExtensionPoint>(grammars: T[], getContent: (grammar: T) => Promise<string>, extension?: IExtensionDescription): void;
 declare function getServiceOverride(getOnigLib: () => Promise<Response | ArrayBuffer>): IEditorOverrideServices;
 
-export { ITMSyntaxExtensionPoint, ITextMateService, getServiceOverride as default, setGrammars };
+export { PartialITMSyntaxExtensionPoint as ITMSyntaxExtensionPoint, ITextMateService, getServiceOverride as default, setGrammars };