@codingame/monaco-vscode-api 1.85.5 → 2.0.0-rework-ci.1

package/vscode/src/vs/platform/theme/common/tokenClassificationRegistry.js

@@ -1,9 +1,9 @@
-import { RunOnceScheduler } from 'monaco-editor/esm/vs/base/common/async.js';
-import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
-import * as platform from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { RunOnceScheduler } from '../../../base/common/async.js';
+import { Color } from '../../../base/common/color.js';
+import { Emitter } from '../../../base/common/event.js';
+import { localizeWithPath } from '../../../nls.js';
+import { Extensions } from '../../jsonschemas/common/jsonContributionRegistry.js';
+import { Registry } from '../../registry/common/platform.js';
 const TOKEN_TYPE_WILDCARD = '*';
 const TOKEN_CLASSIFIER_LANGUAGE_SEPARATOR = ':';
 const CLASSIFIER_MODIFIER_SEPARATOR = '.';
@@ -20,7 +20,7 @@ class TokenStyle {
         this.italic = italic;
     }
 }
-( (function(TokenStyle) {
+( ((function(TokenStyle) {
     function toJSONObject(style) {
         return {
             _foreground: style.foreground === undefined ? null : Color.Format.CSS.formatHexA(style.foreground, true),
@@ -34,14 +34,16 @@ class TokenStyle {
     function fromJSONObject(obj) {
         if (obj) {
             const boolOrUndef = (b) => (typeof b === 'boolean') ? b : undefined;
-            const colorOrUndef = (s) => (typeof s === 'string') ? ( Color.fromHex(s)) : undefined;
-            return ( new TokenStyle(
-                colorOrUndef(obj._foreground),
-                boolOrUndef(obj._bold),
-                boolOrUndef(obj._underline),
-                boolOrUndef(obj._strikethrough),
-                boolOrUndef(obj._italic)
-            ));
+            const colorOrUndef = (s) => (typeof s === 'string') ? ( (Color.fromHex(s))) : undefined;
+            return (
+                 (new TokenStyle(
+                    colorOrUndef(obj._foreground),
+                    boolOrUndef(obj._bold),
+                    boolOrUndef(obj._underline),
+                    boolOrUndef(obj._strikethrough),
+                    boolOrUndef(obj._italic)
+                ))
+            );
         }
         return undefined;
     }
@@ -63,19 +65,21 @@ class TokenStyle {
     }
     TokenStyle.is = is;
     function fromData(data) {
-        return ( new TokenStyle(
-            data.foreground,
-            data.bold,
-            data.underline,
-            data.strikethrough,
-            data.italic
-        ));
+        return (
+             (new TokenStyle(
+                data.foreground,
+                data.bold,
+                data.underline,
+                data.strikethrough,
+                data.italic
+            ))
+        );
     }
     TokenStyle.fromData = fromData;
     function fromSettings(foreground, fontStyle, bold, underline, strikethrough, italic) {
         let foregroundColor = undefined;
         if (foreground !== undefined) {
-            foregroundColor = ( Color.fromHex(foreground));
+            foregroundColor = ( (Color.fromHex(foreground)));
         }
         if (fontStyle !== undefined) {
             bold = italic = underline = strikethrough = false;
@@ -98,12 +102,14 @@ class TokenStyle {
                 }
             }
         }
-        return ( new TokenStyle(foregroundColor, bold, underline, strikethrough, italic));
+        return (
+             (new TokenStyle(foregroundColor, bold, underline, strikethrough, italic))
+        );
     }
     TokenStyle.fromSettings = fromSettings;
-})(TokenStyle || (TokenStyle = {})));
+})(TokenStyle || (TokenStyle = {}))));
 var SemanticTokenRule;
-( (function(SemanticTokenRule) {
+( ((function(SemanticTokenRule) {
     function fromJSONObject(registry, o) {
         if (o && typeof o._selector === 'string' && o._style) {
             const style = TokenStyle.fromJSONObject(o._style);
@@ -138,10 +144,10 @@ var SemanticTokenRule;
         return r && r.selector && typeof r.selector.id === 'string' && TokenStyle.is(r.style);
     }
     SemanticTokenRule.is = is;
-})(SemanticTokenRule || (SemanticTokenRule = {})));
+})(SemanticTokenRule || (SemanticTokenRule = {}))));
 class TokenClassificationRegistry {
     constructor() {
-        this._onDidChangeSchema = ( new Emitter());
+        this._onDidChangeSchema = ( (new Emitter()));
         this.onDidChangeSchema = this._onDidChangeSchema.event;
         this.currentTypeNumber = 0;
         this.currentModifierBit = 1;
@@ -156,49 +162,49 @@ class TokenClassificationRegistry {
             definitions: {
                 style: {
                     type: 'object',
-                    description: ( nls.localizeWithPath(
+                    description: ( (localizeWithPath(
                         'vs/platform/theme/common/tokenClassificationRegistry',
                         'schema.token.settings',
                         'Colors and styles for the token.'
-                    )),
+                    ))),
                     properties: {
                         foreground: {
                             type: 'string',
-                            description: ( nls.localizeWithPath(
+                            description: ( (localizeWithPath(
                                 'vs/platform/theme/common/tokenClassificationRegistry',
                                 'schema.token.foreground',
                                 'Foreground color for the token.'
-                            )),
+                            ))),
                             format: 'color-hex',
                             default: '#ff0000'
                         },
                         background: {
                             type: 'string',
-                            deprecationMessage: ( nls.localizeWithPath(
+                            deprecationMessage: ( (localizeWithPath(
                                 'vs/platform/theme/common/tokenClassificationRegistry',
                                 'schema.token.background.warning',
                                 'Token background colors are currently not supported.'
-                            ))
+                            )))
                         },
                         fontStyle: {
                             type: 'string',
-                            description: ( nls.localizeWithPath(
+                            description: ( (localizeWithPath(
                                 'vs/platform/theme/common/tokenClassificationRegistry',
                                 'schema.token.fontStyle',
                                 'Sets the all font styles of the rule: \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. All styles that are not listed are unset. The empty string unsets all styles.'
-                            )),
+                            ))),
                             pattern: fontStylePattern,
-                            patternErrorMessage: ( nls.localizeWithPath(
+                            patternErrorMessage: ( (localizeWithPath(
                                 'vs/platform/theme/common/tokenClassificationRegistry',
                                 'schema.fontStyle.error',
                                 'Font style must be \'italic\', \'bold\', \'underline\' or \'strikethrough\' or a combination. The empty string unsets all styles.'
-                            )),
+                            ))),
                             defaultSnippets: [
-                                { label: ( nls.localizeWithPath(
+                                { label: ( (localizeWithPath(
                                     'vs/platform/theme/common/tokenClassificationRegistry',
                                     'schema.token.fontStyle.none',
                                     'None (clear inherited style)'
-                                )), bodyText: '""' },
+                                ))), bodyText: '""' },
                                 { body: 'italic' },
                                 { body: 'bold' },
                                 { body: 'underline' },
@@ -218,35 +224,35 @@ class TokenClassificationRegistry {
                         },
                         bold: {
                             type: 'boolean',
-                            description: ( nls.localizeWithPath(
+                            description: ( (localizeWithPath(
                                 'vs/platform/theme/common/tokenClassificationRegistry',
                                 'schema.token.bold',
                                 'Sets or unsets the font style to bold. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            ))),
                         },
                         italic: {
                             type: 'boolean',
-                            description: ( nls.localizeWithPath(
+                            description: ( (localizeWithPath(
                                 'vs/platform/theme/common/tokenClassificationRegistry',
                                 'schema.token.italic',
                                 'Sets or unsets the font style to italic. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            ))),
                         },
                         underline: {
                             type: 'boolean',
-                            description: ( nls.localizeWithPath(
+                            description: ( (localizeWithPath(
                                 'vs/platform/theme/common/tokenClassificationRegistry',
                                 'schema.token.underline',
                                 'Sets or unsets the font style to underline. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            ))),
                         },
                         strikethrough: {
                             type: 'boolean',
-                            description: ( nls.localizeWithPath(
+                            description: ( (localizeWithPath(
                                 'vs/platform/theme/common/tokenClassificationRegistry',
                                 'schema.token.strikethrough',
                                 'Sets or unsets the font style to strikethrough. Note, the presence of \'fontStyle\' overrides this setting.'
-                            )),
+                            ))),
                         }
                     },
                     defaultSnippets: [{ body: { foreground: '${1:#FF0000}', fontStyle: '${2:bold}' } }]
@@ -333,10 +339,14 @@ class TokenClassificationRegistry {
         delete this.tokenStylingSchema.properties[`*.${id}`];
     }
     getTokenTypes() {
-        return ( ( Object.keys(this.tokenTypeById)).map(id => this.tokenTypeById[id]));
+        return (
+             (( (Object.keys(this.tokenTypeById))).map(id => this.tokenTypeById[id]))
+        );
     }
     getTokenModifiers() {
-        return ( ( Object.keys(this.tokenModifierById)).map(id => this.tokenModifierById[id]));
+        return (
+             (( (Object.keys(this.tokenModifierById))).map(id => this.tokenModifierById[id]))
+        );
     }
     getTokenStylingSchema() {
         return this.tokenStylingSchema;
@@ -365,7 +375,7 @@ class TokenClassificationRegistry {
             }
             return a.localeCompare(b);
         };
-        return ( ( Object.keys(this.tokenTypeById)).sort(sorter).map(k => `- \`${k}\`: ${this.tokenTypeById[k].description}`)).join('\n');
+        return ( (( (Object.keys(this.tokenTypeById))).sort(sorter).map(k => `- \`${k}\`: ${this.tokenTypeById[k].description}`))).join('\n');
     }
 }
 const CHAR_LANGUAGE = TOKEN_CLASSIFIER_LANGUAGE_SEPARATOR.charCodeAt(0);
@@ -392,7 +402,7 @@ function parseClassifierString(s, defaultLanguage) {
 }
 const tokenClassificationRegistry = createDefaultTokenClassificationRegistry();
 function createDefaultTokenClassificationRegistry() {
-    const registry = ( new TokenClassificationRegistry());
+    const registry = ( (new TokenClassificationRegistry()));
     function registerTokenType(id, description, scopesToProbe = [], superType, deprecationMessage) {
         registry.registerTokenType(id, description, superType, deprecationMessage);
         if (scopesToProbe) {
@@ -409,166 +419,166 @@ function createDefaultTokenClassificationRegistry() {
             console.log(e);
         }
     }
-    registerTokenType('comment', ( nls.localizeWithPath(
+    registerTokenType('comment', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'comment',
         "Style for comments."
-    )), [['comment']]);
-    registerTokenType('string', ( nls.localizeWithPath(
+    ))), [['comment']]);
+    registerTokenType('string', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'string',
         "Style for strings."
-    )), [['string']]);
-    registerTokenType('keyword', ( nls.localizeWithPath(
+    ))), [['string']]);
+    registerTokenType('keyword', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'keyword',
         "Style for keywords."
-    )), [['keyword.control']]);
-    registerTokenType('number', ( nls.localizeWithPath(
+    ))), [['keyword.control']]);
+    registerTokenType('number', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'number',
         "Style for numbers."
-    )), [['constant.numeric']]);
-    registerTokenType('regexp', ( nls.localizeWithPath(
+    ))), [['constant.numeric']]);
+    registerTokenType('regexp', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'regexp',
         "Style for expressions."
-    )), [['constant.regexp']]);
-    registerTokenType('operator', ( nls.localizeWithPath(
+    ))), [['constant.regexp']]);
+    registerTokenType('operator', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'operator',
         "Style for operators."
-    )), [['keyword.operator']]);
-    registerTokenType('namespace', ( nls.localizeWithPath(
+    ))), [['keyword.operator']]);
+    registerTokenType('namespace', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'namespace',
         "Style for namespaces."
-    )), [['entity.name.namespace']]);
-    registerTokenType('type', ( nls.localizeWithPath(
+    ))), [['entity.name.namespace']]);
+    registerTokenType('type', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'type',
         "Style for types."
-    )), [['entity.name.type'], ['support.type']]);
-    registerTokenType('struct', ( nls.localizeWithPath(
+    ))), [['entity.name.type'], ['support.type']]);
+    registerTokenType('struct', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'struct',
         "Style for structs."
-    )), [['entity.name.type.struct']]);
-    registerTokenType('class', ( nls.localizeWithPath(
+    ))), [['entity.name.type.struct']]);
+    registerTokenType('class', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'class',
         "Style for classes."
-    )), [['entity.name.type.class'], ['support.class']]);
-    registerTokenType('interface', ( nls.localizeWithPath(
+    ))), [['entity.name.type.class'], ['support.class']]);
+    registerTokenType('interface', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'interface',
         "Style for interfaces."
-    )), [['entity.name.type.interface']]);
-    registerTokenType('enum', ( nls.localizeWithPath(
+    ))), [['entity.name.type.interface']]);
+    registerTokenType('enum', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'enum',
         "Style for enums."
-    )), [['entity.name.type.enum']]);
-    registerTokenType('typeParameter', ( nls.localizeWithPath(
+    ))), [['entity.name.type.enum']]);
+    registerTokenType('typeParameter', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'typeParameter',
         "Style for type parameters."
-    )), [['entity.name.type.parameter']]);
-    registerTokenType('function', ( nls.localizeWithPath(
+    ))), [['entity.name.type.parameter']]);
+    registerTokenType('function', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'function',
         "Style for functions"
-    )), [['entity.name.function'], ['support.function']]);
-    registerTokenType('member', ( nls.localizeWithPath(
+    ))), [['entity.name.function'], ['support.function']]);
+    registerTokenType('member', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'member',
         "Style for member functions"
-    )), [], 'method', 'Deprecated use `method` instead');
-    registerTokenType('method', ( nls.localizeWithPath(
+    ))), [], 'method', 'Deprecated use `method` instead');
+    registerTokenType('method', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'method',
         "Style for method (member functions)"
-    )), [['entity.name.function.member'], ['support.function']]);
-    registerTokenType('macro', ( nls.localizeWithPath(
+    ))), [['entity.name.function.member'], ['support.function']]);
+    registerTokenType('macro', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'macro',
         "Style for macros."
-    )), [['entity.name.function.preprocessor']]);
-    registerTokenType('variable', ( nls.localizeWithPath(
+    ))), [['entity.name.function.preprocessor']]);
+    registerTokenType('variable', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'variable',
         "Style for variables."
-    )), [['variable.other.readwrite'], ['entity.name.variable']]);
-    registerTokenType('parameter', ( nls.localizeWithPath(
+    ))), [['variable.other.readwrite'], ['entity.name.variable']]);
+    registerTokenType('parameter', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'parameter',
         "Style for parameters."
-    )), [['variable.parameter']]);
-    registerTokenType('property', ( nls.localizeWithPath(
+    ))), [['variable.parameter']]);
+    registerTokenType('property', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'property',
         "Style for properties."
-    )), [['variable.other.property']]);
-    registerTokenType('enumMember', ( nls.localizeWithPath(
+    ))), [['variable.other.property']]);
+    registerTokenType('enumMember', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'enumMember',
         "Style for enum members."
-    )), [['variable.other.enummember']]);
-    registerTokenType('event', ( nls.localizeWithPath(
+    ))), [['variable.other.enummember']]);
+    registerTokenType('event', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'event',
         "Style for events."
-    )), [['variable.other.event']]);
-    registerTokenType('decorator', ( nls.localizeWithPath(
+    ))), [['variable.other.event']]);
+    registerTokenType('decorator', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'decorator',
         "Style for decorators & annotations."
-    )), [['entity.name.decorator'], ['entity.name.function']]);
-    registerTokenType('label', ( nls.localizeWithPath(
+    ))), [['entity.name.decorator'], ['entity.name.function']]);
+    registerTokenType('label', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'labels',
         "Style for labels. "
-    )), undefined);
-    registry.registerTokenModifier('declaration', ( nls.localizeWithPath(
+    ))), undefined);
+    registry.registerTokenModifier('declaration', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'declaration',
         "Style for all symbol declarations."
-    )), undefined);
-    registry.registerTokenModifier('documentation', ( nls.localizeWithPath(
+    ))), undefined);
+    registry.registerTokenModifier('documentation', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'documentation',
         "Style to use for references in documentation."
-    )), undefined);
-    registry.registerTokenModifier('static', ( nls.localizeWithPath(
+    ))), undefined);
+    registry.registerTokenModifier('static', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'static',
         "Style to use for symbols that are static."
-    )), undefined);
-    registry.registerTokenModifier('abstract', ( nls.localizeWithPath(
+    ))), undefined);
+    registry.registerTokenModifier('abstract', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'abstract',
         "Style to use for symbols that are abstract."
-    )), undefined);
-    registry.registerTokenModifier('deprecated', ( nls.localizeWithPath(
+    ))), undefined);
+    registry.registerTokenModifier('deprecated', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'deprecated',
         "Style to use for symbols that are deprecated."
-    )), undefined);
-    registry.registerTokenModifier('modification', ( nls.localizeWithPath(
+    ))), undefined);
+    registry.registerTokenModifier('modification', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'modification',
         "Style to use for write accesses."
-    )), undefined);
-    registry.registerTokenModifier('async', ( nls.localizeWithPath(
+    ))), undefined);
+    registry.registerTokenModifier('async', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'async',
         "Style to use for symbols that are async."
-    )), undefined);
-    registry.registerTokenModifier('readonly', ( nls.localizeWithPath(
+    ))), undefined);
+    registry.registerTokenModifier('readonly', ( (localizeWithPath(
         'vs/platform/theme/common/tokenClassificationRegistry',
         'readonly',
         "Style to use for symbols that are read-only."
-    )), undefined);
+    ))), undefined);
     registerTokenStyleDefault('variable.readonly', [['variable.other.constant']]);
     registerTokenStyleDefault('property.readonly', [['variable.other.constant.property']]);
     registerTokenStyleDefault('type.defaultLibrary', [['support.type']]);
@@ -602,9 +612,9 @@ function getStylingSchemeEntry(description, deprecationMessage) {
     };
 }
 const tokenStylingSchemaId = 'vscode://schemas/token-styling';
-const schemaRegistry = platform.Registry.as(Extensions.JSONContribution);
+const schemaRegistry = ( Registry.as(Extensions.JSONContribution));
 schemaRegistry.registerSchema(tokenStylingSchemaId, tokenClassificationRegistry.getTokenStylingSchema());
-const delayer = ( new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(tokenStylingSchemaId), 200));
+const delayer = ( (new RunOnceScheduler(() => schemaRegistry.notifySchemaChanged(tokenStylingSchemaId), 200)));
 tokenClassificationRegistry.onDidChangeSchema(() => {
     if (!delayer.isScheduled()) {
         delayer.schedule();

package/vscode/src/vs/platform/tunnel/common/tunnel.js

@@ -1,5 +1,5 @@
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Emitter } from '../../../base/common/event.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
 const ITunnelService = ( createDecorator('tunnelService'));
 var TunnelProtocol;
 ( (function(TunnelProtocol) {

package/vscode/src/vs/platform/undoRedo/common/undoRedo.js

@@ -0,0 +1,37 @@
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+const IUndoRedoService = ( createDecorator('undoRedoService'));
+class ResourceEditStackSnapshot {
+    constructor(resource, elements) {
+        this.resource = resource;
+        this.elements = elements;
+    }
+}
+class UndoRedoGroup {
+    static { this._ID = 0; }
+    constructor() {
+        this.id = UndoRedoGroup._ID++;
+        this.order = 1;
+    }
+    nextOrder() {
+        if (this.id === 0) {
+            return 0;
+        }
+        return this.order++;
+    }
+    static { this.None = ( new UndoRedoGroup()); }
+}
+class UndoRedoSource {
+    static { this._ID = 0; }
+    constructor() {
+        this.id = UndoRedoSource._ID++;
+        this.order = 1;
+    }
+    nextOrder() {
+        if (this.id === 0) {
+            return 0;
+        }
+        return this.order++;
+    }
+    static { this.None = ( new UndoRedoSource()); }
+}
+export { IUndoRedoService, ResourceEditStackSnapshot, UndoRedoGroup, UndoRedoSource };