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

package/lib/umd/utils/objects.js

@@ -1,86 +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.equals = equals;
-    exports.isNumber = isNumber;
-    exports.isDefined = isDefined;
-    exports.isBoolean = isBoolean;
-    exports.isString = isString;
-    exports.isObject = isObject;
-    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;
-        }
-        let 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 {
-            const oneKeys = [];
-            for (key in one) {
-                oneKeys.push(key);
-            }
-            oneKeys.sort();
-            const 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;
-    }
-    function isNumber(val) {
-        return typeof val === 'number';
-    }
-    function isDefined(val) {
-        return typeof val !== 'undefined';
-    }
-    function isBoolean(val) {
-        return typeof val === 'boolean';
-    }
-    function isString(val) {
-        return typeof val === 'string';
-    }
-    function isObject(val) {
-        return typeof val === 'object' && val !== null && !Array.isArray(val);
-    }
-});

package/lib/umd/utils/propertyTree.js

@@ -1,90 +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.PropertyTree = exports.Container = void 0;
-    var Container;
-    (function (Container) {
-        Container[Container["Object"] = 0] = "Object";
-        Container[Container["Array"] = 1] = "Array";
-    })(Container || (exports.Container = Container = {}));
-    class PropertyTree {
-        constructor(propertyName, beginningLineNumber) {
-            this.propertyName = propertyName ?? '';
-            this.beginningLineNumber = beginningLineNumber;
-            this.childrenProperties = [];
-            this.lastProperty = false;
-            this.noKeyName = false;
-        }
-        addChildProperty(childProperty) {
-            childProperty.parent = this;
-            if (this.childrenProperties.length > 0) {
-                let insertionIndex = 0;
-                if (childProperty.noKeyName) {
-                    insertionIndex = this.childrenProperties.length;
-                }
-                else {
-                    insertionIndex = binarySearchOnPropertyArray(this.childrenProperties, childProperty, compareProperties);
-                }
-                if (insertionIndex < 0) {
-                    insertionIndex = (insertionIndex * -1) - 1;
-                }
-                this.childrenProperties.splice(insertionIndex, 0, childProperty);
-            }
-            else {
-                this.childrenProperties.push(childProperty);
-            }
-            return childProperty;
-        }
-    }
-    exports.PropertyTree = PropertyTree;
-    function compareProperties(propertyTree1, propertyTree2) {
-        const propertyName1 = propertyTree1.propertyName.toLowerCase();
-        const propertyName2 = propertyTree2.propertyName.toLowerCase();
-        if (propertyName1 < propertyName2) {
-            return -1;
-        }
-        else if (propertyName1 > propertyName2) {
-            return 1;
-        }
-        return 0;
-    }
-    function binarySearchOnPropertyArray(propertyTreeArray, propertyTree, compare_fn) {
-        const propertyName = propertyTree.propertyName.toLowerCase();
-        const firstPropertyInArrayName = propertyTreeArray[0].propertyName.toLowerCase();
-        const lastPropertyInArrayName = propertyTreeArray[propertyTreeArray.length - 1].propertyName.toLowerCase();
-        if (propertyName < firstPropertyInArrayName) {
-            return 0;
-        }
-        if (propertyName > lastPropertyInArrayName) {
-            return propertyTreeArray.length;
-        }
-        let m = 0;
-        let n = propertyTreeArray.length - 1;
-        while (m <= n) {
-            let k = (n + m) >> 1;
-            let cmp = compare_fn(propertyTree, propertyTreeArray[k]);
-            if (cmp > 0) {
-                m = k + 1;
-            }
-            else if (cmp < 0) {
-                n = k - 1;
-            }
-            else {
-                return k;
-            }
-        }
-        return -m - 1;
-    }
-});

package/lib/umd/utils/sort.js

@@ -1,384 +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", "jsonc-parser", "../jsonLanguageTypes", "./format", "./propertyTree"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.sort = sort;
-    const jsonc_parser_1 = require("jsonc-parser");
-    const jsonLanguageTypes_1 = require("../jsonLanguageTypes");
-    const format_1 = require("./format");
-    const propertyTree_1 = require("./propertyTree");
-    function sort(documentToSort, formattingOptions) {
-        const options = {
-            ...formattingOptions,
-            keepLines: false, // keepLines must be false so that the properties are on separate lines for the sorting
-        };
-        const formattedJsonString = jsonLanguageTypes_1.TextDocument.applyEdits(documentToSort, (0, format_1.format)(documentToSort, options, undefined));
-        const formattedJsonDocument = jsonLanguageTypes_1.TextDocument.create('test://test.json', 'json', 0, formattedJsonString);
-        const jsonPropertyTree = findJsoncPropertyTree(formattedJsonDocument);
-        const sortedJsonDocument = sortJsoncDocument(formattedJsonDocument, jsonPropertyTree);
-        const edits = (0, format_1.format)(sortedJsonDocument, options, undefined);
-        const sortedAndFormattedJsonDocument = jsonLanguageTypes_1.TextDocument.applyEdits(sortedJsonDocument, edits);
-        return [jsonLanguageTypes_1.TextEdit.replace(jsonLanguageTypes_1.Range.create(jsonLanguageTypes_1.Position.create(0, 0), documentToSort.positionAt(documentToSort.getText().length)), sortedAndFormattedJsonDocument)];
-    }
-    function findJsoncPropertyTree(formattedDocument) {
-        const formattedString = formattedDocument.getText();
-        const scanner = (0, jsonc_parser_1.createScanner)(formattedString, false);
-        // The tree that will be returned
-        let rootTree = new propertyTree_1.PropertyTree();
-        // The tree where the current properties can be added as children
-        let currentTree = rootTree;
-        // The tree representing the current property analyzed
-        let currentProperty = rootTree;
-        // The tree representing the previous property analyzed
-        let lastProperty = rootTree;
-        // The current scanned token
-        let token = undefined;
-        // Line number of the last token found
-        let lastTokenLine = 0;
-        // Total number of characters on the lines prior to current line 
-        let numberOfCharactersOnPreviousLines = 0;
-        // The last token scanned that is not trivial, nor a comment
-        let lastNonTriviaNonCommentToken = undefined;
-        // The second to last token scanned that is not trivial, nor a comment
-        let secondToLastNonTriviaNonCommentToken = undefined;
-        // Line number of last token that is not trivial, nor a comment
-        let lineOfLastNonTriviaNonCommentToken = -1;
-        // End index on its line of last token that is not trivial, nor a comment
-        let endIndexOfLastNonTriviaNonCommentToken = -1;
-        // Line number of the start of the range of current/next property
-        let beginningLineNumber = 0;
-        // Line number of the end of the range of current/next property
-        let endLineNumber = 0;
-        // Stack indicating whether we are inside of an object or an array
-        let currentContainerStack = [];
-        // Boolean indicating that the current property end line number needs to be updated. Used only when block comments are encountered.
-        let updateLastPropertyEndLineNumber = false;
-        // Boolean indicating that the beginning line number should be updated. Used only when block comments are encountered. 
-        let updateBeginningLineNumber = false;
-        while ((token = scanner.scan()) !== 17 /* SyntaxKind.EOF */) {
-            // In the case when a block comment has been encountered that starts on the same line as the comma ending a property, update the end line of that
-            // property so that it covers the block comment. For example, if we have: 
-            // 1. "key" : {}, /* some block
-            // 2. comment */
-            // Then, the end line of the property "key" should be line 2 not line 1
-            if (updateLastPropertyEndLineNumber === true
-                && token !== 14 /* SyntaxKind.LineBreakTrivia */
-                && token !== 15 /* SyntaxKind.Trivia */
-                && token !== 12 /* SyntaxKind.LineCommentTrivia */
-                && token !== 13 /* SyntaxKind.BlockCommentTrivia */
-                && currentProperty.endLineNumber === undefined) {
-                let endLineNumber = scanner.getTokenStartLine();
-                // Update the end line number in the case when the last property visited is a container (object or array)
-                if (secondToLastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
-                    || secondToLastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */) {
-                    lastProperty.endLineNumber = endLineNumber - 1;
-                }
-                // Update the end line number in the case when the last property visited is a simple property 
-                else {
-                    currentProperty.endLineNumber = endLineNumber - 1;
-                }
-                beginningLineNumber = endLineNumber;
-                updateLastPropertyEndLineNumber = false;
-            }
-            // When a block comment follows an open brace or an open bracket, that block comment should be associated to that brace or bracket, not the property below it. For example, for:
-            // 1. { /*
-            // 2. ... */
-            // 3. "key" : {}
-            // 4. }
-            // Instead of associating the block comment to the property on line 3, it is associate to the property on line 1
-            if (updateBeginningLineNumber === true
-                && token !== 14 /* SyntaxKind.LineBreakTrivia */
-                && token !== 15 /* SyntaxKind.Trivia */
-                && token !== 12 /* SyntaxKind.LineCommentTrivia */
-                && token !== 13 /* SyntaxKind.BlockCommentTrivia */) {
-                beginningLineNumber = scanner.getTokenStartLine();
-                updateBeginningLineNumber = false;
-            }
-            // Update the number of characters on all the previous lines each time the new token is on a different line to the previous token
-            if (scanner.getTokenStartLine() !== lastTokenLine) {
-                for (let i = lastTokenLine; i < scanner.getTokenStartLine(); i++) {
-                    const lengthOfLine = formattedDocument.getText(jsonLanguageTypes_1.Range.create(jsonLanguageTypes_1.Position.create(i, 0), jsonLanguageTypes_1.Position.create(i + 1, 0))).length;
-                    numberOfCharactersOnPreviousLines = numberOfCharactersOnPreviousLines + lengthOfLine;
-                }
-                lastTokenLine = scanner.getTokenStartLine();
-            }
-            switch (token) {
-                // When a string is found, if it follows an open brace or a comma token and it is within an object, then it corresponds to a key name, not a simple string
-                case 10 /* SyntaxKind.StringLiteral */: {
-                    if ((lastNonTriviaNonCommentToken === undefined
-                        || lastNonTriviaNonCommentToken === 1 /* SyntaxKind.OpenBraceToken */
-                        || (lastNonTriviaNonCommentToken === 5 /* SyntaxKind.CommaToken */
-                            && currentContainerStack[currentContainerStack.length - 1] === propertyTree_1.Container.Object))) {
-                        // In that case create the child property which starts at beginningLineNumber, add it to the current tree
-                        const childProperty = new propertyTree_1.PropertyTree(scanner.getTokenValue(), beginningLineNumber);
-                        lastProperty = currentProperty;
-                        currentProperty = currentTree.addChildProperty(childProperty);
-                    }
-                    break;
-                }
-                // When the token is an open bracket, then we enter into an array
-                case 3 /* SyntaxKind.OpenBracketToken */: {
-                    // If the root tree beginning line number is not defined, then this open bracket is the first open bracket in the document
-                    if (rootTree.beginningLineNumber === undefined) {
-                        rootTree.beginningLineNumber = scanner.getTokenStartLine();
-                    }
-                    // Suppose we are inside of an object, then the current array is associated to a key, and has already been created
-                    // We have the following configuration: {"a": "val", "array": [...], "b": "val"}
-                    // In that case navigate down to the child property
-                    if (currentContainerStack[currentContainerStack.length - 1] === propertyTree_1.Container.Object) {
-                        currentTree = currentProperty;
-                    }
-                    // Suppose we are inside of an array, then since the current array is not associated to a key, it has not been created yet
-                    // We have the following configuration: ["a", [...], "b"]
-                    // In that case create the property and navigate down
-                    else if (currentContainerStack[currentContainerStack.length - 1] === propertyTree_1.Container.Array) {
-                        const childProperty = new propertyTree_1.PropertyTree(scanner.getTokenValue(), beginningLineNumber);
-                        childProperty.noKeyName = true;
-                        lastProperty = currentProperty;
-                        currentProperty = currentTree.addChildProperty(childProperty);
-                        currentTree = currentProperty;
-                    }
-                    currentContainerStack.push(propertyTree_1.Container.Array);
-                    currentProperty.type = propertyTree_1.Container.Array;
-                    beginningLineNumber = scanner.getTokenStartLine();
-                    beginningLineNumber++;
-                    break;
-                }
-                // When the token is an open brace, then we enter into an object
-                case 1 /* SyntaxKind.OpenBraceToken */: {
-                    // If the root tree beginning line number is not defined, then this open brace is the first open brace in the document
-                    if (rootTree.beginningLineNumber === undefined) {
-                        rootTree.beginningLineNumber = scanner.getTokenStartLine();
-                    }
-                    // 1. If we are inside of an objet, the current object is associated to a key and has already been created
-                    // We have the following configuration: {"a": "val", "object": {...}, "b": "val"}
-                    // 2. Otherwise the current object property is inside of an array, not associated to a key name and the property has not yet been created
-                    // We have the following configuration: ["a", {...}, "b"]
-                    else if (currentContainerStack[currentContainerStack.length - 1] === propertyTree_1.Container.Array) {
-                        const childProperty = new propertyTree_1.PropertyTree(scanner.getTokenValue(), beginningLineNumber);
-                        childProperty.noKeyName = true;
-                        lastProperty = currentProperty;
-                        currentProperty = currentTree.addChildProperty(childProperty);
-                    }
-                    currentProperty.type = propertyTree_1.Container.Object;
-                    currentContainerStack.push(propertyTree_1.Container.Object);
-                    currentTree = currentProperty;
-                    beginningLineNumber = scanner.getTokenStartLine();
-                    beginningLineNumber++;
-                    break;
-                }
-                case 4 /* SyntaxKind.CloseBracketToken */: {
-                    endLineNumber = scanner.getTokenStartLine();
-                    currentContainerStack.pop();
-                    // If the last non-trivial non-comment token is a closing brace or bracket, then the currentProperty end line number has not been set yet so set it
-                    // The configuration considered is: [..., {}] or [..., []]
-                    if (currentProperty.endLineNumber === undefined
-                        && (lastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
-                            || lastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */)) {
-                        currentProperty.endLineNumber = endLineNumber - 1;
-                        currentProperty.lastProperty = true;
-                        currentProperty.lineWhereToAddComma = lineOfLastNonTriviaNonCommentToken;
-                        currentProperty.indexWhereToAddComa = endIndexOfLastNonTriviaNonCommentToken;
-                        lastProperty = currentProperty;
-                        currentProperty = currentProperty ? currentProperty.parent : undefined;
-                        currentTree = currentProperty;
-                    }
-                    rootTree.endLineNumber = endLineNumber;
-                    beginningLineNumber = endLineNumber + 1;
-                    break;
-                }
-                case 2 /* SyntaxKind.CloseBraceToken */: {
-                    endLineNumber = scanner.getTokenStartLine();
-                    currentContainerStack.pop();
-                    // If we are not inside of an empty object
-                    if (lastNonTriviaNonCommentToken !== 1 /* SyntaxKind.OpenBraceToken */) {
-                        // If current property end line number has not yet been defined, define it
-                        if (currentProperty.endLineNumber === undefined) {
-                            currentProperty.endLineNumber = endLineNumber - 1;
-                            // The current property is also the last property
-                            currentProperty.lastProperty = true;
-                            // The last property of an object is associated with the line and index of where to add the comma, in case after sorting, it is no longer the last property
-                            currentProperty.lineWhereToAddComma = lineOfLastNonTriviaNonCommentToken;
-                            currentProperty.indexWhereToAddComa = endIndexOfLastNonTriviaNonCommentToken;
-                        }
-                        lastProperty = currentProperty;
-                        currentProperty = currentProperty ? currentProperty.parent : undefined;
-                        currentTree = currentProperty;
-                    }
-                    rootTree.endLineNumber = scanner.getTokenStartLine();
-                    beginningLineNumber = endLineNumber + 1;
-                    break;
-                }
-                case 5 /* SyntaxKind.CommaToken */: {
-                    endLineNumber = scanner.getTokenStartLine();
-                    // If the current container is an object or the current container is an array and the last non-trivia non-comment token is a closing brace or a closing bracket
-                    // Then update the end line number of the current property
-                    if (currentProperty.endLineNumber === undefined
-                        && (currentContainerStack[currentContainerStack.length - 1] === propertyTree_1.Container.Object
-                            || (currentContainerStack[currentContainerStack.length - 1] === propertyTree_1.Container.Array
-                                && (lastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
-                                    || lastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */)))) {
-                        currentProperty.endLineNumber = endLineNumber;
-                        // Store the line and the index of the comma in case it needs to be removed during the sorting
-                        currentProperty.commaIndex = scanner.getTokenOffset() - numberOfCharactersOnPreviousLines;
-                        currentProperty.commaLine = endLineNumber;
-                    }
-                    if (lastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
-                        || lastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */) {
-                        lastProperty = currentProperty;
-                        currentProperty = currentProperty ? currentProperty.parent : undefined;
-                        currentTree = currentProperty;
-                    }
-                    beginningLineNumber = endLineNumber + 1;
-                    break;
-                }
-                case 13 /* SyntaxKind.BlockCommentTrivia */: {
-                    // If the last non trivia non-comment token is a comma and the block comment starts on the same line as the comma, then update the end line number of the current property. For example if:
-                    // 1. {}, /* ...
-                    // 2. ..*/
-                    // The the property on line 1 shoud end on line 2, not line 1
-                    // In the case we are in an array we update the end line number only if the second to last non-trivia non-comment token is a closing brace or bracket
-                    if (lastNonTriviaNonCommentToken === 5 /* SyntaxKind.CommaToken */
-                        && lineOfLastNonTriviaNonCommentToken === scanner.getTokenStartLine()
-                        && (currentContainerStack[currentContainerStack.length - 1] === propertyTree_1.Container.Array
-                            && (secondToLastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
-                                || secondToLastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */)
-                            || currentContainerStack[currentContainerStack.length - 1] === propertyTree_1.Container.Object)) {
-                        if (currentContainerStack[currentContainerStack.length - 1] === propertyTree_1.Container.Array && (secondToLastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */ || secondToLastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */) || currentContainerStack[currentContainerStack.length - 1] === propertyTree_1.Container.Object) {
-                            currentProperty.endLineNumber = undefined;
-                            updateLastPropertyEndLineNumber = true;
-                        }
-                    }
-                    // When the block comment follows an open brace or an open token, we have the following scenario:
-                    // { /**
-                    // ../
-                    // }
-                    // The block comment should be assigned to the open brace not the first property below it
-                    if ((lastNonTriviaNonCommentToken === 1 /* SyntaxKind.OpenBraceToken */
-                        || lastNonTriviaNonCommentToken === 3 /* SyntaxKind.OpenBracketToken */)
-                        && lineOfLastNonTriviaNonCommentToken === scanner.getTokenStartLine()) {
-                        updateBeginningLineNumber = true;
-                    }
-                    break;
-                }
-            }
-            // Update the last and second to last non-trivia non-comment tokens
-            if (token !== 14 /* SyntaxKind.LineBreakTrivia */
-                && token !== 13 /* SyntaxKind.BlockCommentTrivia */
-                && token !== 12 /* SyntaxKind.LineCommentTrivia */
-                && token !== 15 /* SyntaxKind.Trivia */) {
-                secondToLastNonTriviaNonCommentToken = lastNonTriviaNonCommentToken;
-                lastNonTriviaNonCommentToken = token;
-                lineOfLastNonTriviaNonCommentToken = scanner.getTokenStartLine();
-                endIndexOfLastNonTriviaNonCommentToken = scanner.getTokenOffset() + scanner.getTokenLength() - numberOfCharactersOnPreviousLines;
-            }
-        }
-        return rootTree;
-    }
-    function sortJsoncDocument(jsonDocument, propertyTree) {
-        if (propertyTree.childrenProperties.length === 0) {
-            return jsonDocument;
-        }
-        const sortedJsonDocument = jsonLanguageTypes_1.TextDocument.create('test://test.json', 'json', 0, jsonDocument.getText());
-        const queueToSort = [];
-        updateSortingQueue(queueToSort, propertyTree, propertyTree.beginningLineNumber);
-        while (queueToSort.length > 0) {
-            const dataToSort = queueToSort.shift();
-            const propertyTreeArray = dataToSort.propertyTreeArray;
-            let beginningLineNumber = dataToSort.beginningLineNumber;
-            for (let i = 0; i < propertyTreeArray.length; i++) {
-                const propertyTree = propertyTreeArray[i];
-                const range = jsonLanguageTypes_1.Range.create(jsonLanguageTypes_1.Position.create(propertyTree.beginningLineNumber, 0), jsonLanguageTypes_1.Position.create(propertyTree.endLineNumber + 1, 0));
-                const jsonContentToReplace = jsonDocument.getText(range);
-                const jsonDocumentToReplace = jsonLanguageTypes_1.TextDocument.create('test://test.json', 'json', 0, jsonContentToReplace);
-                if (propertyTree.lastProperty === true && i !== propertyTreeArray.length - 1) {
-                    const lineWhereToAddComma = propertyTree.lineWhereToAddComma - propertyTree.beginningLineNumber;
-                    const indexWhereToAddComma = propertyTree.indexWhereToAddComa;
-                    const edit = {
-                        range: jsonLanguageTypes_1.Range.create(jsonLanguageTypes_1.Position.create(lineWhereToAddComma, indexWhereToAddComma), jsonLanguageTypes_1.Position.create(lineWhereToAddComma, indexWhereToAddComma)),
-                        text: ','
-                    };
-                    jsonLanguageTypes_1.TextDocument.update(jsonDocumentToReplace, [edit], 1);
-                }
-                else if (propertyTree.lastProperty === false && i === propertyTreeArray.length - 1) {
-                    const commaIndex = propertyTree.commaIndex;
-                    const commaLine = propertyTree.commaLine;
-                    const lineWhereToRemoveComma = commaLine - propertyTree.beginningLineNumber;
-                    const edit = {
-                        range: jsonLanguageTypes_1.Range.create(jsonLanguageTypes_1.Position.create(lineWhereToRemoveComma, commaIndex), jsonLanguageTypes_1.Position.create(lineWhereToRemoveComma, commaIndex + 1)),
-                        text: ''
-                    };
-                    jsonLanguageTypes_1.TextDocument.update(jsonDocumentToReplace, [edit], 1);
-                }
-                const length = propertyTree.endLineNumber - propertyTree.beginningLineNumber + 1;
-                const edit = {
-                    range: jsonLanguageTypes_1.Range.create(jsonLanguageTypes_1.Position.create(beginningLineNumber, 0), jsonLanguageTypes_1.Position.create(beginningLineNumber + length, 0)),
-                    text: jsonDocumentToReplace.getText()
-                };
-                jsonLanguageTypes_1.TextDocument.update(sortedJsonDocument, [edit], 1);
-                updateSortingQueue(queueToSort, propertyTree, beginningLineNumber);
-                beginningLineNumber = beginningLineNumber + length;
-            }
-        }
-        return sortedJsonDocument;
-    }
-    function sortProperties(properties) {
-        properties.sort((a, b) => a.propertyName.localeCompare(b.propertyName));
-    }
-    function updateSortingQueue(queue, propertyTree, beginningLineNumber) {
-        if (propertyTree.childrenProperties.length === 0) {
-            return;
-        }
-        if (propertyTree.type === propertyTree_1.Container.Object) {
-            let minimumBeginningLineNumber = Infinity;
-            for (const childProperty of propertyTree.childrenProperties) {
-                if (childProperty.beginningLineNumber < minimumBeginningLineNumber) {
-                    minimumBeginningLineNumber = childProperty.beginningLineNumber;
-                }
-            }
-            const diff = minimumBeginningLineNumber - propertyTree.beginningLineNumber;
-            beginningLineNumber = beginningLineNumber + diff;
-            sortProperties(propertyTree.childrenProperties);
-            queue.push(new SortingRange(beginningLineNumber, propertyTree.childrenProperties));
-        }
-        else if (propertyTree.type === propertyTree_1.Container.Array) {
-            updateSortingQueueForArrayProperties(queue, propertyTree, beginningLineNumber);
-        }
-    }
-    function updateSortingQueueForArrayProperties(queue, propertyTree, beginningLineNumber) {
-        for (const subObject of propertyTree.childrenProperties) {
-            // If the child property of the array is an object, then you can sort the properties within this object
-            if (subObject.type === propertyTree_1.Container.Object) {
-                let minimumBeginningLineNumber = Infinity;
-                for (const childProperty of subObject.childrenProperties) {
-                    if (childProperty.beginningLineNumber < minimumBeginningLineNumber) {
-                        minimumBeginningLineNumber = childProperty.beginningLineNumber;
-                    }
-                }
-                const diff = minimumBeginningLineNumber - subObject.beginningLineNumber;
-                queue.push(new SortingRange(beginningLineNumber + subObject.beginningLineNumber - propertyTree.beginningLineNumber + diff, subObject.childrenProperties));
-            }
-            // If the child property of the array is an array, then you need to recurse on the children properties, until you find an object to sort
-            if (subObject.type === propertyTree_1.Container.Array) {
-                updateSortingQueueForArrayProperties(queue, subObject, beginningLineNumber + subObject.beginningLineNumber - propertyTree.beginningLineNumber);
-            }
-        }
-    }
-    class SortingRange {
-        constructor(beginningLineNumber, propertyTreeArray) {
-            this.beginningLineNumber = beginningLineNumber;
-            this.propertyTreeArray = propertyTreeArray;
-        }
-    }
-});

package/lib/umd/utils/strings.js

@@ -1,97 +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.startsWith = startsWith;
-    exports.endsWith = endsWith;
-    exports.convertSimple2RegExpPattern = convertSimple2RegExpPattern;
-    exports.repeat = repeat;
-    exports.extendedRegExp = extendedRegExp;
-    exports.stringLength = stringLength;
-    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.
-     */
-    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;
-        }
-    }
-    function convertSimple2RegExpPattern(pattern) {
-        return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
-    }
-    function repeat(value, count) {
-        let s = '';
-        while (count > 0) {
-            if ((count & 1) === 1) {
-                s += value;
-            }
-            value += value;
-            count = count >>> 1;
-        }
-        return s;
-    }
-    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;
-            }
-        }
-    }
-    // from https://tanishiking.github.io/posts/count-unicode-codepoint/#work-hard-with-for-statements
-    function stringLength(str) {
-        let count = 0;
-        for (let i = 0; i < str.length; i++) {
-            count++;
-            // obtain the i-th 16-bit
-            const code = str.charCodeAt(i);
-            if (0xD800 <= code && code <= 0xDBFF) {
-                // if the i-th 16bit is an upper surrogate
-                // skip the next 16 bits (lower surrogate)
-                i++;
-            }
-        }
-        return count;
-    }
-});