@codingame/monaco-vscode-api 1.69.7 → 1.69.8

package/dist/modelEditor.js

@@ -1,6 +1,7 @@
-import { _ as __decorate, a as __param } from './contextkey.js';
-import { g as ILanguageDetectionService, 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 { b as __decorate, d as __param } from './contextkey.js';
+import { E as Emitter } from './polyfill.js';
+import { d as ILanguageDetectionService, u as unsupported } from './missing-services.js';
+import { Disposable, MutableDisposable, dispose, toDisposable, ImmortalReference } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { w as withUndefinedAsNull } from './types.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';
@@ -8,7 +9,7 @@ import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
 import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
 import { IAccessibilityService } from 'monaco-editor/esm/vs/platform/accessibility/common/accessibility.js';
-import { e as ITextFileService, I as IFileService, b as IUriIdentityService, c as IEditorService, q as SIDE_GROUP, A as ACTIVE_GROUP, s as isPreferredGroup } from './services2.js';
+import { d as IFileService, f as IUriIdentityService, I as ITextFileService, c as SIDE_GROUP, A as ACTIVE_GROUP, i as IEditorService, u as isPreferredGroup } from './services2.js';
 import { MultiModelEditStackElement } from 'monaco-editor/esm/vs/editor/common/model/editStack.js';
 import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
 import { IUndoRedoService } from 'monaco-editor/esm/vs/platform/undoRedo/common/undoRedo.js';
@@ -28,7 +29,7 @@ import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
 import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 class ReferenceCollection {
     constructor() {
-        this.references = ( (new Map()));
+        this.references = ( new Map());
     }
     acquire(key, ...args) {
         let reference = this.references.get(key);
@@ -102,7 +103,7 @@ function isCompositeEditor(thing) {
 class EditorModel extends Disposable {
     constructor() {
         super(...arguments);
-        this._onWillDispose = this._register(( (new Emitter())));
+        this._onWillDispose = this._register(( new Emitter()));
         this.onWillDispose = this._onWillDispose.event;
         this.disposed = false;
         this.resolved = false;
@@ -130,8 +131,8 @@ let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
         this.languageDetectionService = languageDetectionService;
         this.accessibilityService = accessibilityService;
         this.textEditorModelHandle = undefined;
-        this.modelDisposeListener = this._register(( (new MutableDisposable())));
-        this.autoDetectLanguageThrottler = this._register(( (new ThrottledDelayer(BaseTextEditorModel.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY))));
+        this.modelDisposeListener = this._register(( new MutableDisposable()));
+        this.autoDetectLanguageThrottler = this._register(( new ThrottledDelayer(BaseTextEditorModel.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY)));
         this._hasLanguageSetExplicitly = false;
         if (textEditorModelHandle) {
             this.handleExistingModel(textEditorModelHandle);
@@ -189,11 +190,11 @@ let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
             this.setLanguageIdInternal(lang);
             const languageName = this.languageService.getLanguageName(lang);
             if (languageName) {
-                this.accessibilityService.alert(( (localize(
+                this.accessibilityService.alert(( localize(
                     'languageAutoDetected',
                     "Language {0} was automatically detected and set as the language mode.",
                     languageName
-                ))));
+                )));
             }
         }
     }
@@ -260,12 +261,12 @@ let BaseTextEditorModel = class BaseTextEditorModel extends EditorModel {
     }
 };
 BaseTextEditorModel.AUTO_DETECT_LANGUAGE_THROTTLE_DELAY = 600;
-BaseTextEditorModel = ( (__decorate([
-    ( (__param(0, IModelService))),
-    ( (__param(1, ILanguageService))),
-    ( (__param(2, ILanguageDetectionService))),
-    ( (__param(3, IAccessibilityService)))
-], BaseTextEditorModel)));
+BaseTextEditorModel = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ILanguageService)),
+    ( __param(2, ILanguageDetectionService)),
+    ( __param(3, IAccessibilityService))
+], BaseTextEditorModel));
 let TextResourceEditorModel = class TextResourceEditorModel extends BaseTextEditorModel {
     constructor(resource, languageService, modelService, languageDetectionService, accessibilityService) {
         super(modelService, languageService, languageDetectionService, accessibilityService, resource);
@@ -277,12 +278,12 @@ let TextResourceEditorModel = class TextResourceEditorModel extends BaseTextEdit
         super.dispose();
     }
 };
-TextResourceEditorModel = ( (__decorate([
-    ( (__param(1, ILanguageService))),
-    ( (__param(2, IModelService))),
-    ( (__param(3, ILanguageDetectionService))),
-    ( (__param(4, IAccessibilityService)))
-], TextResourceEditorModel)));
+TextResourceEditorModel = ( __decorate([
+    ( __param(1, ILanguageService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ILanguageDetectionService)),
+    ( __param(4, IAccessibilityService))
+], TextResourceEditorModel));
 class TextFileEditorModel {}
 let ModelUndoRedoParticipant = class ModelUndoRedoParticipant extends Disposable {
     constructor(_modelService, _textModelService, _undoRedoService) {
@@ -328,11 +329,11 @@ let ModelUndoRedoParticipant = class ModelUndoRedoParticipant extends Disposable
         });
     }
 };
-ModelUndoRedoParticipant = ( (__decorate([
-    ( (__param(0, IModelService))),
-    ( (__param(1, ITextModelService))),
-    ( (__param(2, IUndoRedoService)))
-], ModelUndoRedoParticipant)));
+ModelUndoRedoParticipant = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, ITextModelService)),
+    ( __param(2, IUndoRedoService))
+], ModelUndoRedoParticipant));
 let ResourceModelCollection = class ResourceModelCollection extends ReferenceCollection {
     constructor(instantiationService, textFileService, fileService, modelService) {
         super();
@@ -340,15 +341,15 @@ let ResourceModelCollection = class ResourceModelCollection extends ReferenceCol
         this.textFileService = textFileService;
         this.fileService = fileService;
         this.modelService = modelService;
-        this.providers = ( (new Map()));
-        this.modelsToDispose = ( (new Set()));
+        this.providers = ( new Map());
+        this.modelsToDispose = ( new Set());
     }
     createReferencedObject(key) {
         return this.doCreateReferencedObject(key);
     }
     async doCreateReferencedObject(key, skipActivateProvider) {
         this.modelsToDispose.delete(key);
-        const resource = ( (URI.parse(key)));
+        const resource = ( URI.parse(key));
         if (resource.scheme === Schemas.inMemory) {
             const cachedModel = this.modelService.getModel(resource);
             if (!cachedModel) {
@@ -391,7 +392,7 @@ let ResourceModelCollection = class ResourceModelCollection extends ReferenceCol
         throw new Error(`Unable to resolve resource ${key}`);
     }
     destroyReferencedObject(key, modelPromise) {
-        const resource = ( (URI.parse(key)));
+        const resource = ( URI.parse(key));
         if (resource.scheme === Schemas.untitled || resource.scheme === Schemas.inMemory) {
             return;
         }
@@ -443,7 +444,7 @@ let ResourceModelCollection = class ResourceModelCollection extends ReferenceCol
         return this.providers.get(scheme) !== undefined;
     }
     async resolveTextModelContent(key) {
-        const resource = ( (URI.parse(key)));
+        const resource = ( URI.parse(key));
         const providersForScheme = this.providers.get(resource.scheme) || [];
         for (const provider of providersForScheme) {
             const value = await provider.provideTextContent(resource);
@@ -454,12 +455,12 @@ let ResourceModelCollection = class ResourceModelCollection extends ReferenceCol
         throw new Error(`Unable to resolve text model content for resource ${key}`);
     }
 };
-ResourceModelCollection = ( (__decorate([
-    ( (__param(0, IInstantiationService))),
-    ( (__param(1, ITextFileService))),
-    ( (__param(2, IFileService))),
-    ( (__param(3, IModelService)))
-], ResourceModelCollection)));
+ResourceModelCollection = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ITextFileService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IModelService))
+], ResourceModelCollection));
 let TextModelResolverService = class TextModelResolverService extends Disposable {
     constructor(instantiationService, fileService, undoRedoService, modelService, uriIdentityService) {
         super();
@@ -469,12 +470,12 @@ let TextModelResolverService = class TextModelResolverService extends Disposable
         this.modelService = modelService;
         this.uriIdentityService = uriIdentityService;
         this.resourceModelCollection = this.instantiationService.createInstance(ResourceModelCollection);
-        this.asyncModelCollection = ( (new AsyncReferenceCollection(this.resourceModelCollection)));
-        this._register(( (new ModelUndoRedoParticipant(this.modelService, this, this.undoRedoService))));
+        this.asyncModelCollection = ( new AsyncReferenceCollection(this.resourceModelCollection));
+        this._register(( new ModelUndoRedoParticipant(this.modelService, this, this.undoRedoService)));
     }
     async createModelReference(resource) {
         resource = this.uriIdentityService.asCanonicalUri(resource);
-        return await this.asyncModelCollection.acquire(( (resource.toString())));
+        return await this.asyncModelCollection.acquire(( resource.toString()));
     }
     registerTextModelContentProvider(scheme, provider) {
         return this.resourceModelCollection.registerTextModelContentProvider(scheme, provider);
@@ -486,13 +487,13 @@ let TextModelResolverService = class TextModelResolverService extends Disposable
         return this.resourceModelCollection.hasTextModelContentProvider(resource.scheme);
     }
 };
-TextModelResolverService = ( (__decorate([
-    ( (__param(0, IInstantiationService))),
-    ( (__param(1, IFileService))),
-    ( (__param(2, IUndoRedoService))),
-    ( (__param(3, IModelService))),
-    ( (__param(4, IUriIdentityService)))
-], TextModelResolverService)));
+TextModelResolverService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IUndoRedoService)),
+    ( __param(3, IModelService)),
+    ( __param(4, IUriIdentityService))
+], TextModelResolverService));
 function applyTextEditorOptions(options, editor, scrollType) {
     let applied = false;
     const viewState = massageEditorViewState(options);
@@ -605,13 +606,13 @@ let CodeEditorService = class CodeEditorService extends AbstractCodeEditorServic
         return null;
     }
 };
-CodeEditorService = ( (__decorate([
-    ( (__param(0, IEditorService))),
-    ( (__param(1, IThemeService))),
-    ( (__param(2, IConfigurationService)))
-], CodeEditorService)));
-const DEFAULT_EDITOR_MIN_DIMENSIONS = ( (new Dimension(220, 70)));
-const DEFAULT_EDITOR_MAX_DIMENSIONS = ( (new Dimension(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY)));
+CodeEditorService = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, IConfigurationService))
+], CodeEditorService));
+const DEFAULT_EDITOR_MIN_DIMENSIONS = ( new Dimension(220, 70));
+const DEFAULT_EDITOR_MAX_DIMENSIONS = ( new Dimension(Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY));
 class SimpleEditorPane {
     constructor(editor) {
         this.editor = editor;
@@ -702,9 +703,9 @@ let EditorService = class EditorService {
         return new SimpleEditorPane(modelEditor);
     }
 };
-EditorService = ( __decorate([
-    ( __param(1, ITextModelService))
-], EditorService));
+EditorService = __decorate([
+    __param(1, ITextModelService)
+], EditorService);
 let CustomTextModelResolverService = class CustomTextModelResolverService extends TextModelResolverService {
     constructor(_instantiationService, fileService, undoRedoService, _modelService, uriIdentityService) {
         super(_instantiationService, fileService, undoRedoService, _modelService, uriIdentityService);
@@ -723,18 +724,18 @@ let CustomTextModelResolverService = class CustomTextModelResolverService extend
         return ref;
     }
 };
-CustomTextModelResolverService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IFileService)),
-    ( __param(2, IUndoRedoService)),
-    ( __param(3, IModelService)),
-    ( __param(4, IUriIdentityService))
-], CustomTextModelResolverService));
+CustomTextModelResolverService = __decorate([
+    __param(0, IInstantiationService),
+    __param(1, IFileService),
+    __param(2, IUndoRedoService),
+    __param(3, IModelService),
+    __param(4, IUriIdentityService)
+], CustomTextModelResolverService);
 function getServiceOverride(openEditor) {
     return {
-        [( ITextModelService.toString())]: new SyncDescriptor(CustomTextModelResolverService),
-        [( ICodeEditorService.toString())]: new SyncDescriptor(CodeEditorService),
-        [( IEditorService.toString())]: new SyncDescriptor(EditorService, [openEditor])
+        [ITextModelService.toString()]: new SyncDescriptor(CustomTextModelResolverService),
+        [ICodeEditorService.toString()]: new SyncDescriptor(CodeEditorService),
+        [IEditorService.toString()]: new SyncDescriptor(EditorService, [openEditor])
     };
 }
 export { getServiceOverride as default };

package/dist/monaco.js

@@ -1,5 +1,6 @@
-import { _ as __decorate, a as __param } from './contextkey.js';
+import { b as __decorate, d as __param } from './contextkey.js';
 export { C as ContextKeyExprType } from './contextkey.js';
+import './polyfill.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';
@@ -12,7 +13,7 @@ import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/c
 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 { StandaloneEditor, StandaloneDiffEditor } 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';
 export { errorHandler } from 'monaco-editor/esm/vs/base/common/errors.js';
@@ -75,7 +76,7 @@ function distinct(base, target) {
     if (!base || !target) {
         return result;
     }
-    const targetKeys = ( (Object.keys(target)));
+    const targetKeys = ( Object.keys(target));
     targetKeys.forEach(k => {
         const baseValue = base[k];
         const targetValue = target[k];
@@ -119,7 +120,7 @@ class ComputedEditorOptions {
 }
 class EditorOptionsUtil {
     static validateOptions(options) {
-        const result = ( (new ValidatedEditorOptions()));
+        const result = ( new ValidatedEditorOptions());
         for (const editorOption of editorOptionsRegistry) {
             const value = (editorOption.name === '_never_' ? undefined : options[editorOption.name]);
             result._write(editorOption.id, editorOption.validate(value));
@@ -127,7 +128,7 @@ class EditorOptionsUtil {
         return result;
     }
     static computeOptions(options, env) {
-        const result = ( (new ComputedEditorOptions()));
+        const result = ( new ComputedEditorOptions());
         for (const editorOption of editorOptionsRegistry) {
             result._write(editorOption.id, editorOption.compute(env, result, options._read(editorOption.id)));
         }
@@ -140,7 +141,7 @@ class EditorOptionsUtil {
         if (Array.isArray(a) || Array.isArray(b)) {
             return (Array.isArray(a) && Array.isArray(b) ? equals$1(a, b) : false);
         }
-        if (( (Object.keys(a))).length !== ( (Object.keys(b))).length) {
+        if (( Object.keys(a)).length !== ( Object.keys(b)).length) {
             return false;
         }
         for (const key in a) {
@@ -160,7 +161,7 @@ class EditorOptionsUtil {
                 somethingChanged = true;
             }
         }
-        return (somethingChanged ?  (new ConfigurationChangedEvent(result)) : null);
+        return (somethingChanged ? ( new ConfigurationChangedEvent(result)) : null);
     }
     static applyUpdate(options, update) {
         let changed = false;
@@ -210,7 +211,7 @@ let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends create
         if (this.lastAppliedEditorOptions != null) {
             editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
         }
-        if (( Object.keys(editorSettingsToApply)).length > 0) {
+        if (Object.keys(editorSettingsToApply).length > 0) {
             this.lastAppliedEditorOptions = editorConfiguration;
             super.updateOptions(editorSettingsToApply);
         }
@@ -223,10 +224,10 @@ let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends create
         this.updateEditorConfiguration();
     }
 };
-ConfiguredStandaloneEditor = ( __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ITextResourceConfigurationService))
-], ConfiguredStandaloneEditor));
+ConfiguredStandaloneEditor = __decorate([
+    __param(3, IInstantiationService),
+    __param(4, ITextResourceConfigurationService)
+], ConfiguredStandaloneEditor);
 class ConfiguredStandaloneDiffEditor extends StandaloneDiffEditor {
     _createInnerEditor(instantiationService, container, options) {
         return instantiationService.createInstance(ConfiguredStandaloneEditor, container, true, options);
@@ -244,7 +245,7 @@ const Extensions = {
     ...Extensions$1,
     ...Extensions$2
 };
-const registry = ( Registry.as(Extensions.JSONContribution));
+const registry = Registry.as(Extensions.JSONContribution);
 function getJsonSchemas(fileMatchs = {}) {
     return Object.entries(registry.getSchemaContributions().schemas)
         .filter(([uri]) => uri !== 'vscode://schemas/vscode-extensions')