vscode-json-languageservice 5.2.0 → 5.3.0

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+5.3.0 / 2023-02-15
+================
+ * new API `LanguageService.sort` for sorting all properties in a JSON document
+ * new API `SortOptions`
+
 5.2.0 / 2023-02-02
 ================
  * Added `SchemaConfiguration.folderUri` for folder-specific schema associations

package/lib/esm/jsonLanguageService.d.ts

@@ -1,4 +1,4 @@
-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, JSONLanguageStatus } from './jsonLanguageTypes';
+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, JSONLanguageStatus, SortOptions } from './jsonLanguageTypes';
 import { DocumentLink } from 'vscode-languageserver-types';
 export type JSONDocument = {
     root: ASTNode | undefined;
@@ -20,10 +20,11 @@ export interface LanguageService {
     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[]>;
+    format(document: TextDocument, range: Range, options: FormattingOptions): TextEdit[];
+    sort(document: TextDocument, options: SortOptions): TextEdit[];
 }
 export declare function getLanguageService(params: LanguageServiceParams): LanguageService;

package/lib/esm/jsonLanguageService.js

@@ -11,8 +11,8 @@ import { schemaContributions } from './services/configuration';
 import { JSONSchemaService } from './services/jsonSchemaService';
 import { getFoldingRanges } from './services/jsonFolding';
 import { getSelectionRanges } from './services/jsonSelectionRanges';
-import { format as formatJSON } from 'jsonc-parser';
-import { Range, TextEdit } from './jsonLanguageTypes';
+import { sort } from './utils/sort';
+import { format } from './utils/format';
 import { findLinks } from './services/jsonLinks';
 export * from './jsonLanguageTypes';
 export function getLanguageService(params) {
@@ -46,17 +46,7 @@ export function getLanguageService(params) {
         getSelectionRanges,
         findDefinition: () => Promise.resolve([]),
         findLinks,
-        format: (d, r, o) => {
-            let range = undefined;
-            if (r) {
-                const offset = d.offsetAt(r.start);
-                const length = d.offsetAt(r.end) - offset;
-                range = { offset, length };
-            }
-            const options = { tabSize: o ? o.tabSize : 4, insertSpaces: o?.insertSpaces === true, insertFinalNewline: o?.insertFinalNewline === true, eol: '\n', keepLines: o?.keepLines === true };
-            return formatJSON(d.getText(), range, options).map(e => {
-                return TextEdit.replace(Range.create(d.positionAt(e.offset), d.positionAt(e.offset + e.length)), e.content);
-            });
-        }
+        format: (document, range, options) => format(document, options, range),
+        sort: (document, options) => sort(document, options)
     };
 }

package/lib/esm/jsonLanguageTypes.d.ts

@@ -1,8 +1,8 @@
 import { JSONWorkerContribution, JSONPath, Segment, CompletionsCollector } from './jsonContributions';
 import { JSONSchema } from './jsonSchema';
 import { Range, Position, DocumentUri, MarkupContent, MarkupKind, Color, ColorInformation, ColorPresentation, FoldingRange, FoldingRangeKind, SelectionRange, Diagnostic, DiagnosticSeverity, CompletionItem, CompletionItemKind, CompletionList, CompletionItemTag, InsertTextFormat, SymbolInformation, SymbolKind, DocumentSymbol, Location, Hover, MarkedString, FormattingOptions as LSPFormattingOptions, DefinitionLink, CodeActionContext, Command, CodeAction, DocumentHighlight, DocumentLink, WorkspaceEdit, TextEdit, CodeActionKind, TextDocumentEdit, VersionedTextDocumentIdentifier, DocumentHighlightKind } from 'vscode-languageserver-types';
-import { TextDocument } from 'vscode-languageserver-textdocument';
-export { TextDocument, Range, Position, DocumentUri, MarkupContent, MarkupKind, JSONSchema, JSONWorkerContribution, JSONPath, Segment, CompletionsCollector, Color, ColorInformation, ColorPresentation, FoldingRange, FoldingRangeKind, SelectionRange, Diagnostic, DiagnosticSeverity, CompletionItem, CompletionItemKind, CompletionList, CompletionItemTag, InsertTextFormat, DefinitionLink, SymbolInformation, SymbolKind, DocumentSymbol, Location, Hover, MarkedString, CodeActionContext, Command, CodeAction, DocumentHighlight, DocumentLink, WorkspaceEdit, TextEdit, CodeActionKind, TextDocumentEdit, VersionedTextDocumentIdentifier, DocumentHighlightKind };
+import { TextDocument, TextDocumentContentChangeEvent } from 'vscode-languageserver-textdocument';
+export { TextDocument, TextDocumentContentChangeEvent, Range, Position, DocumentUri, MarkupContent, MarkupKind, JSONSchema, JSONWorkerContribution, JSONPath, Segment, CompletionsCollector, Color, ColorInformation, ColorPresentation, FoldingRange, FoldingRangeKind, SelectionRange, Diagnostic, DiagnosticSeverity, CompletionItem, CompletionItemKind, CompletionList, CompletionItemTag, InsertTextFormat, DefinitionLink, SymbolInformation, SymbolKind, DocumentSymbol, Location, Hover, MarkedString, CodeActionContext, Command, CodeAction, DocumentHighlight, DocumentLink, WorkspaceEdit, TextEdit, CodeActionKind, TextDocumentEdit, VersionedTextDocumentIdentifier, DocumentHighlightKind };
 /**
  * Error codes used by diagnostics
  */
@@ -295,3 +295,6 @@ export interface FormattingOptions extends LSPFormattingOptions {
     insertFinalNewline?: boolean;
     keepLines?: boolean;
 }
+export interface SortOptions extends LSPFormattingOptions {
+    insertFinalNewline?: boolean;
+}

package/lib/esm/services/jsonCompletion.js

@@ -687,7 +687,7 @@ export class JSONCompletion {
         return text.replace(/[\\\$\}]/g, '\\$&'); // escape $, \ and } 
     }
     getInsertTextForValue(value, separatorAfter) {
-        var text = JSON.stringify(value, null, '\t');
+        const text = JSON.stringify(value, null, '\t');
         if (text === '{}') {
             return '{$1}' + separatorAfter;
         }
@@ -805,7 +805,7 @@ export class JSONCompletion {
                 nValueProposals += propertySchema.examples.length;
             }
             if (nValueProposals === 0) {
-                var type = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;
+                let type = Array.isArray(propertySchema.type) ? propertySchema.type[0] : propertySchema.type;
                 if (!type) {
                     if (propertySchema.properties) {
                         type = 'object';
@@ -845,8 +845,8 @@ export class JSONCompletion {
         return resultText + value + separatorAfter;
     }
     getCurrentWord(document, offset) {
-        var i = offset - 1;
-        var text = document.getText();
+        let i = offset - 1;
+        const text = document.getText();
         while (i >= 0 && ' \t\n\r\v":{[,]}'.indexOf(text.charAt(i)) === -1) {
             i--;
         }

package/lib/esm/services/jsonDocumentSymbols.js

@@ -5,6 +5,7 @@
 import * as Parser from '../parser/jsonParser';
 import * as Strings from '../utils/strings';
 import { colorFromHex } from '../utils/colors';
+import * as l10n from '@vscode/l10n';
 import { Range, TextEdit, SymbolKind, Location } from "../jsonLanguageTypes";
 export class JSONDocumentSymbols {
     constructor(schemaService) {
@@ -26,7 +27,7 @@ export class JSONDocumentSymbols {
                         for (const property of item.properties) {
                             if (property.keyNode.value === 'key' && property.valueNode) {
                                 const location = Location.create(document.uri, getRange(document, item));
-                                result.push({ name: Parser.getNodeValue(property.valueNode), kind: SymbolKind.Function, location: location });
+                                result.push({ name: getName(property.valueNode), kind: SymbolKind.Function, location: location });
                                 limit--;
                                 if (limit <= 0) {
                                     if (context && context.onResultLimitExceeded) {
@@ -100,7 +101,7 @@ export class JSONDocumentSymbols {
                             if (property.keyNode.value === 'key' && property.valueNode) {
                                 const range = getRange(document, item);
                                 const selectionRange = getRange(document, property.keyNode);
-                                result.push({ name: Parser.getNodeValue(property.valueNode), kind: SymbolKind.Function, range, selectionRange });
+                                result.push({ name: getName(property.valueNode), kind: SymbolKind.Function, range, selectionRange });
                                 limit--;
                                 if (limit <= 0) {
                                     if (context && context.onResultLimitExceeded) {
@@ -265,3 +266,6 @@ export class JSONDocumentSymbols {
 function getRange(document, node) {
     return Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));
 }
+function getName(node) {
+    return Parser.getNodeValue(node) || l10n.t('<empty>');
+}

package/lib/esm/services/jsonHover.js

@@ -28,7 +28,7 @@ export class JSONHover {
             }
         }
         const hoverRange = Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
-        var createHover = (contents) => {
+        const createHover = (contents) => {
             const result = {
                 contents: contents,
                 range: hoverRange

package/lib/esm/utils/format.js

@@ -0,0 +1,20 @@
+import { format as formatJSON } from 'jsonc-parser';
+import { Range, TextEdit } from '../jsonLanguageTypes';
+export function format(documentToFormat, formattingOptions, formattingRange) {
+    let range = undefined;
+    if (formattingRange) {
+        const offset = documentToFormat.offsetAt(formattingRange.start);
+        const length = documentToFormat.offsetAt(formattingRange.end) - offset;
+        range = { offset, length };
+    }
+    const options = {
+        tabSize: formattingOptions ? formattingOptions.tabSize : 4,
+        insertSpaces: formattingOptions?.insertSpaces === true,
+        insertFinalNewline: formattingOptions?.insertFinalNewline === true,
+        eol: '\n',
+        keepLines: formattingOptions?.keepLines === true
+    };
+    return formatJSON(documentToFormat.getText(), range, options).map(edit => {
+        return TextEdit.replace(Range.create(documentToFormat.positionAt(edit.offset), documentToFormat.positionAt(edit.offset + edit.length)), edit.content);
+    });
+}

package/lib/esm/utils/objects.js

@@ -18,7 +18,7 @@ export function equals(one, other) {
     if ((Array.isArray(one)) !== (Array.isArray(other))) {
         return false;
     }
-    var i, key;
+    let i, key;
     if (Array.isArray(one)) {
         if (one.length !== other.length) {
             return false;
@@ -30,12 +30,12 @@ export function equals(one, other) {
         }
     }
     else {
-        var oneKeys = [];
+        const oneKeys = [];
         for (key in one) {
             oneKeys.push(key);
         }
         oneKeys.sort();
-        var otherKeys = [];
+        const otherKeys = [];
         for (key in other) {
             otherKeys.push(key);
         }

package/lib/esm/utils/propertyTree.js

@@ -0,0 +1,71 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+export var Container;
+(function (Container) {
+    Container[Container["Object"] = 0] = "Object";
+    Container[Container["Array"] = 1] = "Array";
+})(Container || (Container = {}));
+export 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;
+    }
+}
+function compareProperties(propertyTree1, propertyTree2) {
+    if (propertyTree1.propertyName < propertyTree2.propertyName) {
+        return -1;
+    }
+    else if (propertyTree1.propertyName > propertyTree2.propertyName) {
+        return 1;
+    }
+    return 0;
+}
+function binarySearchOnPropertyArray(propertyTreeArray, propertyTree, compare_fn) {
+    if (propertyTree.propertyName < propertyTreeArray[0].propertyName) {
+        return 0;
+    }
+    if (propertyTree.propertyName > propertyTreeArray[propertyTreeArray.length - 1].propertyName) {
+        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/esm/utils/sort.js

@@ -0,0 +1,355 @@
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+// import { TextEdit} from 'vscode-languageserver-textdocument';
+import { createScanner } from 'jsonc-parser';
+import { TextDocument, TextEdit, Position, Range } from '../jsonLanguageTypes';
+import { format } from './format';
+import { PropertyTree, Container } from './propertyTree';
+export 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 = TextDocument.applyEdits(documentToSort, format(documentToSort, options, undefined));
+    const formattedJsonDocument = TextDocument.create('test://test.json', 'json', 0, formattedJsonString);
+    const jsonPropertyTree = findJsoncPropertyTree(formattedJsonDocument);
+    const sortedJsonDocument = sortJsoncDocument(formattedJsonDocument, jsonPropertyTree);
+    const edits = format(sortedJsonDocument, options, undefined);
+    const sortedAndFormattedJsonDocument = TextDocument.applyEdits(sortedJsonDocument, edits);
+    return [TextEdit.replace(Range.create(Position.create(0, 0), documentToSort.positionAt(documentToSort.getText().length)), sortedAndFormattedJsonDocument)];
+}
+function findJsoncPropertyTree(formattedDocument) {
+    const formattedString = formattedDocument.getText();
+    const scanner = createScanner(formattedString, false);
+    // The tree that will be returned
+    let rootTree = new 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(Range.create(Position.create(i, 0), 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] === Container.Object))) {
+                    // In that case create the child property which starts at beginningLineNumber, add it to the current tree
+                    const childProperty = new 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] === 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] === Container.Array) {
+                    const childProperty = new PropertyTree(scanner.getTokenValue(), beginningLineNumber);
+                    childProperty.noKeyName = true;
+                    lastProperty = currentProperty;
+                    currentProperty = currentTree.addChildProperty(childProperty);
+                }
+                currentContainerStack.push(Container.Array);
+                currentProperty.type = 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] === Container.Array) {
+                    const childProperty = new PropertyTree(scanner.getTokenValue(), beginningLineNumber);
+                    childProperty.noKeyName = true;
+                    lastProperty = currentProperty;
+                    currentProperty = currentTree.addChildProperty(childProperty);
+                }
+                currentProperty.type = Container.Object;
+                currentContainerStack.push(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 and current property end line number has not yet been defined, define it
+                if (lastNonTriviaNonCommentToken !== 1 /* SyntaxKind.OpenBraceToken */
+                    && 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] === Container.Object
+                        || (currentContainerStack[currentContainerStack.length - 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] === Container.Array
+                        && (secondToLastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */
+                            || secondToLastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */)
+                        || currentContainerStack[currentContainerStack.length - 1] === Container.Object)) {
+                    if (currentContainerStack[currentContainerStack.length - 1] === Container.Array && (secondToLastNonTriviaNonCommentToken === 2 /* SyntaxKind.CloseBraceToken */ || secondToLastNonTriviaNonCommentToken === 4 /* SyntaxKind.CloseBracketToken */) || currentContainerStack[currentContainerStack.length - 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 = 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 = Range.create(Position.create(propertyTree.beginningLineNumber, 0), Position.create(propertyTree.endLineNumber + 1, 0));
+            const jsonContentToReplace = jsonDocument.getText(range);
+            const jsonDocumentToReplace = 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: Range.create(Position.create(lineWhereToAddComma, indexWhereToAddComma), Position.create(lineWhereToAddComma, indexWhereToAddComma)),
+                    text: ','
+                };
+                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: Range.create(Position.create(lineWhereToRemoveComma, commaIndex), Position.create(lineWhereToRemoveComma, commaIndex + 1)),
+                    text: ''
+                };
+                TextDocument.update(jsonDocumentToReplace, [edit], 1);
+            }
+            const length = propertyTree.endLineNumber - propertyTree.beginningLineNumber + 1;
+            const edit = {
+                range: Range.create(Position.create(beginningLineNumber, 0), Position.create(beginningLineNumber + length, 0)),
+                text: jsonDocumentToReplace.getText()
+            };
+            TextDocument.update(sortedJsonDocument, [edit], 1);
+            updateSortingQueue(queueToSort, propertyTree, beginningLineNumber);
+            beginningLineNumber = beginningLineNumber + length;
+        }
+    }
+    return sortedJsonDocument;
+}
+function updateSortingQueue(queue, propertyTree, beginningLineNumber) {
+    if (propertyTree.childrenProperties.length === 0) {
+        return;
+    }
+    if (propertyTree.type === 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;
+        queue.push(new SortingRange(beginningLineNumber, propertyTree.childrenProperties));
+    }
+    else if (propertyTree.type === Container.Array) {
+        for (const subObject of propertyTree.childrenProperties) {
+            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));
+        }
+    }
+}
+class SortingRange {
+    constructor(beginningLineNumber, propertyTreeArray) {
+        this.beginningLineNumber = beginningLineNumber;
+        this.propertyTreeArray = propertyTreeArray;
+    }
+}

package/lib/esm/utils/strings.js

@@ -32,7 +32,7 @@ export function convertSimple2RegExpPattern(pattern) {
     return pattern.replace(/[\-\\\{\}\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, '\\$&').replace(/[\*]/g, '.*');
 }
 export function repeat(value, count) {
-    var s = '';
+    let s = '';
     while (count > 0) {
         if ((count & 1) === 1) {
             s += value;