vscode-json-languageservice 5.0.0 → 5.1.1

package/lib/umd/utils/colors.js

@@ -1,84 +1,84 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.colorFrom256RGB = exports.colorFromHex = exports.hexDigit = void 0;
-    const Digit0 = 48;
-    const Digit9 = 57;
-    const A = 65;
-    const a = 97;
-    const f = 102;
-    function hexDigit(charCode) {
-        if (charCode < Digit0) {
-            return 0;
-        }
-        if (charCode <= Digit9) {
-            return charCode - Digit0;
-        }
-        if (charCode < a) {
-            charCode += (a - A);
-        }
-        if (charCode >= a && charCode <= f) {
-            return charCode - a + 10;
-        }
-        return 0;
-    }
-    exports.hexDigit = hexDigit;
-    function colorFromHex(text) {
-        if (text[0] !== '#') {
-            return undefined;
-        }
-        switch (text.length) {
-            case 4:
-                return {
-                    red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,
-                    green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,
-                    blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,
-                    alpha: 1
-                };
-            case 5:
-                return {
-                    red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,
-                    green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,
-                    blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,
-                    alpha: (hexDigit(text.charCodeAt(4)) * 0x11) / 255.0,
-                };
-            case 7:
-                return {
-                    red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
-                    green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
-                    blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
-                    alpha: 1
-                };
-            case 9:
-                return {
-                    red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
-                    green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
-                    blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
-                    alpha: (hexDigit(text.charCodeAt(7)) * 0x10 + hexDigit(text.charCodeAt(8))) / 255.0
-                };
-        }
-        return undefined;
-    }
-    exports.colorFromHex = colorFromHex;
-    function colorFrom256RGB(red, green, blue, alpha = 1.0) {
-        return {
-            red: red / 255.0,
-            green: green / 255.0,
-            blue: blue / 255.0,
-            alpha
-        };
-    }
-    exports.colorFrom256RGB = colorFrom256RGB;
-});
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.colorFrom256RGB = exports.colorFromHex = exports.hexDigit = void 0;
+    const Digit0 = 48;
+    const Digit9 = 57;
+    const A = 65;
+    const a = 97;
+    const f = 102;
+    function hexDigit(charCode) {
+        if (charCode < Digit0) {
+            return 0;
+        }
+        if (charCode <= Digit9) {
+            return charCode - Digit0;
+        }
+        if (charCode < a) {
+            charCode += (a - A);
+        }
+        if (charCode >= a && charCode <= f) {
+            return charCode - a + 10;
+        }
+        return 0;
+    }
+    exports.hexDigit = hexDigit;
+    function colorFromHex(text) {
+        if (text[0] !== '#') {
+            return undefined;
+        }
+        switch (text.length) {
+            case 4:
+                return {
+                    red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,
+                    green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,
+                    blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,
+                    alpha: 1
+                };
+            case 5:
+                return {
+                    red: (hexDigit(text.charCodeAt(1)) * 0x11) / 255.0,
+                    green: (hexDigit(text.charCodeAt(2)) * 0x11) / 255.0,
+                    blue: (hexDigit(text.charCodeAt(3)) * 0x11) / 255.0,
+                    alpha: (hexDigit(text.charCodeAt(4)) * 0x11) / 255.0,
+                };
+            case 7:
+                return {
+                    red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
+                    green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
+                    blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
+                    alpha: 1
+                };
+            case 9:
+                return {
+                    red: (hexDigit(text.charCodeAt(1)) * 0x10 + hexDigit(text.charCodeAt(2))) / 255.0,
+                    green: (hexDigit(text.charCodeAt(3)) * 0x10 + hexDigit(text.charCodeAt(4))) / 255.0,
+                    blue: (hexDigit(text.charCodeAt(5)) * 0x10 + hexDigit(text.charCodeAt(6))) / 255.0,
+                    alpha: (hexDigit(text.charCodeAt(7)) * 0x10 + hexDigit(text.charCodeAt(8))) / 255.0
+                };
+        }
+        return undefined;
+    }
+    exports.colorFromHex = colorFromHex;
+    function colorFrom256RGB(red, green, blue, alpha = 1.0) {
+        return {
+            red: red / 255.0,
+            green: green / 255.0,
+            blue: blue / 255.0,
+            alpha
+        };
+    }
+    exports.colorFrom256RGB = colorFrom256RGB;
+});

package/lib/umd/utils/glob.js

@@ -1,138 +1,138 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.createRegex = void 0;
-    /*---------------------------------------------------------------------------------------------
-     *  Copyright (c) Microsoft Corporation. All rights reserved.
-     *  Copyright (c) 2013, Nick Fitzgerald
-     *  Licensed under the MIT License. See LICENCE.md in the project root for license information.
-     *--------------------------------------------------------------------------------------------*/
-    function createRegex(glob, opts) {
-        if (typeof glob !== 'string') {
-            throw new TypeError('Expected a string');
-        }
-        const str = String(glob);
-        // The regexp we are building, as a string.
-        let reStr = "";
-        // Whether we are matching so called "extended" globs (like bash) and should
-        // support single character matching, matching ranges of characters, group
-        // matching, etc.
-        const extended = opts ? !!opts.extended : false;
-        // When globstar is _false_ (default), '/foo/*' is translated a regexp like
-        // '^\/foo\/.*$' which will match any string beginning with '/foo/'
-        // When globstar is _true_, '/foo/*' is translated to regexp like
-        // '^\/foo\/[^/]*$' which will match any string beginning with '/foo/' BUT
-        // which does not have a '/' to the right of it.
-        // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but
-        // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
-        // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
-        // globstar is _false_
-        const globstar = opts ? !!opts.globstar : false;
-        // If we are doing extended matching, this boolean is true when we are inside
-        // a group (eg {*.html,*.js}), and false otherwise.
-        let inGroup = false;
-        // RegExp flags (eg "i" ) to pass in to RegExp constructor.
-        const flags = opts && typeof (opts.flags) === "string" ? opts.flags : "";
-        let c;
-        for (let i = 0, len = str.length; i < len; i++) {
-            c = str[i];
-            switch (c) {
-                case "/":
-                case "$":
-                case "^":
-                case "+":
-                case ".":
-                case "(":
-                case ")":
-                case "=":
-                case "!":
-                case "|":
-                    reStr += "\\" + c;
-                    break;
-                case "?":
-                    if (extended) {
-                        reStr += ".";
-                        break;
-                    }
-                case "[":
-                case "]":
-                    if (extended) {
-                        reStr += c;
-                        break;
-                    }
-                case "{":
-                    if (extended) {
-                        inGroup = true;
-                        reStr += "(";
-                        break;
-                    }
-                case "}":
-                    if (extended) {
-                        inGroup = false;
-                        reStr += ")";
-                        break;
-                    }
-                case ",":
-                    if (inGroup) {
-                        reStr += "|";
-                        break;
-                    }
-                    reStr += "\\" + c;
-                    break;
-                case "*":
-                    // Move over all consecutive "*"'s.
-                    // Also store the previous and next characters
-                    const prevChar = str[i - 1];
-                    let starCount = 1;
-                    while (str[i + 1] === "*") {
-                        starCount++;
-                        i++;
-                    }
-                    const nextChar = str[i + 1];
-                    if (!globstar) {
-                        // globstar is disabled, so treat any number of "*" as one
-                        reStr += ".*";
-                    }
-                    else {
-                        // globstar is enabled, so determine if this is a globstar segment
-                        const isGlobstar = starCount > 1 // multiple "*"'s
-                            && (prevChar === "/" || prevChar === undefined || prevChar === '{' || prevChar === ',') // from the start of the segment
-                            && (nextChar === "/" || nextChar === undefined || nextChar === ',' || nextChar === '}'); // to the end of the segment
-                        if (isGlobstar) {
-                            if (nextChar === "/") {
-                                i++; // move over the "/"
-                            }
-                            else if (prevChar === '/' && reStr.endsWith('\\/')) {
-                                reStr = reStr.substr(0, reStr.length - 2);
-                            }
-                            // it's a globstar, so match zero or more path segments
-                            reStr += "((?:[^/]*(?:\/|$))*)";
-                        }
-                        else {
-                            // it's not a globstar, so only match one path segment
-                            reStr += "([^/]*)";
-                        }
-                    }
-                    break;
-                default:
-                    reStr += c;
-            }
-        }
-        // When regexp 'g' flag is specified don't
-        // constrain the regular expression with ^ & $
-        if (!flags || !~flags.indexOf('g')) {
-            reStr = "^" + reStr + "$";
-        }
-        return new RegExp(reStr, flags);
-    }
-    exports.createRegex = createRegex;
-    ;
-});
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createRegex = void 0;
+    /*---------------------------------------------------------------------------------------------
+     *  Copyright (c) Microsoft Corporation. All rights reserved.
+     *  Copyright (c) 2013, Nick Fitzgerald
+     *  Licensed under the MIT License. See LICENCE.md in the project root for license information.
+     *--------------------------------------------------------------------------------------------*/
+    function createRegex(glob, opts) {
+        if (typeof glob !== 'string') {
+            throw new TypeError('Expected a string');
+        }
+        const str = String(glob);
+        // The regexp we are building, as a string.
+        let reStr = "";
+        // Whether we are matching so called "extended" globs (like bash) and should
+        // support single character matching, matching ranges of characters, group
+        // matching, etc.
+        const extended = opts ? !!opts.extended : false;
+        // When globstar is _false_ (default), '/foo/*' is translated a regexp like
+        // '^\/foo\/.*$' which will match any string beginning with '/foo/'
+        // When globstar is _true_, '/foo/*' is translated to regexp like
+        // '^\/foo\/[^/]*$' which will match any string beginning with '/foo/' BUT
+        // which does not have a '/' to the right of it.
+        // E.g. with '/foo/*' these will match: '/foo/bar', '/foo/bar.txt' but
+        // these will not '/foo/bar/baz', '/foo/bar/baz.txt'
+        // Lastely, when globstar is _true_, '/foo/**' is equivelant to '/foo/*' when
+        // globstar is _false_
+        const globstar = opts ? !!opts.globstar : false;
+        // If we are doing extended matching, this boolean is true when we are inside
+        // a group (eg {*.html,*.js}), and false otherwise.
+        let inGroup = false;
+        // RegExp flags (eg "i" ) to pass in to RegExp constructor.
+        const flags = opts && typeof (opts.flags) === "string" ? opts.flags : "";
+        let c;
+        for (let i = 0, len = str.length; i < len; i++) {
+            c = str[i];
+            switch (c) {
+                case "/":
+                case "$":
+                case "^":
+                case "+":
+                case ".":
+                case "(":
+                case ")":
+                case "=":
+                case "!":
+                case "|":
+                    reStr += "\\" + c;
+                    break;
+                case "?":
+                    if (extended) {
+                        reStr += ".";
+                        break;
+                    }
+                case "[":
+                case "]":
+                    if (extended) {
+                        reStr += c;
+                        break;
+                    }
+                case "{":
+                    if (extended) {
+                        inGroup = true;
+                        reStr += "(";
+                        break;
+                    }
+                case "}":
+                    if (extended) {
+                        inGroup = false;
+                        reStr += ")";
+                        break;
+                    }
+                case ",":
+                    if (inGroup) {
+                        reStr += "|";
+                        break;
+                    }
+                    reStr += "\\" + c;
+                    break;
+                case "*":
+                    // Move over all consecutive "*"'s.
+                    // Also store the previous and next characters
+                    const prevChar = str[i - 1];
+                    let starCount = 1;
+                    while (str[i + 1] === "*") {
+                        starCount++;
+                        i++;
+                    }
+                    const nextChar = str[i + 1];
+                    if (!globstar) {
+                        // globstar is disabled, so treat any number of "*" as one
+                        reStr += ".*";
+                    }
+                    else {
+                        // globstar is enabled, so determine if this is a globstar segment
+                        const isGlobstar = starCount > 1 // multiple "*"'s
+                            && (prevChar === "/" || prevChar === undefined || prevChar === '{' || prevChar === ',') // from the start of the segment
+                            && (nextChar === "/" || nextChar === undefined || nextChar === ',' || nextChar === '}'); // to the end of the segment
+                        if (isGlobstar) {
+                            if (nextChar === "/") {
+                                i++; // move over the "/"
+                            }
+                            else if (prevChar === '/' && reStr.endsWith('\\/')) {
+                                reStr = reStr.substr(0, reStr.length - 2);
+                            }
+                            // it's a globstar, so match zero or more path segments
+                            reStr += "((?:[^/]*(?:\/|$))*)";
+                        }
+                        else {
+                            // it's not a globstar, so only match one path segment
+                            reStr += "([^/]*)";
+                        }
+                    }
+                    break;
+                default:
+                    reStr += c;
+            }
+        }
+        // When regexp 'g' flag is specified don't
+        // constrain the regular expression with ^ & $
+        if (!flags || !~flags.indexOf('g')) {
+            reStr = "^" + reStr + "$";
+        }
+        return new RegExp(reStr, flags);
+    }
+    exports.createRegex = createRegex;
+    ;
+});

package/lib/umd/utils/json.js

@@ -1,56 +1,56 @@
-/*---------------------------------------------------------------------------------------------
-*  Copyright (c) Microsoft Corporation. All rights reserved.
-*  Licensed under the MIT License. See License.txt in the project root for license information.
-*--------------------------------------------------------------------------------------------*/
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.stringifyObject = void 0;
-    function stringifyObject(obj, indent, stringifyLiteral) {
-        if (obj !== null && typeof obj === 'object') {
-            const newIndent = indent + '\t';
-            if (Array.isArray(obj)) {
-                if (obj.length === 0) {
-                    return '[]';
-                }
-                let result = '[\n';
-                for (let i = 0; i < obj.length; i++) {
-                    result += newIndent + stringifyObject(obj[i], newIndent, stringifyLiteral);
-                    if (i < obj.length - 1) {
-                        result += ',';
-                    }
-                    result += '\n';
-                }
-                result += indent + ']';
-                return result;
-            }
-            else {
-                const keys = Object.keys(obj);
-                if (keys.length === 0) {
-                    return '{}';
-                }
-                let result = '{\n';
-                for (let i = 0; i < keys.length; i++) {
-                    const key = keys[i];
-                    result += newIndent + JSON.stringify(key) + ': ' + stringifyObject(obj[key], newIndent, stringifyLiteral);
-                    if (i < keys.length - 1) {
-                        result += ',';
-                    }
-                    result += '\n';
-                }
-                result += indent + '}';
-                return result;
-            }
-        }
-        return stringifyLiteral(obj);
-    }
-    exports.stringifyObject = stringifyObject;
-});
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.stringifyObject = void 0;
+    function stringifyObject(obj, indent, stringifyLiteral) {
+        if (obj !== null && typeof obj === 'object') {
+            const newIndent = indent + '\t';
+            if (Array.isArray(obj)) {
+                if (obj.length === 0) {
+                    return '[]';
+                }
+                let result = '[\n';
+                for (let i = 0; i < obj.length; i++) {
+                    result += newIndent + stringifyObject(obj[i], newIndent, stringifyLiteral);
+                    if (i < obj.length - 1) {
+                        result += ',';
+                    }
+                    result += '\n';
+                }
+                result += indent + ']';
+                return result;
+            }
+            else {
+                const keys = Object.keys(obj);
+                if (keys.length === 0) {
+                    return '{}';
+                }
+                let result = '{\n';
+                for (let i = 0; i < keys.length; i++) {
+                    const key = keys[i];
+                    result += newIndent + JSON.stringify(key) + ': ' + stringifyObject(obj[key], newIndent, stringifyLiteral);
+                    if (i < keys.length - 1) {
+                        result += ',';
+                    }
+                    result += '\n';
+                }
+                result += indent + '}';
+                return result;
+            }
+        }
+        return stringifyLiteral(obj);
+    }
+    exports.stringifyObject = stringifyObject;
+});