vscode-json-languageservice 4.1.8

package/lib/umd/services/jsonValidation.js

@@ -0,0 +1,159 @@
+/*---------------------------------------------------------------------------------------------
+ *  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", "./jsonSchemaService", "../jsonLanguageTypes", "vscode-nls", "../utils/objects"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JSONValidation = void 0;
+    var jsonSchemaService_1 = require("./jsonSchemaService");
+    var jsonLanguageTypes_1 = require("../jsonLanguageTypes");
+    var nls = require("vscode-nls");
+    var objects_1 = require("../utils/objects");
+    var localize = nls.loadMessageBundle();
+    var JSONValidation = /** @class */ (function () {
+        function JSONValidation(jsonSchemaService, promiseConstructor) {
+            this.jsonSchemaService = jsonSchemaService;
+            this.promise = promiseConstructor;
+            this.validationEnabled = true;
+        }
+        JSONValidation.prototype.configure = function (raw) {
+            if (raw) {
+                this.validationEnabled = raw.validate !== false;
+                this.commentSeverity = raw.allowComments ? undefined : jsonLanguageTypes_1.DiagnosticSeverity.Error;
+            }
+        };
+        JSONValidation.prototype.doValidation = function (textDocument, jsonDocument, documentSettings, schema) {
+            var _this = this;
+            if (!this.validationEnabled) {
+                return this.promise.resolve([]);
+            }
+            var diagnostics = [];
+            var added = {};
+            var addProblem = function (problem) {
+                // remove duplicated messages
+                var signature = problem.range.start.line + ' ' + problem.range.start.character + ' ' + problem.message;
+                if (!added[signature]) {
+                    added[signature] = true;
+                    diagnostics.push(problem);
+                }
+            };
+            var getDiagnostics = function (schema) {
+                var trailingCommaSeverity = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.trailingCommas) ? toDiagnosticSeverity(documentSettings.trailingCommas) : jsonLanguageTypes_1.DiagnosticSeverity.Error;
+                var commentSeverity = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.comments) ? toDiagnosticSeverity(documentSettings.comments) : _this.commentSeverity;
+                var schemaValidation = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.schemaValidation) ? toDiagnosticSeverity(documentSettings.schemaValidation) : jsonLanguageTypes_1.DiagnosticSeverity.Warning;
+                var schemaRequest = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.schemaRequest) ? toDiagnosticSeverity(documentSettings.schemaRequest) : jsonLanguageTypes_1.DiagnosticSeverity.Warning;
+                if (schema) {
+                    if (schema.errors.length && jsonDocument.root && schemaRequest) {
+                        var astRoot = jsonDocument.root;
+                        var property = astRoot.type === 'object' ? astRoot.properties[0] : undefined;
+                        if (property && property.keyNode.value === '$schema') {
+                            var node = property.valueNode || property;
+                            var range = jsonLanguageTypes_1.Range.create(textDocument.positionAt(node.offset), textDocument.positionAt(node.offset + node.length));
+                            addProblem(jsonLanguageTypes_1.Diagnostic.create(range, schema.errors[0], schemaRequest, jsonLanguageTypes_1.ErrorCode.SchemaResolveError));
+                        }
+                        else {
+                            var range = jsonLanguageTypes_1.Range.create(textDocument.positionAt(astRoot.offset), textDocument.positionAt(astRoot.offset + 1));
+                            addProblem(jsonLanguageTypes_1.Diagnostic.create(range, schema.errors[0], schemaRequest, jsonLanguageTypes_1.ErrorCode.SchemaResolveError));
+                        }
+                    }
+                    else if (schemaValidation) {
+                        var semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation);
+                        if (semanticErrors) {
+                            semanticErrors.forEach(addProblem);
+                        }
+                    }
+                    if (schemaAllowsComments(schema.schema)) {
+                        commentSeverity = undefined;
+                    }
+                    if (schemaAllowsTrailingCommas(schema.schema)) {
+                        trailingCommaSeverity = undefined;
+                    }
+                }
+                for (var _i = 0, _a = jsonDocument.syntaxErrors; _i < _a.length; _i++) {
+                    var p = _a[_i];
+                    if (p.code === jsonLanguageTypes_1.ErrorCode.TrailingComma) {
+                        if (typeof trailingCommaSeverity !== 'number') {
+                            continue;
+                        }
+                        p.severity = trailingCommaSeverity;
+                    }
+                    addProblem(p);
+                }
+                if (typeof commentSeverity === 'number') {
+                    var message_1 = localize('InvalidCommentToken', 'Comments are not permitted in JSON.');
+                    jsonDocument.comments.forEach(function (c) {
+                        addProblem(jsonLanguageTypes_1.Diagnostic.create(c, message_1, commentSeverity, jsonLanguageTypes_1.ErrorCode.CommentNotPermitted));
+                    });
+                }
+                return diagnostics;
+            };
+            if (schema) {
+                var id = schema.id || ('schemaservice://untitled/' + idCounter++);
+                return this.jsonSchemaService.resolveSchemaContent(new jsonSchemaService_1.UnresolvedSchema(schema), id, {}).then(function (resolvedSchema) {
+                    return getDiagnostics(resolvedSchema);
+                });
+            }
+            return this.jsonSchemaService.getSchemaForResource(textDocument.uri, jsonDocument).then(function (schema) {
+                return getDiagnostics(schema);
+            });
+        };
+        return JSONValidation;
+    }());
+    exports.JSONValidation = JSONValidation;
+    var idCounter = 0;
+    function schemaAllowsComments(schemaRef) {
+        if (schemaRef && typeof schemaRef === 'object') {
+            if (objects_1.isBoolean(schemaRef.allowComments)) {
+                return schemaRef.allowComments;
+            }
+            if (schemaRef.allOf) {
+                for (var _i = 0, _a = schemaRef.allOf; _i < _a.length; _i++) {
+                    var schema = _a[_i];
+                    var allow = schemaAllowsComments(schema);
+                    if (objects_1.isBoolean(allow)) {
+                        return allow;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    function schemaAllowsTrailingCommas(schemaRef) {
+        if (schemaRef && typeof schemaRef === 'object') {
+            if (objects_1.isBoolean(schemaRef.allowTrailingCommas)) {
+                return schemaRef.allowTrailingCommas;
+            }
+            var deprSchemaRef = schemaRef;
+            if (objects_1.isBoolean(deprSchemaRef['allowsTrailingCommas'])) { // deprecated
+                return deprSchemaRef['allowsTrailingCommas'];
+            }
+            if (schemaRef.allOf) {
+                for (var _i = 0, _a = schemaRef.allOf; _i < _a.length; _i++) {
+                    var schema = _a[_i];
+                    var allow = schemaAllowsTrailingCommas(schema);
+                    if (objects_1.isBoolean(allow)) {
+                        return allow;
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
+    function toDiagnosticSeverity(severityLevel) {
+        switch (severityLevel) {
+            case 'error': return jsonLanguageTypes_1.DiagnosticSeverity.Error;
+            case 'warning': return jsonLanguageTypes_1.DiagnosticSeverity.Warning;
+            case 'ignore': return undefined;
+        }
+        return undefined;
+    }
+});

package/lib/umd/utils/colors.js

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------------------------
+ *  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;
+    var Digit0 = 48;
+    var Digit9 = 57;
+    var A = 65;
+    var a = 97;
+    var 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) {
+        if (alpha === void 0) { alpha = 1.0; }
+        return {
+            red: red / 255.0,
+            green: green / 255.0,
+            blue: blue / 255.0,
+            alpha: alpha
+        };
+    }
+    exports.colorFrom256RGB = colorFrom256RGB;
+});

package/lib/umd/utils/glob.js

@@ -0,0 +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');
+        }
+        var str = String(glob);
+        // The regexp we are building, as a string.
+        var reStr = "";
+        // Whether we are matching so called "extended" globs (like bash) and should
+        // support single character matching, matching ranges of characters, group
+        // matching, etc.
+        var 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_
+        var 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.
+        var inGroup = false;
+        // RegExp flags (eg "i" ) to pass in to RegExp constructor.
+        var flags = opts && typeof (opts.flags) === "string" ? opts.flags : "";
+        var c;
+        for (var 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
+                    var prevChar = str[i - 1];
+                    var starCount = 1;
+                    while (str[i + 1] === "*") {
+                        starCount++;
+                        i++;
+                    }
+                    var 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
+                        var 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

@@ -0,0 +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') {
+            var newIndent = indent + '\t';
+            if (Array.isArray(obj)) {
+                if (obj.length === 0) {
+                    return '[]';
+                }
+                var result = '[\n';
+                for (var 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 {
+                var keys = Object.keys(obj);
+                if (keys.length === 0) {
+                    return '{}';
+                }
+                var result = '{\n';
+                for (var i = 0; i < keys.length; i++) {
+                    var 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;
+});

package/lib/umd/utils/objects.js

@@ -0,0 +1,83 @@
+/*---------------------------------------------------------------------------------------------
+*  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.isString = exports.isBoolean = exports.isDefined = exports.isNumber = exports.equals = void 0;
+    function equals(one, other) {
+        if (one === other) {
+            return true;
+        }
+        if (one === null || one === undefined || other === null || other === undefined) {
+            return false;
+        }
+        if (typeof one !== typeof other) {
+            return false;
+        }
+        if (typeof one !== 'object') {
+            return false;
+        }
+        if ((Array.isArray(one)) !== (Array.isArray(other))) {
+            return false;
+        }
+        var i, key;
+        if (Array.isArray(one)) {
+            if (one.length !== other.length) {
+                return false;
+            }
+            for (i = 0; i < one.length; i++) {
+                if (!equals(one[i], other[i])) {
+                    return false;
+                }
+            }
+        }
+        else {
+            var oneKeys = [];
+            for (key in one) {
+                oneKeys.push(key);
+            }
+            oneKeys.sort();
+            var otherKeys = [];
+            for (key in other) {
+                otherKeys.push(key);
+            }
+            otherKeys.sort();
+            if (!equals(oneKeys, otherKeys)) {
+                return false;
+            }
+            for (i = 0; i < oneKeys.length; i++) {
+                if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    exports.equals = equals;
+    function isNumber(val) {
+        return typeof val === 'number';
+    }
+    exports.isNumber = isNumber;
+    function isDefined(val) {
+        return typeof val !== 'undefined';
+    }
+    exports.isDefined = isDefined;
+    function isBoolean(val) {
+        return typeof val === 'boolean';
+    }
+    exports.isBoolean = isBoolean;
+    function isString(val) {
+        return typeof val === 'string';
+    }
+    exports.isString = isString;
+});

package/lib/umd/utils/strings.js

@@ -0,0 +1,70 @@
+/*---------------------------------------------------------------------------------------------
+*  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.extendedRegExp = exports.repeat = exports.convertSimple2RegExpPattern = exports.endsWith = exports.startsWith = void 0;
+    function startsWith(haystack, needle) {
+        if (haystack.length < needle.length) {
+            return false;
+        }
+        for (var i = 0; i < needle.length; i++) {
+            if (haystack[i] !== needle[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    exports.startsWith = startsWith;
+    /**
+     * Determines if haystack ends with needle.
+     */
+    function endsWith(haystack, needle) {
+        var diff = haystack.length - needle.length;
+        if (diff > 0) {
+            return haystack.lastIndexOf(needle) === diff;
+        }
+        else if (diff === 0) {
+            return haystack === needle;
+        }
+        else {
+            return false;
+        }
+    }
+    exports.endsWith = endsWith;
+    function convertSimple2RegExpPattern(pattern) {
+        return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
+    }
+    exports.convertSimple2RegExpPattern = convertSimple2RegExpPattern;
+    function repeat(value, count) {
+        var s = '';
+        while (count > 0) {
+            if ((count & 1) === 1) {
+                s += value;
+            }
+            value += value;
+            count = count >>> 1;
+        }
+        return s;
+    }
+    exports.repeat = repeat;
+    function extendedRegExp(pattern) {
+        if (startsWith(pattern, '(?i)')) {
+            return new RegExp(pattern.substring(4), 'i');
+        }
+        else {
+            return new RegExp(pattern);
+        }
+    }
+    exports.extendedRegExp = extendedRegExp;
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "vscode-json-languageservice",
+  "version": "4.1.8",
+  "description": "Language service for JSON",
+  "main": "./lib/umd/jsonLanguageService.js",
+  "typings": "./lib/umd/jsonLanguageService",
+  "module": "./lib/esm/jsonLanguageService.js",
+  "author": "Microsoft Corporation",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Microsoft/vscode-json-languageservice"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Microsoft/vscode-json-languageservice"
+  },
+  "engines": {
+    "npm": ">=7.0.0"
+  },
+  "devDependencies": {
+    "@types/mocha": "^8.2.0",
+    "@types/node": "^10.12.21",
+    "@typescript-eslint/eslint-plugin": "^4.14.0",
+    "@typescript-eslint/parser": "^4.14.0",
+    "eslint": "^7.18.0",
+    "mocha": "^8.2.1",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.1.3"
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.0.0",
+    "vscode-languageserver-textdocument": "^1.0.1",
+    "vscode-languageserver-types": "^3.16.0",
+    "vscode-nls": "^5.0.0",
+    "vscode-uri": "^3.0.2"
+  },
+  "scripts": {
+    "prepublishOnly": "npm run clean && npm run compile-esm && npm run test && npm run remove-sourcemap-refs",
+    "postpublish": "node ./build/post-publish.js",
+    "compile": "tsc -p ./src",
+    "compile-esm": "tsc -p ./src/tsconfig.esm.json",
+    "clean": "rimraf lib",
+    "remove-sourcemap-refs": "node ./build/remove-sourcemap-refs.js",
+    "watch": "tsc -w -p ./src",
+    "pretest": "npm run compile",
+    "test": "mocha",
+    "posttest": "npm run lint",
+    "coverage": "npx nyc -r lcov npm run test",
+    "lint": "eslint src/**/*.ts",
+    "install-types-next": "npm install vscode-languageserver-types@next -f -S && npm install vscode-languageserver-textdocument@next -f -S",
+    "preversion": "npm test",
+    "postversion": "git push && git push --tags",
+    "sample": "npm run compile && node ./lib/umd/example/sample.js"
+  }
+}