@codingame/monaco-vscode-api 1.78.4 → 1.78.5

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

@@ -0,0 +1,439 @@
+function parse(content) {
+    return _parse(content, null, null);
+}
+function _parse(content, filename, locationKeyName) {
+    const len = content.length;
+    let pos = 0;
+    let line = 1;
+    let char = 0;
+    if (len > 0 && content.charCodeAt(0) === 65279 ) {
+        pos = 1;
+    }
+    function advancePosBy(by) {
+        if (locationKeyName === null) {
+            pos = pos + by;
+        }
+        else {
+            while (by > 0) {
+                const chCode = content.charCodeAt(pos);
+                if (chCode === 10 ) {
+                    pos++;
+                    line++;
+                    char = 0;
+                }
+                else {
+                    pos++;
+                    char++;
+                }
+                by--;
+            }
+        }
+    }
+    function advancePosTo(to) {
+        if (locationKeyName === null) {
+            pos = to;
+        }
+        else {
+            advancePosBy(to - pos);
+        }
+    }
+    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 = {};
+            if (locationKeyName !== null) {
+                newDict[locationKeyName] = {
+                    filename: filename,
+                    line: line,
+                    char: char
+                };
+            }
+            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 = {};
+            if (locationKeyName !== null) {
+                newDict[locationKeyName] = {
+                    filename: filename,
+                    line: line,
+                    char: char
+                };
+            }
+            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 = {};
+            if (locationKeyName !== null) {
+                cur[locationKeyName] = {
+                    filename: filename,
+                    line: line,
+                    char: char
+                };
+            }
+            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/dist/vscode/vs/workbench/services/themes/common/productIconThemeSchema.js

@@ -0,0 +1,94 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+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 { iconsSchemaId } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+const fontIdRegex = '^([\\w_-]+)$';
+const fontStyleRegex = '^(normal|italic|(oblique[ \\w\\s-]+))$';
+const fontWeightRegex = '^(normal|bold|lighter|bolder|(\\d{0-1000}))$';
+const fontSizeRegex = '^([\\w .%_-]+)$';
+const fontFormatRegex = '^woff|woff2|truetype|opentype|embedded-opentype|svg$';
+const schemaId = 'vscode://schemas/product-icon-theme';
+const schema = {
+    type: 'object',
+    allowComments: true,
+    allowTrailingCommas: true,
+    properties: {
+        fonts: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'string',
+                        description: ( nls.localize('schema.id', 'The ID of the font.')),
+                        pattern: fontIdRegex,
+                        patternErrorMessage: ( nls.localize(
+                            'schema.id.formatError',
+                            'The ID must only contain letters, numbers, underscore and minus.'
+                        ))
+                    },
+                    src: {
+                        type: 'array',
+                        description: ( nls.localize('schema.src', 'The location of the font.')),
+                        items: {
+                            type: 'object',
+                            properties: {
+                                path: {
+                                    type: 'string',
+                                    description: ( nls.localize(
+                                        'schema.font-path',
+                                        'The font path, relative to the current product icon theme file.'
+                                    )),
+                                },
+                                format: {
+                                    type: 'string',
+                                    description: ( nls.localize('schema.font-format', 'The format of the font.')),
+                                    enum: ['woff', 'woff2', 'truetype', 'opentype', 'embedded-opentype', 'svg']
+                                }
+                            },
+                            required: [
+                                'path',
+                                'format'
+                            ]
+                        }
+                    },
+                    weight: {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'schema.font-weight',
+                            'The weight of the font. See https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight for valid values.'
+                        )),
+                        anyOf: [
+                            { enum: ['normal', 'bold', 'lighter', 'bolder'] },
+                            { type: 'string', pattern: fontWeightRegex }
+                        ]
+                    },
+                    style: {
+                        type: 'string',
+                        description: ( nls.localize(
+                            'schema.font-style',
+                            'The style of the font. See https://developer.mozilla.org/en-US/docs/Web/CSS/font-style for valid values.'
+                        )),
+                        anyOf: [
+                            { enum: ['normal', 'italic', 'oblique'] },
+                            { type: 'string', pattern: fontStyleRegex }
+                        ]
+                    }
+                },
+                required: [
+                    'id',
+                    'src'
+                ]
+            }
+        },
+        iconDefinitions: {
+            description: ( nls.localize('schema.iconDefinitions', 'Association of icon name to a font character.')),
+            $ref: iconsSchemaId
+        }
+    }
+};
+function registerProductIconThemeSchemas() {
+    const schemaRegistry = ( Registry.as(Extensions.JSONContribution));
+    schemaRegistry.registerSchema(schemaId, schema);
+}
+export { fontFormatRegex, fontIdRegex, fontSizeRegex, fontStyleRegex, fontWeightRegex, registerProductIconThemeSchemas };

package/dist/vscode/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 };