vscode-json-languageservice 5.7.2 → 6.0.0-next.2

package/lib/umd/services/schemas/draft-2020-12-flat.js

@@ -1,307 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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 });
-    // This file is generated - do not edit directly!
-    // Derived from https://json-schema.org/draft/2020-12
-    exports.default = {
-        $id: 'https://json-schema.org/draft/2020-12/schema',
-        $schema: 'https://json-schema.org/draft/2020-12/schema',
-        title: '(Flattened static) Core and Validation specifications meta-schema',
-        type: [
-            'object',
-            'boolean',
-        ],
-        properties: {
-            definitions: {
-                $comment: 'While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.',
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#',
-                },
-                default: {},
-            },
-            dependencies: {
-                $comment: '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
-                type: 'object',
-                additionalProperties: {
-                    anyOf: [
-                        {
-                            $ref: '#',
-                        },
-                        {
-                            $ref: '#/$defs/stringArray',
-                        },
-                    ],
-                },
-            },
-            $id: {
-                type: 'string',
-                format: 'uri-reference',
-                $comment: 'Non-empty fragments not allowed.',
-                pattern: '^[^#]*#?$',
-            },
-            $schema: {
-                type: 'string',
-                format: 'uri',
-            },
-            $anchor: {
-                type: 'string',
-                pattern: '^[A-Za-z_][-A-Za-z0-9._]*$',
-            },
-            $ref: {
-                type: 'string',
-                format: 'uri-reference',
-            },
-            $dynamicRef: {
-                type: 'string',
-                format: 'uri-reference',
-            },
-            $vocabulary: {
-                type: 'object',
-                propertyNames: {
-                    type: 'string',
-                    format: 'uri',
-                },
-                additionalProperties: {
-                    type: 'boolean',
-                },
-            },
-            $comment: {
-                type: 'string',
-            },
-            $defs: {
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#',
-                },
-                default: {},
-            },
-            prefixItems: {
-                $ref: '#/$defs/schemaArray',
-            },
-            items: {
-                $ref: '#',
-            },
-            contains: {
-                $ref: '#',
-            },
-            additionalProperties: {
-                $ref: '#',
-            },
-            properties: {
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#',
-                },
-                default: {},
-            },
-            patternProperties: {
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#',
-                },
-                propertyNames: {
-                    format: 'regex',
-                },
-                default: {},
-            },
-            dependentSchemas: {
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#',
-                },
-            },
-            propertyNames: {
-                $ref: '#',
-            },
-            if: {
-                $ref: '#',
-            },
-            then: {
-                $ref: '#',
-            },
-            else: {
-                $ref: '#',
-            },
-            allOf: {
-                $ref: '#/$defs/schemaArray',
-            },
-            anyOf: {
-                $ref: '#/$defs/schemaArray',
-            },
-            oneOf: {
-                $ref: '#/$defs/schemaArray',
-            },
-            not: {
-                $ref: '#',
-            },
-            unevaluatedItems: {
-                $ref: '#',
-            },
-            unevaluatedProperties: {
-                $ref: '#',
-            },
-            multipleOf: {
-                type: 'number',
-                exclusiveMinimum: 0,
-            },
-            maximum: {
-                type: 'number',
-            },
-            exclusiveMaximum: {
-                type: 'number',
-            },
-            minimum: {
-                type: 'number',
-            },
-            exclusiveMinimum: {
-                type: 'number',
-            },
-            maxLength: {
-                $ref: '#/$defs/nonNegativeInteger',
-            },
-            minLength: {
-                $ref: '#/$defs/nonNegativeIntegerDefault0',
-            },
-            pattern: {
-                type: 'string',
-                format: 'regex',
-            },
-            maxItems: {
-                $ref: '#/$defs/nonNegativeInteger',
-            },
-            minItems: {
-                $ref: '#/$defs/nonNegativeIntegerDefault0',
-            },
-            uniqueItems: {
-                type: 'boolean',
-                default: false,
-            },
-            maxContains: {
-                $ref: '#/$defs/nonNegativeInteger',
-            },
-            minContains: {
-                $ref: '#/$defs/nonNegativeInteger',
-                default: 1,
-            },
-            maxProperties: {
-                $ref: '#/$defs/nonNegativeInteger',
-            },
-            minProperties: {
-                $ref: '#/$defs/nonNegativeIntegerDefault0',
-            },
-            required: {
-                $ref: '#/$defs/stringArray',
-            },
-            dependentRequired: {
-                type: 'object',
-                additionalProperties: {
-                    $ref: '#/$defs/stringArray',
-                },
-            },
-            const: true,
-            enum: {
-                type: 'array',
-                items: true,
-            },
-            type: {
-                anyOf: [
-                    {
-                        $ref: '#/$defs/simpleTypes',
-                    },
-                    {
-                        type: 'array',
-                        items: {
-                            $ref: '#/$defs/simpleTypes',
-                        },
-                        minItems: 1,
-                        uniqueItems: true,
-                    },
-                ],
-            },
-            title: {
-                type: 'string',
-            },
-            description: {
-                type: 'string',
-            },
-            default: true,
-            deprecated: {
-                type: 'boolean',
-                default: false,
-            },
-            readOnly: {
-                type: 'boolean',
-                default: false,
-            },
-            writeOnly: {
-                type: 'boolean',
-                default: false,
-            },
-            examples: {
-                type: 'array',
-                items: true,
-            },
-            format: {
-                type: 'string',
-            },
-            contentMediaType: {
-                type: 'string',
-            },
-            contentEncoding: {
-                type: 'string',
-            },
-            contentSchema: {
-                $ref: '#',
-            },
-        },
-        $defs: {
-            schemaArray: {
-                type: 'array',
-                minItems: 1,
-                items: {
-                    $ref: '#',
-                },
-            },
-            nonNegativeInteger: {
-                type: 'integer',
-                minimum: 0,
-            },
-            nonNegativeIntegerDefault0: {
-                $ref: '#/$defs/nonNegativeInteger',
-                default: 0,
-            },
-            simpleTypes: {
-                enum: [
-                    'array',
-                    'boolean',
-                    'integer',
-                    'null',
-                    'number',
-                    'object',
-                    'string',
-                ],
-            },
-            stringArray: {
-                type: 'array',
-                items: {
-                    type: 'string',
-                },
-                uniqueItems: true,
-                default: [],
-            },
-        },
-    };
-});

package/lib/umd/utils/colors.js

@@ -1,83 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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.hexDigit = hexDigit;
-    exports.colorFromHex = colorFromHex;
-    exports.colorFrom256RGB = colorFrom256RGB;
-    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;
-    }
-    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;
-    }
-    function colorFrom256RGB(red, green, blue, alpha = 1.0) {
-        return {
-            red: red / 255.0,
-            green: green / 255.0,
-            blue: blue / 255.0,
-            alpha
-        };
-    }
-});

package/lib/umd/utils/format.js

@@ -1,33 +0,0 @@
-(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", "jsonc-parser", "../jsonLanguageTypes"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.format = format;
-    const jsonc_parser_1 = require("jsonc-parser");
-    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    function format(documentToFormat, formattingOptions, formattingRange) {
-        let range = undefined;
-        if (formattingRange) {
-            const offset = documentToFormat.offsetAt(formattingRange.start);
-            const length = documentToFormat.offsetAt(formattingRange.end) - offset;
-            range = { offset, length };
-        }
-        const options = {
-            tabSize: formattingOptions ? formattingOptions.tabSize : 4,
-            insertSpaces: formattingOptions?.insertSpaces === true,
-            insertFinalNewline: formattingOptions?.insertFinalNewline === true,
-            eol: '\n',
-            keepLines: formattingOptions?.keepLines === true
-        };
-        return (0, jsonc_parser_1.format)(documentToFormat.getText(), range, options).map(edit => {
-            return jsonLanguageTypes_1.TextEdit.replace(jsonLanguageTypes_1.Range.create(documentToFormat.positionAt(edit.offset), documentToFormat.positionAt(edit.offset + edit.length)), edit.content);
-        });
-    }
-});

package/lib/umd/utils/glob.js

@@ -1,137 +0,0 @@
-(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 = createRegex;
-    /*---------------------------------------------------------------------------------------------
-     *  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);
-    }
-    ;
-});

package/lib/umd/utils/json.js

@@ -1,55 +0,0 @@
-/*---------------------------------------------------------------------------------------------
-*  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 = stringifyObject;
-    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);
-    }
-});