@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.1

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

@@ -1,439 +0,0 @@
-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/vscode/src/vs/workbench/services/themes/common/productIconThemeSchema.js

@@ -1,94 +0,0 @@
-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/vscode/src/vs/workbench/services/themes/common/textMateScopeMatcher.js

@@ -1,120 +0,0 @@
-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 };