@codingame/monaco-vscode-api 9.0.3 → 10.0.1

package/vscode/src/vs/workbench/services/themes/common/iconExtensionPoint.js

@@ -6,21 +6,21 @@ import { Registry } from '../../../../platform/registry/common/platform.js';
 import { ThemeIcon } from '../../../../base/common/themables.js';
 import { joinPath, isEqualOrParent } from '../../../../base/common/resources.js';
 import { extname, posix } from '../../../../base/common/path.js';
+import { registerWorkbenchContribution2 } from '../../../common/contributions.js';
 import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { registerWorkbenchContribution2, WorkbenchPhase } from '../../../common/contributions.js';
 const iconRegistry = ( (Registry.as(Extensions.IconContribution)));
 const iconReferenceSchema = iconRegistry.getIconReferenceSchema();
 const iconIdPattern = `^${ThemeIcon.iconNameSegment}(-${ThemeIcon.iconNameSegment})+$`;
 const iconConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'icons',
     jsonSchema: {
-        description: ( localize(615, 'Contributes extension defined themable icons')),
+        description: ( localize(627, 'Contributes extension defined themable icons')),
         type: 'object',
         propertyNames: {
             pattern: iconIdPattern,
-            description: ( localize(616, 'The identifier of the themable icon')),
+            description: ( localize(628, 'The identifier of the themable icon')),
             patternErrorMessage: ( localize(
-                617,
+                629,
                 'Identifiers can only contain letters, digits and minuses and need to consist of at least two segments in the form `component-iconname`.'
             )),
         },
@@ -29,7 +29,7 @@ const iconConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
             properties: {
                 description: {
                     type: 'string',
-                    description: ( localize(618, 'The description of the themable icon')),
+                    description: ( localize(630, 'The description of the themable icon')),
                 },
                 default: {
                     anyOf: [
@@ -38,11 +38,11 @@ const iconConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                             type: 'object',
                             properties: {
                                 fontPath: {
-                                    description: ( localize(619, 'The path of the icon font that defines the icon.')),
+                                    description: ( localize(631, 'The path of the icon font that defines the icon.')),
                                     type: 'string'
                                 },
                                 fontCharacter: {
-                                    description: ( localize(620, 'The character for the icon in the icon font.')),
+                                    description: ( localize(632, 'The character for the icon in the icon font.')),
                                     type: 'string'
                                 }
                             },
@@ -51,7 +51,7 @@ const iconConfigurationExtPoint = ExtensionsRegistry.registerExtensionPoint({
                         }
                     ],
                     description: ( localize(
-                        621,
+                        633,
                         'The default of the icon. Either a reference to an extisting ThemeIcon or an icon in an icon font.'
                     )),
                 }
@@ -70,7 +70,7 @@ class IconExtensionPoint {
                 const collector = extension.collector;
                 if (!extensionValue || typeof extensionValue !== 'object') {
                     collector.error(( localize(
-                        622,
+                        634,
                         "'configuration.icons' must be an object with the icon names as properties."
                     )));
                     return;
@@ -78,7 +78,7 @@ class IconExtensionPoint {
                 for (const id in extensionValue) {
                     if (!id.match(iconIdPattern)) {
                         collector.error(( localize(
-                            623,
+                            635,
                             "'configuration.icons' keys represent the icon id and can only contain letter, digits and minuses. They need to consist of at least two segments in the form `component-iconname`."
                         )));
                         return;
@@ -86,7 +86,7 @@ class IconExtensionPoint {
                     const iconContribution = extensionValue[id];
                     if (typeof iconContribution.description !== 'string' || iconContribution.description.length === 0) {
                         collector.error(( localize(
-                            624,
+                            636,
                             "'configuration.icons.description' must be defined and can not be empty"
                         )));
                         return;
@@ -100,7 +100,7 @@ class IconExtensionPoint {
                         const format = formatMap[fileExt];
                         if (!format) {
                             collector.warn(( localize(
-                                625,
+                                637,
                                 "Expected `contributes.icons.default.fontPath` to have file extension 'woff', woff2' or 'ttf', is '{0}'.",
                                 fileExt
                             )));
@@ -110,7 +110,7 @@ class IconExtensionPoint {
                         const iconFontLocation = joinPath(extensionLocation, defaultIcon.fontPath);
                         if (!isEqualOrParent(iconFontLocation, extensionLocation)) {
                             collector.warn(( localize(
-                                626,
+                                638,
                                 "Expected `contributes.icons.default.fontPath` ({0}) to be included inside extension's folder ({0}).",
                                 iconFontLocation.path,
                                 extensionLocation.path
@@ -129,7 +129,7 @@ class IconExtensionPoint {
                     }
                     else {
                         collector.error(( localize(
-                            627,
+                            639,
                             "'configuration.icons.default' must be either a reference to the id of an other theme icon (string) or a icon definition (object) with properties `fontPath` and `fontCharacter`."
                         )));
                     }
@@ -162,5 +162,5 @@ let ColorExtensionPointWorkbenchContribution = class ColorExtensionPointWorkbenc
 ColorExtensionPointWorkbenchContribution = ( (__decorate([
     ( (__param(0, IInstantiationService)))
 ], ColorExtensionPointWorkbenchContribution)));
-registerWorkbenchContribution2(ColorExtensionPointWorkbenchContribution.ID, ColorExtensionPointWorkbenchContribution, WorkbenchPhase.BlockStartup);
+registerWorkbenchContribution2(ColorExtensionPointWorkbenchContribution.ID, ColorExtensionPointWorkbenchContribution, 1 );
 export { IconExtensionPoint };

package/vscode/src/vs/workbench/services/themes/common/plistParser.js

@@ -0,0 +1,400 @@
+function parse(content) {
+    return _parse(content);
+}
+function _parse(content, filename, locationKeyName) {
+    const len = content.length;
+    let pos = 0;
+    if (len > 0 && content.charCodeAt(0) === 65279 ) {
+        pos = 1;
+    }
+    function advancePosBy(by) {
+        {
+            pos = pos + by;
+        }
+    }
+    function advancePosTo(to) {
+        {
+            pos = to;
+        }
+    }
+    function skipWhitespace() {
+        while (pos < len) {
+            const chCode = content.charCodeAt(pos);
+            if (chCode !== 32  && chCode !== 9  && chCode !== 13  && chCode !== 10 ) {
+                break;
+            }
+            advancePosBy(1);
+        }
+    }
+    function advanceIfStartsWith(str) {
+        if (content.substr(pos, str.length) === str) {
+            advancePosBy(str.length);
+            return true;
+        }
+        return false;
+    }
+    function advanceUntil(str) {
+        const nextOccurence = content.indexOf(str, pos);
+        if (nextOccurence !== -1) {
+            advancePosTo(nextOccurence + str.length);
+        }
+        else {
+            advancePosTo(len);
+        }
+    }
+    function captureUntil(str) {
+        const nextOccurence = content.indexOf(str, pos);
+        if (nextOccurence !== -1) {
+            const r = content.substring(pos, nextOccurence);
+            advancePosTo(nextOccurence + str.length);
+            return r;
+        }
+        else {
+            const r = content.substr(pos);
+            advancePosTo(len);
+            return r;
+        }
+    }
+    let state = 0 ;
+    let cur = null;
+    const stateStack = [];
+    const objStack = [];
+    let curKey = null;
+    function pushState(newState, newCur) {
+        stateStack.push(state);
+        objStack.push(cur);
+        state = newState;
+        cur = newCur;
+    }
+    function popState() {
+        if (stateStack.length === 0) {
+            return fail('illegal state stack');
+        }
+        state = stateStack.pop();
+        cur = objStack.pop();
+    }
+    function fail(msg) {
+        throw ( new Error(
+            'Near offset ' + pos + ': ' + msg + ' ~~~' + content.substr(pos, 50) + '~~~'
+        ));
+    }
+    const dictState = {
+        enterDict: function () {
+            if (curKey === null) {
+                return fail('missing <key>');
+            }
+            const newDict = {};
+            cur[curKey] = newDict;
+            curKey = null;
+            pushState(1 , newDict);
+        },
+        enterArray: function () {
+            if (curKey === null) {
+                return fail('missing <key>');
+            }
+            const newArr = [];
+            cur[curKey] = newArr;
+            curKey = null;
+            pushState(2 , newArr);
+        }
+    };
+    const arrState = {
+        enterDict: function () {
+            const newDict = {};
+            cur.push(newDict);
+            pushState(1 , newDict);
+        },
+        enterArray: function () {
+            const newArr = [];
+            cur.push(newArr);
+            pushState(2 , newArr);
+        }
+    };
+    function enterDict() {
+        if (state === 1 ) {
+            dictState.enterDict();
+        }
+        else if (state === 2 ) {
+            arrState.enterDict();
+        }
+        else {
+            cur = {};
+            pushState(1 , cur);
+        }
+    }
+    function leaveDict() {
+        if (state === 1 ) {
+            popState();
+        }
+        else if (state === 2 ) {
+            return fail('unexpected </dict>');
+        }
+        else {
+            return fail('unexpected </dict>');
+        }
+    }
+    function enterArray() {
+        if (state === 1 ) {
+            dictState.enterArray();
+        }
+        else if (state === 2 ) {
+            arrState.enterArray();
+        }
+        else {
+            cur = [];
+            pushState(2 , cur);
+        }
+    }
+    function leaveArray() {
+        if (state === 1 ) {
+            return fail('unexpected </array>');
+        }
+        else if (state === 2 ) {
+            popState();
+        }
+        else {
+            return fail('unexpected </array>');
+        }
+    }
+    function acceptKey(val) {
+        if (state === 1 ) {
+            if (curKey !== null) {
+                return fail('too many <key>');
+            }
+            curKey = val;
+        }
+        else if (state === 2 ) {
+            return fail('unexpected <key>');
+        }
+        else {
+            return fail('unexpected <key>');
+        }
+    }
+    function acceptString(val) {
+        if (state === 1 ) {
+            if (curKey === null) {
+                return fail('missing <key>');
+            }
+            cur[curKey] = val;
+            curKey = null;
+        }
+        else if (state === 2 ) {
+            cur.push(val);
+        }
+        else {
+            cur = val;
+        }
+    }
+    function acceptReal(val) {
+        if (isNaN(val)) {
+            return fail('cannot parse float');
+        }
+        if (state === 1 ) {
+            if (curKey === null) {
+                return fail('missing <key>');
+            }
+            cur[curKey] = val;
+            curKey = null;
+        }
+        else if (state === 2 ) {
+            cur.push(val);
+        }
+        else {
+            cur = val;
+        }
+    }
+    function acceptInteger(val) {
+        if (isNaN(val)) {
+            return fail('cannot parse integer');
+        }
+        if (state === 1 ) {
+            if (curKey === null) {
+                return fail('missing <key>');
+            }
+            cur[curKey] = val;
+            curKey = null;
+        }
+        else if (state === 2 ) {
+            cur.push(val);
+        }
+        else {
+            cur = val;
+        }
+    }
+    function acceptDate(val) {
+        if (state === 1 ) {
+            if (curKey === null) {
+                return fail('missing <key>');
+            }
+            cur[curKey] = val;
+            curKey = null;
+        }
+        else if (state === 2 ) {
+            cur.push(val);
+        }
+        else {
+            cur = val;
+        }
+    }
+    function acceptData(val) {
+        if (state === 1 ) {
+            if (curKey === null) {
+                return fail('missing <key>');
+            }
+            cur[curKey] = val;
+            curKey = null;
+        }
+        else if (state === 2 ) {
+            cur.push(val);
+        }
+        else {
+            cur = val;
+        }
+    }
+    function acceptBool(val) {
+        if (state === 1 ) {
+            if (curKey === null) {
+                return fail('missing <key>');
+            }
+            cur[curKey] = val;
+            curKey = null;
+        }
+        else if (state === 2 ) {
+            cur.push(val);
+        }
+        else {
+            cur = val;
+        }
+    }
+    function escapeVal(str) {
+        return str.replace(/&#([0-9]+);/g, function (_, m0) {
+            return String.fromCodePoint(parseInt(m0, 10));
+        }).replace(/&#x([0-9a-f]+);/g, function (_, m0) {
+            return String.fromCodePoint(parseInt(m0, 16));
+        }).replace(/&amp;|&lt;|&gt;|&quot;|&apos;/g, function (_) {
+            switch (_) {
+                case '&amp;': return '&';
+                case '&lt;': return '<';
+                case '&gt;': return '>';
+                case '&quot;': return '"';
+                case '&apos;': return '\'';
+            }
+            return _;
+        });
+    }
+    function parseOpenTag() {
+        let r = captureUntil('>');
+        let isClosed = false;
+        if (r.charCodeAt(r.length - 1) === 47 ) {
+            isClosed = true;
+            r = r.substring(0, r.length - 1);
+        }
+        return {
+            name: r.trim(),
+            isClosed: isClosed
+        };
+    }
+    function parseTagValue(tag) {
+        if (tag.isClosed) {
+            return '';
+        }
+        const val = captureUntil('</');
+        advanceUntil('>');
+        return escapeVal(val);
+    }
+    while (pos < len) {
+        skipWhitespace();
+        if (pos >= len) {
+            break;
+        }
+        const chCode = content.charCodeAt(pos);
+        advancePosBy(1);
+        if (chCode !== 60 ) {
+            return fail('expected <');
+        }
+        if (pos >= len) {
+            return fail('unexpected end of input');
+        }
+        const peekChCode = content.charCodeAt(pos);
+        if (peekChCode === 63 ) {
+            advancePosBy(1);
+            advanceUntil('?>');
+            continue;
+        }
+        if (peekChCode === 33 ) {
+            advancePosBy(1);
+            if (advanceIfStartsWith('--')) {
+                advanceUntil('-->');
+                continue;
+            }
+            advanceUntil('>');
+            continue;
+        }
+        if (peekChCode === 47 ) {
+            advancePosBy(1);
+            skipWhitespace();
+            if (advanceIfStartsWith('plist')) {
+                advanceUntil('>');
+                continue;
+            }
+            if (advanceIfStartsWith('dict')) {
+                advanceUntil('>');
+                leaveDict();
+                continue;
+            }
+            if (advanceIfStartsWith('array')) {
+                advanceUntil('>');
+                leaveArray();
+                continue;
+            }
+            return fail('unexpected closed tag');
+        }
+        const tag = parseOpenTag();
+        switch (tag.name) {
+            case 'dict':
+                enterDict();
+                if (tag.isClosed) {
+                    leaveDict();
+                }
+                continue;
+            case 'array':
+                enterArray();
+                if (tag.isClosed) {
+                    leaveArray();
+                }
+                continue;
+            case 'key':
+                acceptKey(parseTagValue(tag));
+                continue;
+            case 'string':
+                acceptString(parseTagValue(tag));
+                continue;
+            case 'real':
+                acceptReal(parseFloat(parseTagValue(tag)));
+                continue;
+            case 'integer':
+                acceptInteger(parseInt(parseTagValue(tag), 10));
+                continue;
+            case 'date':
+                acceptDate(( new Date(parseTagValue(tag))));
+                continue;
+            case 'data':
+                acceptData(parseTagValue(tag));
+                continue;
+            case 'true':
+                parseTagValue(tag);
+                acceptBool(true);
+                continue;
+            case 'false':
+                parseTagValue(tag);
+                acceptBool(false);
+                continue;
+        }
+        if (/^plist/.test(tag.name)) {
+            continue;
+        }
+        return fail('unexpected opened tag ' + tag.name);
+    }
+    return cur;
+}
+export { parse };

package/vscode/src/vs/workbench/services/themes/common/textMateScopeMatcher.js

@@ -0,0 +1,120 @@
+function createMatchers(selector, matchesName, results) {
+    const tokenizer = newTokenizer(selector);
+    let token = tokenizer.next();
+    while (token !== null) {
+        let priority = 0;
+        if (token.length === 2 && token.charAt(1) === ':') {
+            switch (token.charAt(0)) {
+                case 'R':
+                    priority = 1;
+                    break;
+                case 'L':
+                    priority = -1;
+                    break;
+                default:
+                    console.log(`Unknown priority ${token} in scope selector`);
+            }
+            token = tokenizer.next();
+        }
+        const matcher = parseConjunction();
+        if (matcher) {
+            results.push({ matcher, priority });
+        }
+        if (token !== ',') {
+            break;
+        }
+        token = tokenizer.next();
+    }
+    function parseOperand() {
+        if (token === '-') {
+            token = tokenizer.next();
+            const expressionToNegate = parseOperand();
+            if (!expressionToNegate) {
+                return null;
+            }
+            return matcherInput => {
+                const score = expressionToNegate(matcherInput);
+                return score < 0 ? 0 : -1;
+            };
+        }
+        if (token === '(') {
+            token = tokenizer.next();
+            const expressionInParents = parseInnerExpression();
+            if (token === ')') {
+                token = tokenizer.next();
+            }
+            return expressionInParents;
+        }
+        if (isIdentifier(token)) {
+            const identifiers = [];
+            do {
+                identifiers.push(token);
+                token = tokenizer.next();
+            } while (isIdentifier(token));
+            return matcherInput => matchesName(identifiers, matcherInput);
+        }
+        return null;
+    }
+    function parseConjunction() {
+        let matcher = parseOperand();
+        if (!matcher) {
+            return null;
+        }
+        const matchers = [];
+        while (matcher) {
+            matchers.push(matcher);
+            matcher = parseOperand();
+        }
+        return matcherInput => {
+            let min = matchers[0](matcherInput);
+            for (let i = 1; min >= 0 && i < matchers.length; i++) {
+                min = Math.min(min, matchers[i](matcherInput));
+            }
+            return min;
+        };
+    }
+    function parseInnerExpression() {
+        let matcher = parseConjunction();
+        if (!matcher) {
+            return null;
+        }
+        const matchers = [];
+        while (matcher) {
+            matchers.push(matcher);
+            if (token === '|' || token === ',') {
+                do {
+                    token = tokenizer.next();
+                } while (token === '|' || token === ',');
+            }
+            else {
+                break;
+            }
+            matcher = parseConjunction();
+        }
+        return matcherInput => {
+            let max = matchers[0](matcherInput);
+            for (let i = 1; i < matchers.length; i++) {
+                max = Math.max(max, matchers[i](matcherInput));
+            }
+            return max;
+        };
+    }
+}
+function isIdentifier(token) {
+    return !!token && !!token.match(/[\w\.:]+/);
+}
+function newTokenizer(input) {
+    const regex = /([LR]:|[\w\.:][\w\.:\-]*|[\,\|\-\(\)])/g;
+    let match = regex.exec(input);
+    return {
+        next: () => {
+            if (!match) {
+                return null;
+            }
+            const res = match[0];
+            match = regex.exec(input);
+            return res;
+        }
+    };
+}
+export { createMatchers };