@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

package/dist/extension-tools-b68a64de.js

@@ -1,1024 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-/**
- * @returns whether the provided parameter is a JavaScript String or not.
- */
-function isString(str) {
-    return (typeof str === 'string');
-}
-/**
- * @returns whether the provided parameter is of type `object` but **not**
- *	`null`, an `array`, a `regexp`, nor a `date`.
- */
-function isObject(obj) {
-    // The method can't do a type cast since there are type (like strings) which
-    // are subclasses of any put not positvely matched by the function. Hence type
-    // narrowing results in wrong results.
-    return typeof obj === 'object'
-        && obj !== null
-        && !Array.isArray(obj)
-        && !(obj instanceof RegExp)
-        && !(obj instanceof Date);
-}
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function _format(message, args) {
-    let result;
-    if (args.length === 0) {
-        result = message;
-    }
-    else {
-        result = message.replace(/\{(\d+)\}/g, function (match, rest) {
-            const index = rest[0];
-            return typeof args[index] !== 'undefined' ? args[index] : match;
-        });
-    }
-    return result;
-}
-function localize(data, message, ...args) {
-    return _format(message, args);
-}
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function localizeManifest(extensionManifest, translations, fallbackTranslations) {
-    try {
-        replaceNLStrings(extensionManifest, translations, fallbackTranslations);
-    }
-    catch (error) {
-        console.error(error?.message ?? error);
-        /*Ignore Error*/
-    }
-    return extensionManifest;
-}
-/**
- * This routine makes the following assumptions:
- * The root element is an object literal
- */
-function replaceNLStrings(extensionManifest, messages, originalMessages) {
-    const processEntry = (obj, key, command) => {
-        const value = obj[key];
-        if (isString(value)) {
-            const str = value;
-            const length = str.length;
-            if (length > 1 && str[0] === '%' && str[length - 1] === '%') {
-                const messageKey = str.substr(1, length - 2);
-                let translated = messages[messageKey];
-                // If the messages come from a language pack they might miss some keys
-                // Fill them from the original messages.
-                if (translated === undefined && originalMessages) {
-                    translated = originalMessages[messageKey];
-                }
-                const message = typeof translated === 'string' ? translated : translated?.message;
-                // This branch returns ILocalizedString's instead of Strings so that the Command Palette can contain both the localized and the original value.
-                const original = originalMessages?.[messageKey];
-                const originalMessage = typeof original === 'string' ? original : original?.message;
-                if (!message) {
-                    if (!originalMessage) {
-                        console.warn(`[${extensionManifest.name}]: ${localize('missingNLSKey', "Couldn't find message for key {0}.", messageKey)}`);
-                    }
-                    return;
-                }
-                if (
-                // if we are translating the title or category of a command
-                command && (key === 'title' || key === 'category') &&
-                    // and the original value is not the same as the translated value
-                    originalMessage && originalMessage !== message) {
-                    const localizedString = {
-                        value: message,
-                        original: originalMessage
-                    };
-                    obj[key] = localizedString;
-                }
-                else {
-                    obj[key] = message;
-                }
-            }
-        }
-        else if (isObject(value)) {
-            for (const k in value) {
-                if (value.hasOwnProperty(k)) {
-                    k === 'commands' ? processEntry(value, k, true) : processEntry(value, k, command);
-                }
-            }
-        }
-        else if (Array.isArray(value)) {
-            for (let i = 0; i < value.length; i++) {
-                processEntry(value, i, command);
-            }
-        }
-    };
-    for (const key in extensionManifest) {
-        if (extensionManifest.hasOwnProperty(key)) {
-            processEntry(extensionManifest, key);
-        }
-    }
-}
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var ScanError;
-(function (ScanError) {
-    ScanError[ScanError["None"] = 0] = "None";
-    ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
-    ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
-    ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
-    ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
-    ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
-    ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
-})(ScanError || (ScanError = {}));
-var SyntaxKind;
-(function (SyntaxKind) {
-    SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
-    SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
-    SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
-    SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
-    SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
-    SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
-    SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
-    SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
-    SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
-    SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
-    SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
-    SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
-    SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
-    SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
-    SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
-    SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
-    SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
-})(SyntaxKind || (SyntaxKind = {}));
-var ParseErrorCode;
-(function (ParseErrorCode) {
-    ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
-    ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
-    ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
-    ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
-    ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
-    ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
-    ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
-    ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
-    ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
-    ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
-    ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
-    ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
-    ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
-    ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
-    ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
-    ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
-})(ParseErrorCode || (ParseErrorCode = {}));
-var ParseOptions;
-(function (ParseOptions) {
-    ParseOptions.DEFAULT = {
-        allowTrailingComma: true
-    };
-})(ParseOptions || (ParseOptions = {}));
-/**
- * Creates a JSON scanner on the given text.
- * If ignoreTrivia is set, whitespaces or comments are ignored.
- */
-function createScanner(text, ignoreTrivia = false) {
-    let pos = 0;
-    const len = text.length;
-    let value = '';
-    let tokenOffset = 0;
-    let token = 16 /* SyntaxKind.Unknown */;
-    let scanError = 0 /* ScanError.None */;
-    function scanHexDigits(count) {
-        let digits = 0;
-        let hexValue = 0;
-        while (digits < count) {
-            const ch = text.charCodeAt(pos);
-            if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) {
-                hexValue = hexValue * 16 + ch - 48 /* CharacterCodes._0 */;
-            }
-            else if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) {
-                hexValue = hexValue * 16 + ch - 65 /* CharacterCodes.A */ + 10;
-            }
-            else if (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */) {
-                hexValue = hexValue * 16 + ch - 97 /* CharacterCodes.a */ + 10;
-            }
-            else {
-                break;
-            }
-            pos++;
-            digits++;
-        }
-        if (digits < count) {
-            hexValue = -1;
-        }
-        return hexValue;
-    }
-    function setPosition(newPosition) {
-        pos = newPosition;
-        value = '';
-        tokenOffset = 0;
-        token = 16 /* SyntaxKind.Unknown */;
-        scanError = 0 /* ScanError.None */;
-    }
-    function scanNumber() {
-        const start = pos;
-        if (text.charCodeAt(pos) === 48 /* CharacterCodes._0 */) {
-            pos++;
-        }
-        else {
-            pos++;
-            while (pos < text.length && isDigit(text.charCodeAt(pos))) {
-                pos++;
-            }
-        }
-        if (pos < text.length && text.charCodeAt(pos) === 46 /* CharacterCodes.dot */) {
-            pos++;
-            if (pos < text.length && isDigit(text.charCodeAt(pos))) {
-                pos++;
-                while (pos < text.length && isDigit(text.charCodeAt(pos))) {
-                    pos++;
-                }
-            }
-            else {
-                scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
-                return text.substring(start, pos);
-            }
-        }
-        let end = pos;
-        if (pos < text.length && (text.charCodeAt(pos) === 69 /* CharacterCodes.E */ || text.charCodeAt(pos) === 101 /* CharacterCodes.e */)) {
-            pos++;
-            if (pos < text.length && text.charCodeAt(pos) === 43 /* CharacterCodes.plus */ || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) {
-                pos++;
-            }
-            if (pos < text.length && isDigit(text.charCodeAt(pos))) {
-                pos++;
-                while (pos < text.length && isDigit(text.charCodeAt(pos))) {
-                    pos++;
-                }
-                end = pos;
-            }
-            else {
-                scanError = 3 /* ScanError.UnexpectedEndOfNumber */;
-            }
-        }
-        return text.substring(start, end);
-    }
-    function scanString() {
-        let result = '', start = pos;
-        while (true) {
-            if (pos >= len) {
-                result += text.substring(start, pos);
-                scanError = 2 /* ScanError.UnexpectedEndOfString */;
-                break;
-            }
-            const ch = text.charCodeAt(pos);
-            if (ch === 34 /* CharacterCodes.doubleQuote */) {
-                result += text.substring(start, pos);
-                pos++;
-                break;
-            }
-            if (ch === 92 /* CharacterCodes.backslash */) {
-                result += text.substring(start, pos);
-                pos++;
-                if (pos >= len) {
-                    scanError = 2 /* ScanError.UnexpectedEndOfString */;
-                    break;
-                }
-                const ch2 = text.charCodeAt(pos++);
-                switch (ch2) {
-                    case 34 /* CharacterCodes.doubleQuote */:
-                        result += '\"';
-                        break;
-                    case 92 /* CharacterCodes.backslash */:
-                        result += '\\';
-                        break;
-                    case 47 /* CharacterCodes.slash */:
-                        result += '/';
-                        break;
-                    case 98 /* CharacterCodes.b */:
-                        result += '\b';
-                        break;
-                    case 102 /* CharacterCodes.f */:
-                        result += '\f';
-                        break;
-                    case 110 /* CharacterCodes.n */:
-                        result += '\n';
-                        break;
-                    case 114 /* CharacterCodes.r */:
-                        result += '\r';
-                        break;
-                    case 116 /* CharacterCodes.t */:
-                        result += '\t';
-                        break;
-                    case 117 /* CharacterCodes.u */: {
-                        const ch3 = scanHexDigits(4);
-                        if (ch3 >= 0) {
-                            result += String.fromCharCode(ch3);
-                        }
-                        else {
-                            scanError = 4 /* ScanError.InvalidUnicode */;
-                        }
-                        break;
-                    }
-                    default:
-                        scanError = 5 /* ScanError.InvalidEscapeCharacter */;
-                }
-                start = pos;
-                continue;
-            }
-            if (ch >= 0 && ch <= 0x1F) {
-                if (isLineBreak(ch)) {
-                    result += text.substring(start, pos);
-                    scanError = 2 /* ScanError.UnexpectedEndOfString */;
-                    break;
-                }
-                else {
-                    scanError = 6 /* ScanError.InvalidCharacter */;
-                    // mark as error but continue with string
-                }
-            }
-            pos++;
-        }
-        return result;
-    }
-    function scanNext() {
-        value = '';
-        scanError = 0 /* ScanError.None */;
-        tokenOffset = pos;
-        if (pos >= len) {
-            // at the end
-            tokenOffset = len;
-            return token = 17 /* SyntaxKind.EOF */;
-        }
-        let code = text.charCodeAt(pos);
-        // trivia: whitespace
-        if (isWhitespace(code)) {
-            do {
-                pos++;
-                value += String.fromCharCode(code);
-                code = text.charCodeAt(pos);
-            } while (isWhitespace(code));
-            return token = 15 /* SyntaxKind.Trivia */;
-        }
-        // trivia: newlines
-        if (isLineBreak(code)) {
-            pos++;
-            value += String.fromCharCode(code);
-            if (code === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) {
-                pos++;
-                value += '\n';
-            }
-            return token = 14 /* SyntaxKind.LineBreakTrivia */;
-        }
-        switch (code) {
-            // tokens: []{}:,
-            case 123 /* CharacterCodes.openBrace */:
-                pos++;
-                return token = 1 /* SyntaxKind.OpenBraceToken */;
-            case 125 /* CharacterCodes.closeBrace */:
-                pos++;
-                return token = 2 /* SyntaxKind.CloseBraceToken */;
-            case 91 /* CharacterCodes.openBracket */:
-                pos++;
-                return token = 3 /* SyntaxKind.OpenBracketToken */;
-            case 93 /* CharacterCodes.closeBracket */:
-                pos++;
-                return token = 4 /* SyntaxKind.CloseBracketToken */;
-            case 58 /* CharacterCodes.colon */:
-                pos++;
-                return token = 6 /* SyntaxKind.ColonToken */;
-            case 44 /* CharacterCodes.comma */:
-                pos++;
-                return token = 5 /* SyntaxKind.CommaToken */;
-            // strings
-            case 34 /* CharacterCodes.doubleQuote */:
-                pos++;
-                value = scanString();
-                return token = 10 /* SyntaxKind.StringLiteral */;
-            // comments
-            case 47 /* CharacterCodes.slash */: {
-                const start = pos - 1;
-                // Single-line comment
-                if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
-                    pos += 2;
-                    while (pos < len) {
-                        if (isLineBreak(text.charCodeAt(pos))) {
-                            break;
-                        }
-                        pos++;
-                    }
-                    value = text.substring(start, pos);
-                    return token = 12 /* SyntaxKind.LineCommentTrivia */;
-                }
-                // Multi-line comment
-                if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) {
-                    pos += 2;
-                    const safeLength = len - 1; // For lookahead.
-                    let commentClosed = false;
-                    while (pos < safeLength) {
-                        const ch = text.charCodeAt(pos);
-                        if (ch === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
-                            pos += 2;
-                            commentClosed = true;
-                            break;
-                        }
-                        pos++;
-                    }
-                    if (!commentClosed) {
-                        pos++;
-                        scanError = 1 /* ScanError.UnexpectedEndOfComment */;
-                    }
-                    value = text.substring(start, pos);
-                    return token = 13 /* SyntaxKind.BlockCommentTrivia */;
-                }
-                // just a single slash
-                value += String.fromCharCode(code);
-                pos++;
-                return token = 16 /* SyntaxKind.Unknown */;
-            }
-            // numbers
-            case 45 /* CharacterCodes.minus */:
-                value += String.fromCharCode(code);
-                pos++;
-                if (pos === len || !isDigit(text.charCodeAt(pos))) {
-                    return token = 16 /* SyntaxKind.Unknown */;
-                }
-            // found a minus, followed by a number so
-            // we fall through to proceed with scanning
-            // numbers
-            case 48 /* CharacterCodes._0 */:
-            case 49 /* CharacterCodes._1 */:
-            case 50 /* CharacterCodes._2 */:
-            case 51 /* CharacterCodes._3 */:
-            case 52 /* CharacterCodes._4 */:
-            case 53 /* CharacterCodes._5 */:
-            case 54 /* CharacterCodes._6 */:
-            case 55 /* CharacterCodes._7 */:
-            case 56 /* CharacterCodes._8 */:
-            case 57 /* CharacterCodes._9 */:
-                value += scanNumber();
-                return token = 11 /* SyntaxKind.NumericLiteral */;
-            // literals and unknown symbols
-            default:
-                // is a literal? Read the full word.
-                while (pos < len && isUnknownContentCharacter(code)) {
-                    pos++;
-                    code = text.charCodeAt(pos);
-                }
-                if (tokenOffset !== pos) {
-                    value = text.substring(tokenOffset, pos);
-                    // keywords: true, false, null
-                    switch (value) {
-                        case 'true': return token = 8 /* SyntaxKind.TrueKeyword */;
-                        case 'false': return token = 9 /* SyntaxKind.FalseKeyword */;
-                        case 'null': return token = 7 /* SyntaxKind.NullKeyword */;
-                    }
-                    return token = 16 /* SyntaxKind.Unknown */;
-                }
-                // some
-                value += String.fromCharCode(code);
-                pos++;
-                return token = 16 /* SyntaxKind.Unknown */;
-        }
-    }
-    function isUnknownContentCharacter(code) {
-        if (isWhitespace(code) || isLineBreak(code)) {
-            return false;
-        }
-        switch (code) {
-            case 125 /* CharacterCodes.closeBrace */:
-            case 93 /* CharacterCodes.closeBracket */:
-            case 123 /* CharacterCodes.openBrace */:
-            case 91 /* CharacterCodes.openBracket */:
-            case 34 /* CharacterCodes.doubleQuote */:
-            case 58 /* CharacterCodes.colon */:
-            case 44 /* CharacterCodes.comma */:
-            case 47 /* CharacterCodes.slash */:
-                return false;
-        }
-        return true;
-    }
-    function scanNextNonTrivia() {
-        let result;
-        do {
-            result = scanNext();
-        } while (result >= 12 /* SyntaxKind.LineCommentTrivia */ && result <= 15 /* SyntaxKind.Trivia */);
-        return result;
-    }
-    return {
-        setPosition: setPosition,
-        getPosition: () => pos,
-        scan: ignoreTrivia ? scanNextNonTrivia : scanNext,
-        getToken: () => token,
-        getTokenValue: () => value,
-        getTokenOffset: () => tokenOffset,
-        getTokenLength: () => pos - tokenOffset,
-        getTokenError: () => scanError
-    };
-}
-function isWhitespace(ch) {
-    return ch === 32 /* CharacterCodes.space */ || ch === 9 /* CharacterCodes.tab */ || ch === 11 /* CharacterCodes.verticalTab */ || ch === 12 /* CharacterCodes.formFeed */ ||
-        ch === 160 /* CharacterCodes.nonBreakingSpace */ || ch === 5760 /* CharacterCodes.ogham */ || ch >= 8192 /* CharacterCodes.enQuad */ && ch <= 8203 /* CharacterCodes.zeroWidthSpace */ ||
-        ch === 8239 /* CharacterCodes.narrowNoBreakSpace */ || ch === 8287 /* CharacterCodes.mathematicalSpace */ || ch === 12288 /* CharacterCodes.ideographicSpace */ || ch === 65279 /* CharacterCodes.byteOrderMark */;
-}
-function isLineBreak(ch) {
-    return ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */ || ch === 8232 /* CharacterCodes.lineSeparator */ || ch === 8233 /* CharacterCodes.paragraphSeparator */;
-}
-function isDigit(ch) {
-    return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */;
-}
-var CharacterCodes;
-(function (CharacterCodes) {
-    CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter";
-    CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter";
-    CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
-    CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
-    CharacterCodes[CharacterCodes["lineSeparator"] = 8232] = "lineSeparator";
-    CharacterCodes[CharacterCodes["paragraphSeparator"] = 8233] = "paragraphSeparator";
-    // REVIEW: do we need to support this?  The scanner doesn't, but our IText does.  This seems
-    // like an odd disparity?  (Or maybe it's completely fine for them to be different).
-    CharacterCodes[CharacterCodes["nextLine"] = 133] = "nextLine";
-    // Unicode 3.0 space characters
-    CharacterCodes[CharacterCodes["space"] = 32] = "space";
-    CharacterCodes[CharacterCodes["nonBreakingSpace"] = 160] = "nonBreakingSpace";
-    CharacterCodes[CharacterCodes["enQuad"] = 8192] = "enQuad";
-    CharacterCodes[CharacterCodes["emQuad"] = 8193] = "emQuad";
-    CharacterCodes[CharacterCodes["enSpace"] = 8194] = "enSpace";
-    CharacterCodes[CharacterCodes["emSpace"] = 8195] = "emSpace";
-    CharacterCodes[CharacterCodes["threePerEmSpace"] = 8196] = "threePerEmSpace";
-    CharacterCodes[CharacterCodes["fourPerEmSpace"] = 8197] = "fourPerEmSpace";
-    CharacterCodes[CharacterCodes["sixPerEmSpace"] = 8198] = "sixPerEmSpace";
-    CharacterCodes[CharacterCodes["figureSpace"] = 8199] = "figureSpace";
-    CharacterCodes[CharacterCodes["punctuationSpace"] = 8200] = "punctuationSpace";
-    CharacterCodes[CharacterCodes["thinSpace"] = 8201] = "thinSpace";
-    CharacterCodes[CharacterCodes["hairSpace"] = 8202] = "hairSpace";
-    CharacterCodes[CharacterCodes["zeroWidthSpace"] = 8203] = "zeroWidthSpace";
-    CharacterCodes[CharacterCodes["narrowNoBreakSpace"] = 8239] = "narrowNoBreakSpace";
-    CharacterCodes[CharacterCodes["ideographicSpace"] = 12288] = "ideographicSpace";
-    CharacterCodes[CharacterCodes["mathematicalSpace"] = 8287] = "mathematicalSpace";
-    CharacterCodes[CharacterCodes["ogham"] = 5760] = "ogham";
-    CharacterCodes[CharacterCodes["_"] = 95] = "_";
-    CharacterCodes[CharacterCodes["$"] = 36] = "$";
-    CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
-    CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
-    CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
-    CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
-    CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
-    CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
-    CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
-    CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
-    CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
-    CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
-    CharacterCodes[CharacterCodes["a"] = 97] = "a";
-    CharacterCodes[CharacterCodes["b"] = 98] = "b";
-    CharacterCodes[CharacterCodes["c"] = 99] = "c";
-    CharacterCodes[CharacterCodes["d"] = 100] = "d";
-    CharacterCodes[CharacterCodes["e"] = 101] = "e";
-    CharacterCodes[CharacterCodes["f"] = 102] = "f";
-    CharacterCodes[CharacterCodes["g"] = 103] = "g";
-    CharacterCodes[CharacterCodes["h"] = 104] = "h";
-    CharacterCodes[CharacterCodes["i"] = 105] = "i";
-    CharacterCodes[CharacterCodes["j"] = 106] = "j";
-    CharacterCodes[CharacterCodes["k"] = 107] = "k";
-    CharacterCodes[CharacterCodes["l"] = 108] = "l";
-    CharacterCodes[CharacterCodes["m"] = 109] = "m";
-    CharacterCodes[CharacterCodes["n"] = 110] = "n";
-    CharacterCodes[CharacterCodes["o"] = 111] = "o";
-    CharacterCodes[CharacterCodes["p"] = 112] = "p";
-    CharacterCodes[CharacterCodes["q"] = 113] = "q";
-    CharacterCodes[CharacterCodes["r"] = 114] = "r";
-    CharacterCodes[CharacterCodes["s"] = 115] = "s";
-    CharacterCodes[CharacterCodes["t"] = 116] = "t";
-    CharacterCodes[CharacterCodes["u"] = 117] = "u";
-    CharacterCodes[CharacterCodes["v"] = 118] = "v";
-    CharacterCodes[CharacterCodes["w"] = 119] = "w";
-    CharacterCodes[CharacterCodes["x"] = 120] = "x";
-    CharacterCodes[CharacterCodes["y"] = 121] = "y";
-    CharacterCodes[CharacterCodes["z"] = 122] = "z";
-    CharacterCodes[CharacterCodes["A"] = 65] = "A";
-    CharacterCodes[CharacterCodes["B"] = 66] = "B";
-    CharacterCodes[CharacterCodes["C"] = 67] = "C";
-    CharacterCodes[CharacterCodes["D"] = 68] = "D";
-    CharacterCodes[CharacterCodes["E"] = 69] = "E";
-    CharacterCodes[CharacterCodes["F"] = 70] = "F";
-    CharacterCodes[CharacterCodes["G"] = 71] = "G";
-    CharacterCodes[CharacterCodes["H"] = 72] = "H";
-    CharacterCodes[CharacterCodes["I"] = 73] = "I";
-    CharacterCodes[CharacterCodes["J"] = 74] = "J";
-    CharacterCodes[CharacterCodes["K"] = 75] = "K";
-    CharacterCodes[CharacterCodes["L"] = 76] = "L";
-    CharacterCodes[CharacterCodes["M"] = 77] = "M";
-    CharacterCodes[CharacterCodes["N"] = 78] = "N";
-    CharacterCodes[CharacterCodes["O"] = 79] = "O";
-    CharacterCodes[CharacterCodes["P"] = 80] = "P";
-    CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
-    CharacterCodes[CharacterCodes["R"] = 82] = "R";
-    CharacterCodes[CharacterCodes["S"] = 83] = "S";
-    CharacterCodes[CharacterCodes["T"] = 84] = "T";
-    CharacterCodes[CharacterCodes["U"] = 85] = "U";
-    CharacterCodes[CharacterCodes["V"] = 86] = "V";
-    CharacterCodes[CharacterCodes["W"] = 87] = "W";
-    CharacterCodes[CharacterCodes["X"] = 88] = "X";
-    CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
-    CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
-    CharacterCodes[CharacterCodes["ampersand"] = 38] = "ampersand";
-    CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
-    CharacterCodes[CharacterCodes["at"] = 64] = "at";
-    CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
-    CharacterCodes[CharacterCodes["bar"] = 124] = "bar";
-    CharacterCodes[CharacterCodes["caret"] = 94] = "caret";
-    CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
-    CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
-    CharacterCodes[CharacterCodes["closeParen"] = 41] = "closeParen";
-    CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
-    CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
-    CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
-    CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
-    CharacterCodes[CharacterCodes["equals"] = 61] = "equals";
-    CharacterCodes[CharacterCodes["exclamation"] = 33] = "exclamation";
-    CharacterCodes[CharacterCodes["greaterThan"] = 62] = "greaterThan";
-    CharacterCodes[CharacterCodes["lessThan"] = 60] = "lessThan";
-    CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
-    CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
-    CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
-    CharacterCodes[CharacterCodes["openParen"] = 40] = "openParen";
-    CharacterCodes[CharacterCodes["percent"] = 37] = "percent";
-    CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
-    CharacterCodes[CharacterCodes["question"] = 63] = "question";
-    CharacterCodes[CharacterCodes["semicolon"] = 59] = "semicolon";
-    CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote";
-    CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
-    CharacterCodes[CharacterCodes["tilde"] = 126] = "tilde";
-    CharacterCodes[CharacterCodes["backspace"] = 8] = "backspace";
-    CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
-    CharacterCodes[CharacterCodes["byteOrderMark"] = 65279] = "byteOrderMark";
-    CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
-    CharacterCodes[CharacterCodes["verticalTab"] = 11] = "verticalTab";
-})(CharacterCodes || (CharacterCodes = {}));
-/**
- * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
- * Therefore always check the errors list to find out if the input was valid.
- */
-function parse(text, errors = [], options = ParseOptions.DEFAULT) {
-    let currentProperty = null;
-    let currentParent = [];
-    const previousParents = [];
-    function onValue(value) {
-        if (Array.isArray(currentParent)) {
-            currentParent.push(value);
-        }
-        else if (currentProperty !== null) {
-            currentParent[currentProperty] = value;
-        }
-    }
-    const visitor = {
-        onObjectBegin: () => {
-            const object = {};
-            onValue(object);
-            previousParents.push(currentParent);
-            currentParent = object;
-            currentProperty = null;
-        },
-        onObjectProperty: (name) => {
-            currentProperty = name;
-        },
-        onObjectEnd: () => {
-            currentParent = previousParents.pop();
-        },
-        onArrayBegin: () => {
-            const array = [];
-            onValue(array);
-            previousParents.push(currentParent);
-            currentParent = array;
-            currentProperty = null;
-        },
-        onArrayEnd: () => {
-            currentParent = previousParents.pop();
-        },
-        onLiteralValue: onValue,
-        onError: (error, offset, length) => {
-            errors.push({ error, offset, length });
-        }
-    };
-    visit(text, visitor, options);
-    return currentParent[0];
-}
-/**
- * Parses the given text and invokes the visitor functions for each object, array and literal reached.
- */
-function visit(text, visitor, options = ParseOptions.DEFAULT) {
-    const _scanner = createScanner(text, false);
-    function toNoArgVisit(visitFunction) {
-        return visitFunction ? () => visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength()) : () => true;
-    }
-    function toOneArgVisit(visitFunction) {
-        return visitFunction ? (arg) => visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength()) : () => true;
-    }
-    const onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);
-    const disallowComments = options && options.disallowComments;
-    const allowTrailingComma = options && options.allowTrailingComma;
-    function scanNext() {
-        while (true) {
-            const token = _scanner.scan();
-            switch (_scanner.getTokenError()) {
-                case 4 /* ScanError.InvalidUnicode */:
-                    handleError(14 /* ParseErrorCode.InvalidUnicode */);
-                    break;
-                case 5 /* ScanError.InvalidEscapeCharacter */:
-                    handleError(15 /* ParseErrorCode.InvalidEscapeCharacter */);
-                    break;
-                case 3 /* ScanError.UnexpectedEndOfNumber */:
-                    handleError(13 /* ParseErrorCode.UnexpectedEndOfNumber */);
-                    break;
-                case 1 /* ScanError.UnexpectedEndOfComment */:
-                    if (!disallowComments) {
-                        handleError(11 /* ParseErrorCode.UnexpectedEndOfComment */);
-                    }
-                    break;
-                case 2 /* ScanError.UnexpectedEndOfString */:
-                    handleError(12 /* ParseErrorCode.UnexpectedEndOfString */);
-                    break;
-                case 6 /* ScanError.InvalidCharacter */:
-                    handleError(16 /* ParseErrorCode.InvalidCharacter */);
-                    break;
-            }
-            switch (token) {
-                case 12 /* SyntaxKind.LineCommentTrivia */:
-                case 13 /* SyntaxKind.BlockCommentTrivia */:
-                    if (disallowComments) {
-                        handleError(10 /* ParseErrorCode.InvalidCommentToken */);
-                    }
-                    else {
-                        onComment();
-                    }
-                    break;
-                case 16 /* SyntaxKind.Unknown */:
-                    handleError(1 /* ParseErrorCode.InvalidSymbol */);
-                    break;
-                case 15 /* SyntaxKind.Trivia */:
-                case 14 /* SyntaxKind.LineBreakTrivia */:
-                    break;
-                default:
-                    return token;
-            }
-        }
-    }
-    function handleError(error, skipUntilAfter = [], skipUntil = []) {
-        onError(error);
-        if (skipUntilAfter.length + skipUntil.length > 0) {
-            let token = _scanner.getToken();
-            while (token !== 17 /* SyntaxKind.EOF */) {
-                if (skipUntilAfter.indexOf(token) !== -1) {
-                    scanNext();
-                    break;
-                }
-                else if (skipUntil.indexOf(token) !== -1) {
-                    break;
-                }
-                token = scanNext();
-            }
-        }
-    }
-    function parseString(isValue) {
-        const value = _scanner.getTokenValue();
-        if (isValue) {
-            onLiteralValue(value);
-        }
-        else {
-            onObjectProperty(value);
-        }
-        scanNext();
-        return true;
-    }
-    function parseLiteral() {
-        switch (_scanner.getToken()) {
-            case 11 /* SyntaxKind.NumericLiteral */: {
-                let value = 0;
-                try {
-                    value = JSON.parse(_scanner.getTokenValue());
-                    if (typeof value !== 'number') {
-                        handleError(2 /* ParseErrorCode.InvalidNumberFormat */);
-                        value = 0;
-                    }
-                }
-                catch (e) {
-                    handleError(2 /* ParseErrorCode.InvalidNumberFormat */);
-                }
-                onLiteralValue(value);
-                break;
-            }
-            case 7 /* SyntaxKind.NullKeyword */:
-                onLiteralValue(null);
-                break;
-            case 8 /* SyntaxKind.TrueKeyword */:
-                onLiteralValue(true);
-                break;
-            case 9 /* SyntaxKind.FalseKeyword */:
-                onLiteralValue(false);
-                break;
-            default:
-                return false;
-        }
-        scanNext();
-        return true;
-    }
-    function parseProperty() {
-        if (_scanner.getToken() !== 10 /* SyntaxKind.StringLiteral */) {
-            handleError(3 /* ParseErrorCode.PropertyNameExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
-            return false;
-        }
-        parseString(false);
-        if (_scanner.getToken() === 6 /* SyntaxKind.ColonToken */) {
-            onSeparator(':');
-            scanNext(); // consume colon
-            if (!parseValue()) {
-                handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
-            }
-        }
-        else {
-            handleError(5 /* ParseErrorCode.ColonExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
-        }
-        return true;
-    }
-    function parseObject() {
-        onObjectBegin();
-        scanNext(); // consume open brace
-        let needsComma = false;
-        while (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
-            if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
-                if (!needsComma) {
-                    handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
-                }
-                onSeparator(',');
-                scanNext(); // consume comma
-                if (_scanner.getToken() === 2 /* SyntaxKind.CloseBraceToken */ && allowTrailingComma) {
-                    break;
-                }
-            }
-            else if (needsComma) {
-                handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
-            }
-            if (!parseProperty()) {
-                handleError(4 /* ParseErrorCode.ValueExpected */, [], [2 /* SyntaxKind.CloseBraceToken */, 5 /* SyntaxKind.CommaToken */]);
-            }
-            needsComma = true;
-        }
-        onObjectEnd();
-        if (_scanner.getToken() !== 2 /* SyntaxKind.CloseBraceToken */) {
-            handleError(7 /* ParseErrorCode.CloseBraceExpected */, [2 /* SyntaxKind.CloseBraceToken */], []);
-        }
-        else {
-            scanNext(); // consume close brace
-        }
-        return true;
-    }
-    function parseArray() {
-        onArrayBegin();
-        scanNext(); // consume open bracket
-        let needsComma = false;
-        while (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */ && _scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
-            if (_scanner.getToken() === 5 /* SyntaxKind.CommaToken */) {
-                if (!needsComma) {
-                    handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
-                }
-                onSeparator(',');
-                scanNext(); // consume comma
-                if (_scanner.getToken() === 4 /* SyntaxKind.CloseBracketToken */ && allowTrailingComma) {
-                    break;
-                }
-            }
-            else if (needsComma) {
-                handleError(6 /* ParseErrorCode.CommaExpected */, [], []);
-            }
-            if (!parseValue()) {
-                handleError(4 /* ParseErrorCode.ValueExpected */, [], [4 /* SyntaxKind.CloseBracketToken */, 5 /* SyntaxKind.CommaToken */]);
-            }
-            needsComma = true;
-        }
-        onArrayEnd();
-        if (_scanner.getToken() !== 4 /* SyntaxKind.CloseBracketToken */) {
-            handleError(8 /* ParseErrorCode.CloseBracketExpected */, [4 /* SyntaxKind.CloseBracketToken */], []);
-        }
-        else {
-            scanNext(); // consume close bracket
-        }
-        return true;
-    }
-    function parseValue() {
-        switch (_scanner.getToken()) {
-            case 3 /* SyntaxKind.OpenBracketToken */:
-                return parseArray();
-            case 1 /* SyntaxKind.OpenBraceToken */:
-                return parseObject();
-            case 10 /* SyntaxKind.StringLiteral */:
-                return parseString(true);
-            default:
-                return parseLiteral();
-        }
-    }
-    scanNext();
-    if (_scanner.getToken() === 17 /* SyntaxKind.EOF */) {
-        if (options.allowEmptyContent) {
-            return true;
-        }
-        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
-        return false;
-    }
-    if (!parseValue()) {
-        handleError(4 /* ParseErrorCode.ValueExpected */, [], []);
-        return false;
-    }
-    if (_scanner.getToken() !== 17 /* SyntaxKind.EOF */) {
-        handleError(9 /* ParseErrorCode.EndOfFileExpected */, [], []);
-    }
-    return true;
-}
-
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-function getParseErrorMessage(errorCode) {
-    switch (errorCode) {
-        case 1 /* ParseErrorCode.InvalidSymbol */: return localize('error.invalidSymbol', 'Invalid symbol');
-        case 2 /* ParseErrorCode.InvalidNumberFormat */: return localize('error.invalidNumberFormat', 'Invalid number format');
-        case 3 /* ParseErrorCode.PropertyNameExpected */: return localize('error.propertyNameExpected', 'Property name expected');
-        case 4 /* ParseErrorCode.ValueExpected */: return localize('error.valueExpected', 'Value expected');
-        case 5 /* ParseErrorCode.ColonExpected */: return localize('error.colonExpected', 'Colon expected');
-        case 6 /* ParseErrorCode.CommaExpected */: return localize('error.commaExpected', 'Comma expected');
-        case 7 /* ParseErrorCode.CloseBraceExpected */: return localize('error.closeBraceExpected', 'Closing brace expected');
-        case 8 /* ParseErrorCode.CloseBracketExpected */: return localize('error.closeBracketExpected', 'Closing bracket expected');
-        case 9 /* ParseErrorCode.EndOfFileExpected */: return localize('error.endOfFileExpected', 'End of file expected');
-        default:
-            return '';
-    }
-}
-
-function extractCommandPaths(command) {
-    if (Array.isArray(command)) {
-        return command.flatMap(extractCommandPaths);
-    }
-    if (command.icon != null) {
-        if (typeof command.icon === 'object') {
-            return [command.icon.light, command.icon.dark];
-        }
-        else {
-            return [command.icon];
-        }
-    }
-    return [];
-}
-function extractGrammarPaths(grammar) {
-    return [grammar.path];
-}
-function extractLanguagePaths(language) {
-    const paths = [];
-    if (language.icon != null) {
-        paths.push(language.icon.dark, language.icon.light);
-    }
-    if (language.configuration != null) {
-        paths.push(language.configuration);
-    }
-    return paths;
-}
-function extractSnippetsPaths(snippet) {
-    return [snippet.path];
-}
-function extractThemePaths(theme) {
-    return [theme.path];
-}
-function extractPathsFromExtensionManifestContribute(contribute) {
-    const paths = [];
-    if (contribute.commands != null)
-        paths.push(...extractCommandPaths(contribute.commands));
-    if (contribute.grammars != null)
-        paths.push(...contribute.grammars.flatMap(extractGrammarPaths));
-    if (contribute.languages != null)
-        paths.push(...contribute.languages.flatMap(extractLanguagePaths));
-    if (contribute.snippets != null)
-        paths.push(...contribute.snippets.flatMap(extractSnippetsPaths));
-    if (contribute.themes != null)
-        paths.push(...contribute.themes.flatMap(extractThemePaths));
-    if (contribute.iconThemes != null)
-        paths.push(...contribute.iconThemes.flatMap(extractThemePaths));
-    if (contribute.productIconThemes != null)
-        paths.push(...contribute.productIconThemes.flatMap(extractThemePaths));
-    return Array.from(new Set(paths));
-}
-function extractPathsFromExtensionManifest(manifest) {
-    return manifest.contributes != null ? extractPathsFromExtensionManifestContribute(manifest.contributes) : [];
-}
-function parseJson(path, text) {
-    const errors = [];
-    const result = parse(text, errors);
-    if (errors.length > 0) {
-        throw new Error(`Failed to parse ${path}:\n${errors.map(error => `    ${getParseErrorMessage(error.error)}`).join('\n')}`);
-    }
-    return result;
-}
-
-export { extractPathsFromExtensionManifest as e, localizeManifest as l, parseJson as p };