vscode-json-languageservice 4.1.8

package/lib/esm/services/jsonValidation.js

@@ -0,0 +1,146 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { UnresolvedSchema } from './jsonSchemaService';
+import { ErrorCode, Diagnostic, DiagnosticSeverity, Range } from '../jsonLanguageTypes';
+import * as nls from 'vscode-nls';
+import { isBoolean } from '../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 : 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) : 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) : DiagnosticSeverity.Warning;
+            var schemaRequest = (documentSettings === null || documentSettings === void 0 ? void 0 : documentSettings.schemaRequest) ? toDiagnosticSeverity(documentSettings.schemaRequest) : 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 = Range.create(textDocument.positionAt(node.offset), textDocument.positionAt(node.offset + node.length));
+                        addProblem(Diagnostic.create(range, schema.errors[0], schemaRequest, ErrorCode.SchemaResolveError));
+                    }
+                    else {
+                        var range = Range.create(textDocument.positionAt(astRoot.offset), textDocument.positionAt(astRoot.offset + 1));
+                        addProblem(Diagnostic.create(range, schema.errors[0], schemaRequest, 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 === 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(Diagnostic.create(c, message_1, commentSeverity, ErrorCode.CommentNotPermitted));
+                });
+            }
+            return diagnostics;
+        };
+        if (schema) {
+            var id = schema.id || ('schemaservice://untitled/' + idCounter++);
+            return this.jsonSchemaService.resolveSchemaContent(new UnresolvedSchema(schema), id, {}).then(function (resolvedSchema) {
+                return getDiagnostics(resolvedSchema);
+            });
+        }
+        return this.jsonSchemaService.getSchemaForResource(textDocument.uri, jsonDocument).then(function (schema) {
+            return getDiagnostics(schema);
+        });
+    };
+    return JSONValidation;
+}());
+export { JSONValidation };
+var idCounter = 0;
+function schemaAllowsComments(schemaRef) {
+    if (schemaRef && typeof schemaRef === 'object') {
+        if (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 (isBoolean(allow)) {
+                    return allow;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function schemaAllowsTrailingCommas(schemaRef) {
+    if (schemaRef && typeof schemaRef === 'object') {
+        if (isBoolean(schemaRef.allowTrailingCommas)) {
+            return schemaRef.allowTrailingCommas;
+        }
+        var deprSchemaRef = schemaRef;
+        if (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 (isBoolean(allow)) {
+                    return allow;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function toDiagnosticSeverity(severityLevel) {
+    switch (severityLevel) {
+        case 'error': return DiagnosticSeverity.Error;
+        case 'warning': return DiagnosticSeverity.Warning;
+        case 'ignore': return undefined;
+    }
+    return undefined;
+}

package/lib/esm/utils/colors.js

@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var Digit0 = 48;
+var Digit9 = 57;
+var A = 65;
+var a = 97;
+var f = 102;
+export 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;
+}
+export 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;
+}
+export 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
+    };
+}

package/lib/esm/utils/glob.js

@@ -0,0 +1,124 @@
+/*---------------------------------------------------------------------------------------------
+ *  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.
+ *--------------------------------------------------------------------------------------------*/
+export 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);
+}
+;

package/lib/esm/utils/json.js

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+export 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);
+}

package/lib/esm/utils/objects.js

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+export 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;
+}
+export function isNumber(val) {
+    return typeof val === 'number';
+}
+export function isDefined(val) {
+    return typeof val !== 'undefined';
+}
+export function isBoolean(val) {
+    return typeof val === 'boolean';
+}
+export function isString(val) {
+    return typeof val === 'string';
+}

package/lib/esm/utils/strings.js

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+export 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;
+}
+/**
+ * Determines if haystack ends with needle.
+ */
+export 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;
+    }
+}
+export function convertSimple2RegExpPattern(pattern) {
+    return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
+}
+export function repeat(value, count) {
+    var s = '';
+    while (count > 0) {
+        if ((count & 1) === 1) {
+            s += value;
+        }
+        value += value;
+        count = count >>> 1;
+    }
+    return s;
+}
+export function extendedRegExp(pattern) {
+    if (startsWith(pattern, '(?i)')) {
+        return new RegExp(pattern.substring(4), 'i');
+    }
+    else {
+        return new RegExp(pattern);
+    }
+}

package/lib/umd/jsonContributions.d.ts

@@ -0,0 +1,17 @@
+import { Thenable, MarkedString, CompletionItem } from './jsonLanguageService';
+export interface JSONWorkerContribution {
+    getInfoContribution(uri: string, location: JSONPath): Thenable<MarkedString[]>;
+    collectPropertyCompletions(uri: string, location: JSONPath, currentWord: string, addValue: boolean, isLast: boolean, result: CompletionsCollector): Thenable<any>;
+    collectValueCompletions(uri: string, location: JSONPath, propertyKey: string, result: CompletionsCollector): Thenable<any>;
+    collectDefaultCompletions(uri: string, result: CompletionsCollector): Thenable<any>;
+    resolveCompletion?(item: CompletionItem): Thenable<CompletionItem>;
+}
+export declare type Segment = string | number;
+export declare type JSONPath = Segment[];
+export interface CompletionsCollector {
+    add(suggestion: CompletionItem): void;
+    error(message: string): void;
+    log(message: string): void;
+    setAsIncomplete(): void;
+    getNumberOfProposals(): number;
+}

package/lib/umd/jsonContributions.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/lib/umd/jsonLanguageService.d.ts

@@ -0,0 +1,28 @@
+import { Thenable, ASTNode, Color, ColorInformation, ColorPresentation, LanguageServiceParams, LanguageSettings, DocumentLanguageSettings, FoldingRange, JSONSchema, SelectionRange, FoldingRangesContext, DocumentSymbolsContext, ColorInformationContext as DocumentColorsContext, TextDocument, Position, CompletionItem, CompletionList, Hover, Range, SymbolInformation, Diagnostic, TextEdit, FormattingOptions, DocumentSymbol, DefinitionLink, MatchingSchema } from './jsonLanguageTypes';
+import { DocumentLink } from 'vscode-languageserver-types';
+export declare type JSONDocument = {
+    root: ASTNode | undefined;
+    getNodeFromOffset(offset: number, includeRightBound?: boolean): ASTNode | undefined;
+};
+export * from './jsonLanguageTypes';
+export interface LanguageService {
+    configure(settings: LanguageSettings): void;
+    doValidation(document: TextDocument, jsonDocument: JSONDocument, documentSettings?: DocumentLanguageSettings, schema?: JSONSchema): Thenable<Diagnostic[]>;
+    parseJSONDocument(document: TextDocument): JSONDocument;
+    newJSONDocument(rootNode: ASTNode, syntaxDiagnostics?: Diagnostic[]): JSONDocument;
+    resetSchema(uri: string): boolean;
+    getMatchingSchemas(document: TextDocument, jsonDocument: JSONDocument, schema?: JSONSchema): Thenable<MatchingSchema[]>;
+    doResolve(item: CompletionItem): Thenable<CompletionItem>;
+    doComplete(document: TextDocument, position: Position, doc: JSONDocument): Thenable<CompletionList | null>;
+    findDocumentSymbols(document: TextDocument, doc: JSONDocument, context?: DocumentSymbolsContext): SymbolInformation[];
+    findDocumentSymbols2(document: TextDocument, doc: JSONDocument, context?: DocumentSymbolsContext): DocumentSymbol[];
+    findDocumentColors(document: TextDocument, doc: JSONDocument, context?: DocumentColorsContext): Thenable<ColorInformation[]>;
+    getColorPresentations(document: TextDocument, doc: JSONDocument, color: Color, range: Range): ColorPresentation[];
+    doHover(document: TextDocument, position: Position, doc: JSONDocument): Thenable<Hover | null>;
+    format(document: TextDocument, range: Range, options: FormattingOptions): TextEdit[];
+    getFoldingRanges(document: TextDocument, context?: FoldingRangesContext): FoldingRange[];
+    getSelectionRanges(document: TextDocument, positions: Position[], doc: JSONDocument): SelectionRange[];
+    findDefinition(document: TextDocument, position: Position, doc: JSONDocument): Thenable<DefinitionLink[]>;
+    findLinks(document: TextDocument, doc: JSONDocument): Thenable<DocumentLink[]>;
+}
+export declare function getLanguageService(params: LanguageServiceParams): LanguageService;

package/lib/umd/jsonLanguageService.js

@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(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", "./services/jsonCompletion", "./services/jsonHover", "./services/jsonValidation", "./services/jsonDocumentSymbols", "./parser/jsonParser", "./services/configuration", "./services/jsonSchemaService", "./services/jsonFolding", "./services/jsonSelectionRanges", "jsonc-parser", "./jsonLanguageTypes", "./services/jsonLinks", "./jsonLanguageTypes"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getLanguageService = void 0;
+    var jsonCompletion_1 = require("./services/jsonCompletion");
+    var jsonHover_1 = require("./services/jsonHover");
+    var jsonValidation_1 = require("./services/jsonValidation");
+    var jsonDocumentSymbols_1 = require("./services/jsonDocumentSymbols");
+    var jsonParser_1 = require("./parser/jsonParser");
+    var configuration_1 = require("./services/configuration");
+    var jsonSchemaService_1 = require("./services/jsonSchemaService");
+    var jsonFolding_1 = require("./services/jsonFolding");
+    var jsonSelectionRanges_1 = require("./services/jsonSelectionRanges");
+    var jsonc_parser_1 = require("jsonc-parser");
+    var jsonLanguageTypes_1 = require("./jsonLanguageTypes");
+    var jsonLinks_1 = require("./services/jsonLinks");
+    __exportStar(require("./jsonLanguageTypes"), exports);
+    function getLanguageService(params) {
+        var promise = params.promiseConstructor || Promise;
+        var jsonSchemaService = new jsonSchemaService_1.JSONSchemaService(params.schemaRequestService, params.workspaceContext, promise);
+        jsonSchemaService.setSchemaContributions(configuration_1.schemaContributions);
+        var jsonCompletion = new jsonCompletion_1.JSONCompletion(jsonSchemaService, params.contributions, promise, params.clientCapabilities);
+        var jsonHover = new jsonHover_1.JSONHover(jsonSchemaService, params.contributions, promise);
+        var jsonDocumentSymbols = new jsonDocumentSymbols_1.JSONDocumentSymbols(jsonSchemaService);
+        var jsonValidation = new jsonValidation_1.JSONValidation(jsonSchemaService, promise);
+        return {
+            configure: function (settings) {
+                jsonSchemaService.clearExternalSchemas();
+                if (settings.schemas) {
+                    settings.schemas.forEach(function (settings) {
+                        jsonSchemaService.registerExternalSchema(settings.uri, settings.fileMatch, settings.schema);
+                    });
+                }
+                jsonValidation.configure(settings);
+            },
+            resetSchema: function (uri) { return jsonSchemaService.onResourceChange(uri); },
+            doValidation: jsonValidation.doValidation.bind(jsonValidation),
+            parseJSONDocument: function (document) { return jsonParser_1.parse(document, { collectComments: true }); },
+            newJSONDocument: function (root, diagnostics) { return jsonParser_1.newJSONDocument(root, diagnostics); },
+            getMatchingSchemas: jsonSchemaService.getMatchingSchemas.bind(jsonSchemaService),
+            doResolve: jsonCompletion.doResolve.bind(jsonCompletion),
+            doComplete: jsonCompletion.doComplete.bind(jsonCompletion),
+            findDocumentSymbols: jsonDocumentSymbols.findDocumentSymbols.bind(jsonDocumentSymbols),
+            findDocumentSymbols2: jsonDocumentSymbols.findDocumentSymbols2.bind(jsonDocumentSymbols),
+            findDocumentColors: jsonDocumentSymbols.findDocumentColors.bind(jsonDocumentSymbols),
+            getColorPresentations: jsonDocumentSymbols.getColorPresentations.bind(jsonDocumentSymbols),
+            doHover: jsonHover.doHover.bind(jsonHover),
+            getFoldingRanges: jsonFolding_1.getFoldingRanges,
+            getSelectionRanges: jsonSelectionRanges_1.getSelectionRanges,
+            findDefinition: function () { return Promise.resolve([]); },
+            findLinks: jsonLinks_1.findLinks,
+            format: function (d, r, o) {
+                var range = undefined;
+                if (r) {
+                    var offset = d.offsetAt(r.start);
+                    var length = d.offsetAt(r.end) - offset;
+                    range = { offset: offset, length: length };
+                }
+                var options = { tabSize: o ? o.tabSize : 4, insertSpaces: (o === null || o === void 0 ? void 0 : o.insertSpaces) === true, insertFinalNewline: (o === null || o === void 0 ? void 0 : o.insertFinalNewline) === true, eol: '\n' };
+                return jsonc_parser_1.format(d.getText(), range, options).map(function (e) {
+                    return jsonLanguageTypes_1.TextEdit.replace(jsonLanguageTypes_1.Range.create(d.positionAt(e.offset), d.positionAt(e.offset + e.length)), e.content);
+                });
+            }
+        };
+    }
+    exports.getLanguageService = getLanguageService;
+});