vscode-json-languageservice 4.2.1 → 5.0.0

package/lib/esm/utils/glob.js

@@ -1,124 +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);
-}
-;
+/*---------------------------------------------------------------------------------------------
+ *  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');
+    }
+    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/esm/utils/json.js

@@ -1,42 +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);
-}
+/*---------------------------------------------------------------------------------------------
+*  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') {
+        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);
+}

package/lib/esm/utils/objects.js

@@ -1,65 +1,68 @@
-/*---------------------------------------------------------------------------------------------
-*  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';
-}
+/*---------------------------------------------------------------------------------------------
+*  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';
+}
+export function isObject(val) {
+    return typeof val === 'object' && val !== null && !Array.isArray(val);
+}

package/lib/esm/utils/strings.js

@@ -1,64 +1,64 @@
-/*---------------------------------------------------------------------------------------------
-*  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) {
-    var flags = '';
-    if (startsWith(pattern, '(?i)')) {
-        pattern = pattern.substring(4);
-        flags = 'i';
-    }
-    try {
-        return new RegExp(pattern, flags + 'u');
-    }
-    catch (e) {
-        // could be an exception due to the 'u ' flag
-        try {
-            return new RegExp(pattern, flags);
-        }
-        catch (e) {
-            // invalid pattern
-            return undefined;
-        }
-    }
-}
+/*---------------------------------------------------------------------------------------------
+*  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 (let 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) {
+    const 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) {
+    let flags = '';
+    if (startsWith(pattern, '(?i)')) {
+        pattern = pattern.substring(4);
+        flags = 'i';
+    }
+    try {
+        return new RegExp(pattern, flags + 'u');
+    }
+    catch (e) {
+        // could be an exception due to the 'u ' flag
+        try {
+            return new RegExp(pattern, flags);
+        }
+        catch (e) {
+            // invalid pattern
+            return undefined;
+        }
+    }
+}

package/lib/umd/jsonContributions.d.ts

@@ -1,17 +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;
-}
+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

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