@jxsuite/studio 4.0.0 → 5.0.0

package/dist/chunks/{jsonMode-dkr040ga.js → jsonMode-tyx2kj6p.js}

@@ -1,15 +1,14 @@
 import {
-  createWebWorker
-} from "./studio-685s0ytq.js";
-import"./studio-ynxwkrzd.js";
+  Range3,
+  MarkerSeverity3,
+  Uri2,
+  editor2,
+  languages2
+} from "./studio-e1f24eff.js";
 import {
-  MarkerSeverity1 as MarkerSeverity,
-  Range1 as Range,
-  Uri,
-  editor,
-  languages
-} from "./studio-b9b6t1dg.js";
-import"./studio-a0tswy0w.js";
+  createWebWorker
+} from "./studio-nqgawfks.js";
+import"./studio-4wbb9ct0.js";
 
 // ../../node_modules/monaco-editor/esm/vs/languages/features/json/workerManager.js
 var STOP_WHEN_IDLE_FOR = 2 * 60 * 1000;
@@ -75,39 +74,39 @@ class WorkerManager {
 
 // ../../node_modules/monaco-editor/esm/external/vscode-languageserver-types/lib/esm/main.js
 var DocumentUri;
-(function(DocumentUri2) {
+(function(DocumentUri) {
   function is(value) {
     return typeof value === "string";
   }
-  DocumentUri2.is = is;
+  DocumentUri.is = is;
 })(DocumentUri || (DocumentUri = {}));
 var URI;
-(function(URI2) {
+(function(URI) {
   function is(value) {
     return typeof value === "string";
   }
-  URI2.is = is;
+  URI.is = is;
 })(URI || (URI = {}));
 var integer;
-(function(integer2) {
-  integer2.MIN_VALUE = -2147483648;
-  integer2.MAX_VALUE = 2147483647;
+(function(integer) {
+  integer.MIN_VALUE = -2147483648;
+  integer.MAX_VALUE = 2147483647;
   function is(value) {
-    return typeof value === "number" && integer2.MIN_VALUE <= value && value <= integer2.MAX_VALUE;
+    return typeof value === "number" && integer.MIN_VALUE <= value && value <= integer.MAX_VALUE;
   }
-  integer2.is = is;
+  integer.is = is;
 })(integer || (integer = {}));
 var uinteger;
-(function(uinteger2) {
-  uinteger2.MIN_VALUE = 0;
-  uinteger2.MAX_VALUE = 2147483647;
+(function(uinteger) {
+  uinteger.MIN_VALUE = 0;
+  uinteger.MAX_VALUE = 2147483647;
   function is(value) {
-    return typeof value === "number" && uinteger2.MIN_VALUE <= value && value <= uinteger2.MAX_VALUE;
+    return typeof value === "number" && uinteger.MIN_VALUE <= value && value <= uinteger.MAX_VALUE;
   }
-  uinteger2.is = is;
+  uinteger.is = is;
 })(uinteger || (uinteger = {}));
 var Position;
-(function(Position2) {
+(function(Position) {
   function create(line, character) {
     if (line === Number.MAX_VALUE) {
       line = uinteger.MAX_VALUE;
@@ -117,15 +116,15 @@ var Position;
     }
     return { line, character };
   }
-  Position2.create = create;
+  Position.create = create;
   function is(value) {
     let candidate = value;
     return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);
   }
-  Position2.is = is;
+  Position.is = is;
 })(Position || (Position = {}));
-var Range2;
-(function(Range3) {
+var Range;
+(function(Range) {
   function create(one, two, three, four) {
     if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {
       return { start: Position.create(one, two), end: Position.create(three, four) };
@@ -135,39 +134,39 @@ var Range2;
       throw new Error(`Range#create called with invalid arguments[${one}, ${two}, ${three}, ${four}]`);
     }
   }
-  Range3.create = create;
+  Range.create = create;
   function is(value) {
     let candidate = value;
     return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);
   }
-  Range3.is = is;
-})(Range2 || (Range2 = {}));
+  Range.is = is;
+})(Range || (Range = {}));
 var Location;
-(function(Location2) {
+(function(Location) {
   function create(uri, range) {
     return { uri, range };
   }
-  Location2.create = create;
+  Location.create = create;
   function is(value) {
     let candidate = value;
-    return Is.objectLiteral(candidate) && Range2.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
+    return Is.objectLiteral(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));
   }
-  Location2.is = is;
+  Location.is = is;
 })(Location || (Location = {}));
 var LocationLink;
-(function(LocationLink2) {
+(function(LocationLink) {
   function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {
     return { targetUri, targetRange, targetSelectionRange, originSelectionRange };
   }
-  LocationLink2.create = create;
+  LocationLink.create = create;
   function is(value) {
     let candidate = value;
-    return Is.objectLiteral(candidate) && Range2.is(candidate.targetRange) && Is.string(candidate.targetUri) && Range2.is(candidate.targetSelectionRange) && (Range2.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
+    return Is.objectLiteral(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri) && Range.is(candidate.targetSelectionRange) && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));
   }
-  LocationLink2.is = is;
+  LocationLink.is = is;
 })(LocationLink || (LocationLink = {}));
 var Color;
-(function(Color2) {
+(function(Color) {
   function create(red, green, blue, alpha) {
     return {
       red,
@@ -176,30 +175,30 @@ var Color;
       alpha
     };
   }
-  Color2.create = create;
+  Color.create = create;
   function is(value) {
     const candidate = value;
     return Is.objectLiteral(candidate) && Is.numberRange(candidate.red, 0, 1) && Is.numberRange(candidate.green, 0, 1) && Is.numberRange(candidate.blue, 0, 1) && Is.numberRange(candidate.alpha, 0, 1);
   }
-  Color2.is = is;
+  Color.is = is;
 })(Color || (Color = {}));
 var ColorInformation;
-(function(ColorInformation2) {
+(function(ColorInformation) {
   function create(range, color) {
     return {
       range,
       color
     };
   }
-  ColorInformation2.create = create;
+  ColorInformation.create = create;
   function is(value) {
     const candidate = value;
-    return Is.objectLiteral(candidate) && Range2.is(candidate.range) && Color.is(candidate.color);
+    return Is.objectLiteral(candidate) && Range.is(candidate.range) && Color.is(candidate.color);
   }
-  ColorInformation2.is = is;
+  ColorInformation.is = is;
 })(ColorInformation || (ColorInformation = {}));
 var ColorPresentation;
-(function(ColorPresentation2) {
+(function(ColorPresentation) {
   function create(label, textEdit, additionalTextEdits) {
     return {
       label,
@@ -207,21 +206,21 @@ var ColorPresentation;
       additionalTextEdits
     };
   }
-  ColorPresentation2.create = create;
+  ColorPresentation.create = create;
   function is(value) {
     const candidate = value;
     return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));
   }
-  ColorPresentation2.is = is;
+  ColorPresentation.is = is;
 })(ColorPresentation || (ColorPresentation = {}));
 var FoldingRangeKind;
-(function(FoldingRangeKind2) {
-  FoldingRangeKind2.Comment = "comment";
-  FoldingRangeKind2.Imports = "imports";
-  FoldingRangeKind2.Region = "region";
+(function(FoldingRangeKind) {
+  FoldingRangeKind.Comment = "comment";
+  FoldingRangeKind.Imports = "imports";
+  FoldingRangeKind.Region = "region";
 })(FoldingRangeKind || (FoldingRangeKind = {}));
 var FoldingRange;
-(function(FoldingRange2) {
+(function(FoldingRange) {
   function create(startLine, endLine, startCharacter, endCharacter, kind, collapsedText) {
     const result = {
       startLine,
@@ -241,50 +240,50 @@ var FoldingRange;
     }
     return result;
   }
-  FoldingRange2.create = create;
+  FoldingRange.create = create;
   function is(value) {
     const candidate = value;
     return Is.objectLiteral(candidate) && Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine) && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter)) && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter)) && (Is.undefined(candidate.kind) || Is.string(candidate.kind));
   }
-  FoldingRange2.is = is;
+  FoldingRange.is = is;
 })(FoldingRange || (FoldingRange = {}));
 var DiagnosticRelatedInformation;
-(function(DiagnosticRelatedInformation2) {
+(function(DiagnosticRelatedInformation) {
   function create(location, message) {
     return {
       location,
       message
     };
   }
-  DiagnosticRelatedInformation2.create = create;
+  DiagnosticRelatedInformation.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);
   }
-  DiagnosticRelatedInformation2.is = is;
+  DiagnosticRelatedInformation.is = is;
 })(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
 var DiagnosticSeverity;
-(function(DiagnosticSeverity2) {
-  DiagnosticSeverity2.Error = 1;
-  DiagnosticSeverity2.Warning = 2;
-  DiagnosticSeverity2.Information = 3;
-  DiagnosticSeverity2.Hint = 4;
+(function(DiagnosticSeverity) {
+  DiagnosticSeverity.Error = 1;
+  DiagnosticSeverity.Warning = 2;
+  DiagnosticSeverity.Information = 3;
+  DiagnosticSeverity.Hint = 4;
 })(DiagnosticSeverity || (DiagnosticSeverity = {}));
 var DiagnosticTag;
-(function(DiagnosticTag2) {
-  DiagnosticTag2.Unnecessary = 1;
-  DiagnosticTag2.Deprecated = 2;
+(function(DiagnosticTag) {
+  DiagnosticTag.Unnecessary = 1;
+  DiagnosticTag.Deprecated = 2;
 })(DiagnosticTag || (DiagnosticTag = {}));
 var CodeDescription;
-(function(CodeDescription2) {
+(function(CodeDescription) {
   function is(value) {
     const candidate = value;
     return Is.objectLiteral(candidate) && Is.string(candidate.href);
   }
-  CodeDescription2.is = is;
+  CodeDescription.is = is;
 })(CodeDescription || (CodeDescription = {}));
 var Diagnostic;
-(function(Diagnostic2) {
+(function(Diagnostic) {
   function create(range, message, severity, code, source, relatedInformation) {
     let result = { range, message };
     if (Is.defined(severity)) {
@@ -301,16 +300,16 @@ var Diagnostic;
     }
     return result;
   }
-  Diagnostic2.create = create;
+  Diagnostic.create = create;
   function is(value) {
     var _a;
     let candidate = value;
-    return Is.defined(candidate) && Range2.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === undefined ? undefined : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
+    return Is.defined(candidate) && Range.is(candidate.range) && Is.string(candidate.message) && (Is.number(candidate.severity) || Is.undefined(candidate.severity)) && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code)) && (Is.undefined(candidate.codeDescription) || Is.string((_a = candidate.codeDescription) === null || _a === undefined ? undefined : _a.href)) && (Is.string(candidate.source) || Is.undefined(candidate.source)) && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));
   }
-  Diagnostic2.is = is;
+  Diagnostic.is = is;
 })(Diagnostic || (Diagnostic = {}));
 var Command;
-(function(Command2) {
+(function(Command) {
   function create(title, command, ...args) {
     let result = { title, command };
     if (Is.defined(args) && args.length > 0) {
@@ -318,35 +317,35 @@ var Command;
     }
     return result;
   }
-  Command2.create = create;
+  Command.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
   }
-  Command2.is = is;
+  Command.is = is;
 })(Command || (Command = {}));
 var TextEdit;
-(function(TextEdit2) {
+(function(TextEdit) {
   function replace(range, newText) {
     return { range, newText };
   }
-  TextEdit2.replace = replace;
+  TextEdit.replace = replace;
   function insert(position, newText) {
     return { range: { start: position, end: position }, newText };
   }
-  TextEdit2.insert = insert;
+  TextEdit.insert = insert;
   function del(range) {
     return { range, newText: "" };
   }
-  TextEdit2.del = del;
+  TextEdit.del = del;
   function is(value) {
     const candidate = value;
-    return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range2.is(candidate.range);
+    return Is.objectLiteral(candidate) && Is.string(candidate.newText) && Range.is(candidate.range);
   }
-  TextEdit2.is = is;
+  TextEdit.is = is;
 })(TextEdit || (TextEdit = {}));
 var ChangeAnnotation;
-(function(ChangeAnnotation2) {
+(function(ChangeAnnotation) {
   function create(label, needsConfirmation, description) {
     const result = { label };
     if (needsConfirmation !== undefined) {
@@ -357,55 +356,55 @@ var ChangeAnnotation;
     }
     return result;
   }
-  ChangeAnnotation2.create = create;
+  ChangeAnnotation.create = create;
   function is(value) {
     const candidate = value;
     return Is.objectLiteral(candidate) && Is.string(candidate.label) && (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === undefined) && (Is.string(candidate.description) || candidate.description === undefined);
   }
-  ChangeAnnotation2.is = is;
+  ChangeAnnotation.is = is;
 })(ChangeAnnotation || (ChangeAnnotation = {}));
 var ChangeAnnotationIdentifier;
-(function(ChangeAnnotationIdentifier2) {
+(function(ChangeAnnotationIdentifier) {
   function is(value) {
     const candidate = value;
     return Is.string(candidate);
   }
-  ChangeAnnotationIdentifier2.is = is;
+  ChangeAnnotationIdentifier.is = is;
 })(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
 var AnnotatedTextEdit;
-(function(AnnotatedTextEdit2) {
+(function(AnnotatedTextEdit) {
   function replace(range, newText, annotation) {
     return { range, newText, annotationId: annotation };
   }
-  AnnotatedTextEdit2.replace = replace;
+  AnnotatedTextEdit.replace = replace;
   function insert(position, newText, annotation) {
     return { range: { start: position, end: position }, newText, annotationId: annotation };
   }
-  AnnotatedTextEdit2.insert = insert;
+  AnnotatedTextEdit.insert = insert;
   function del(range, annotation) {
     return { range, newText: "", annotationId: annotation };
   }
-  AnnotatedTextEdit2.del = del;
+  AnnotatedTextEdit.del = del;
   function is(value) {
     const candidate = value;
     return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));
   }
-  AnnotatedTextEdit2.is = is;
+  AnnotatedTextEdit.is = is;
 })(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
 var TextDocumentEdit;
-(function(TextDocumentEdit2) {
+(function(TextDocumentEdit) {
   function create(textDocument, edits) {
     return { textDocument, edits };
   }
-  TextDocumentEdit2.create = create;
+  TextDocumentEdit.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument) && Array.isArray(candidate.edits);
   }
-  TextDocumentEdit2.is = is;
+  TextDocumentEdit.is = is;
 })(TextDocumentEdit || (TextDocumentEdit = {}));
 var CreateFile;
-(function(CreateFile2) {
+(function(CreateFile) {
   function create(uri, options, annotation) {
     let result = {
       kind: "create",
@@ -419,15 +418,15 @@ var CreateFile;
     }
     return result;
   }
-  CreateFile2.create = create;
+  CreateFile.create = create;
   function is(value) {
     let candidate = value;
     return candidate && candidate.kind === "create" && Is.string(candidate.uri) && (candidate.options === undefined || (candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
   }
-  CreateFile2.is = is;
+  CreateFile.is = is;
 })(CreateFile || (CreateFile = {}));
 var RenameFile;
-(function(RenameFile2) {
+(function(RenameFile) {
   function create(oldUri, newUri, options, annotation) {
     let result = {
       kind: "rename",
@@ -442,15 +441,15 @@ var RenameFile;
     }
     return result;
   }
-  RenameFile2.create = create;
+  RenameFile.create = create;
   function is(value) {
     let candidate = value;
     return candidate && candidate.kind === "rename" && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === undefined || (candidate.options.overwrite === undefined || Is.boolean(candidate.options.overwrite)) && (candidate.options.ignoreIfExists === undefined || Is.boolean(candidate.options.ignoreIfExists))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
   }
-  RenameFile2.is = is;
+  RenameFile.is = is;
 })(RenameFile || (RenameFile = {}));
 var DeleteFile;
-(function(DeleteFile2) {
+(function(DeleteFile) {
   function create(uri, options, annotation) {
     let result = {
       kind: "delete",
@@ -464,15 +463,15 @@ var DeleteFile;
     }
     return result;
   }
-  DeleteFile2.create = create;
+  DeleteFile.create = create;
   function is(value) {
     let candidate = value;
     return candidate && candidate.kind === "delete" && Is.string(candidate.uri) && (candidate.options === undefined || (candidate.options.recursive === undefined || Is.boolean(candidate.options.recursive)) && (candidate.options.ignoreIfNotExists === undefined || Is.boolean(candidate.options.ignoreIfNotExists))) && (candidate.annotationId === undefined || ChangeAnnotationIdentifier.is(candidate.annotationId));
   }
-  DeleteFile2.is = is;
+  DeleteFile.is = is;
 })(DeleteFile || (DeleteFile = {}));
 var WorkspaceEdit;
-(function(WorkspaceEdit2) {
+(function(WorkspaceEdit) {
   function is(value) {
     let candidate = value;
     return candidate && (candidate.changes !== undefined || candidate.documentChanges !== undefined) && (candidate.documentChanges === undefined || candidate.documentChanges.every((change) => {
@@ -483,179 +482,179 @@ var WorkspaceEdit;
       }
     }));
   }
-  WorkspaceEdit2.is = is;
+  WorkspaceEdit.is = is;
 })(WorkspaceEdit || (WorkspaceEdit = {}));
 var TextDocumentIdentifier;
-(function(TextDocumentIdentifier2) {
+(function(TextDocumentIdentifier) {
   function create(uri) {
     return { uri };
   }
-  TextDocumentIdentifier2.create = create;
+  TextDocumentIdentifier.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && Is.string(candidate.uri);
   }
-  TextDocumentIdentifier2.is = is;
+  TextDocumentIdentifier.is = is;
 })(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
 var VersionedTextDocumentIdentifier;
-(function(VersionedTextDocumentIdentifier2) {
+(function(VersionedTextDocumentIdentifier) {
   function create(uri, version) {
     return { uri, version };
   }
-  VersionedTextDocumentIdentifier2.create = create;
+  VersionedTextDocumentIdentifier.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);
   }
-  VersionedTextDocumentIdentifier2.is = is;
+  VersionedTextDocumentIdentifier.is = is;
 })(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));
 var OptionalVersionedTextDocumentIdentifier;
-(function(OptionalVersionedTextDocumentIdentifier2) {
+(function(OptionalVersionedTextDocumentIdentifier) {
   function create(uri, version) {
     return { uri, version };
   }
-  OptionalVersionedTextDocumentIdentifier2.create = create;
+  OptionalVersionedTextDocumentIdentifier.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));
   }
-  OptionalVersionedTextDocumentIdentifier2.is = is;
+  OptionalVersionedTextDocumentIdentifier.is = is;
 })(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));
 var TextDocumentItem;
-(function(TextDocumentItem2) {
+(function(TextDocumentItem) {
   function create(uri, languageId, version, text) {
     return { uri, languageId, version, text };
   }
-  TextDocumentItem2.create = create;
+  TextDocumentItem.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);
   }
-  TextDocumentItem2.is = is;
+  TextDocumentItem.is = is;
 })(TextDocumentItem || (TextDocumentItem = {}));
 var MarkupKind;
-(function(MarkupKind2) {
-  MarkupKind2.PlainText = "plaintext";
-  MarkupKind2.Markdown = "markdown";
+(function(MarkupKind) {
+  MarkupKind.PlainText = "plaintext";
+  MarkupKind.Markdown = "markdown";
   function is(value) {
     const candidate = value;
-    return candidate === MarkupKind2.PlainText || candidate === MarkupKind2.Markdown;
+    return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown;
   }
-  MarkupKind2.is = is;
+  MarkupKind.is = is;
 })(MarkupKind || (MarkupKind = {}));
 var MarkupContent;
-(function(MarkupContent2) {
+(function(MarkupContent) {
   function is(value) {
     const candidate = value;
     return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);
   }
-  MarkupContent2.is = is;
+  MarkupContent.is = is;
 })(MarkupContent || (MarkupContent = {}));
 var CompletionItemKind;
-(function(CompletionItemKind2) {
-  CompletionItemKind2.Text = 1;
-  CompletionItemKind2.Method = 2;
-  CompletionItemKind2.Function = 3;
-  CompletionItemKind2.Constructor = 4;
-  CompletionItemKind2.Field = 5;
-  CompletionItemKind2.Variable = 6;
-  CompletionItemKind2.Class = 7;
-  CompletionItemKind2.Interface = 8;
-  CompletionItemKind2.Module = 9;
-  CompletionItemKind2.Property = 10;
-  CompletionItemKind2.Unit = 11;
-  CompletionItemKind2.Value = 12;
-  CompletionItemKind2.Enum = 13;
-  CompletionItemKind2.Keyword = 14;
-  CompletionItemKind2.Snippet = 15;
-  CompletionItemKind2.Color = 16;
-  CompletionItemKind2.File = 17;
-  CompletionItemKind2.Reference = 18;
-  CompletionItemKind2.Folder = 19;
-  CompletionItemKind2.EnumMember = 20;
-  CompletionItemKind2.Constant = 21;
-  CompletionItemKind2.Struct = 22;
-  CompletionItemKind2.Event = 23;
-  CompletionItemKind2.Operator = 24;
-  CompletionItemKind2.TypeParameter = 25;
+(function(CompletionItemKind) {
+  CompletionItemKind.Text = 1;
+  CompletionItemKind.Method = 2;
+  CompletionItemKind.Function = 3;
+  CompletionItemKind.Constructor = 4;
+  CompletionItemKind.Field = 5;
+  CompletionItemKind.Variable = 6;
+  CompletionItemKind.Class = 7;
+  CompletionItemKind.Interface = 8;
+  CompletionItemKind.Module = 9;
+  CompletionItemKind.Property = 10;
+  CompletionItemKind.Unit = 11;
+  CompletionItemKind.Value = 12;
+  CompletionItemKind.Enum = 13;
+  CompletionItemKind.Keyword = 14;
+  CompletionItemKind.Snippet = 15;
+  CompletionItemKind.Color = 16;
+  CompletionItemKind.File = 17;
+  CompletionItemKind.Reference = 18;
+  CompletionItemKind.Folder = 19;
+  CompletionItemKind.EnumMember = 20;
+  CompletionItemKind.Constant = 21;
+  CompletionItemKind.Struct = 22;
+  CompletionItemKind.Event = 23;
+  CompletionItemKind.Operator = 24;
+  CompletionItemKind.TypeParameter = 25;
 })(CompletionItemKind || (CompletionItemKind = {}));
 var InsertTextFormat;
-(function(InsertTextFormat2) {
-  InsertTextFormat2.PlainText = 1;
-  InsertTextFormat2.Snippet = 2;
+(function(InsertTextFormat) {
+  InsertTextFormat.PlainText = 1;
+  InsertTextFormat.Snippet = 2;
 })(InsertTextFormat || (InsertTextFormat = {}));
 var CompletionItemTag;
-(function(CompletionItemTag2) {
-  CompletionItemTag2.Deprecated = 1;
+(function(CompletionItemTag) {
+  CompletionItemTag.Deprecated = 1;
 })(CompletionItemTag || (CompletionItemTag = {}));
 var InsertReplaceEdit;
-(function(InsertReplaceEdit2) {
+(function(InsertReplaceEdit) {
   function create(newText, insert, replace) {
     return { newText, insert, replace };
   }
-  InsertReplaceEdit2.create = create;
+  InsertReplaceEdit.create = create;
   function is(value) {
     const candidate = value;
-    return candidate && Is.string(candidate.newText) && Range2.is(candidate.insert) && Range2.is(candidate.replace);
+    return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);
   }
-  InsertReplaceEdit2.is = is;
+  InsertReplaceEdit.is = is;
 })(InsertReplaceEdit || (InsertReplaceEdit = {}));
 var InsertTextMode;
-(function(InsertTextMode2) {
-  InsertTextMode2.asIs = 1;
-  InsertTextMode2.adjustIndentation = 2;
+(function(InsertTextMode) {
+  InsertTextMode.asIs = 1;
+  InsertTextMode.adjustIndentation = 2;
 })(InsertTextMode || (InsertTextMode = {}));
 var CompletionItemLabelDetails;
-(function(CompletionItemLabelDetails2) {
+(function(CompletionItemLabelDetails) {
   function is(value) {
     const candidate = value;
     return candidate && (Is.string(candidate.detail) || candidate.detail === undefined) && (Is.string(candidate.description) || candidate.description === undefined);
   }
-  CompletionItemLabelDetails2.is = is;
+  CompletionItemLabelDetails.is = is;
 })(CompletionItemLabelDetails || (CompletionItemLabelDetails = {}));
 var CompletionItem;
-(function(CompletionItem2) {
+(function(CompletionItem) {
   function create(label) {
     return { label };
   }
-  CompletionItem2.create = create;
+  CompletionItem.create = create;
 })(CompletionItem || (CompletionItem = {}));
 var CompletionList;
-(function(CompletionList2) {
+(function(CompletionList) {
   function create(items, isIncomplete) {
     return { items: items ? items : [], isIncomplete: !!isIncomplete };
   }
-  CompletionList2.create = create;
+  CompletionList.create = create;
 })(CompletionList || (CompletionList = {}));
 var MarkedString;
-(function(MarkedString2) {
+(function(MarkedString) {
   function fromPlainText(plainText) {
     return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
   }
-  MarkedString2.fromPlainText = fromPlainText;
+  MarkedString.fromPlainText = fromPlainText;
   function is(value) {
     const candidate = value;
     return Is.string(candidate) || Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value);
   }
-  MarkedString2.is = is;
+  MarkedString.is = is;
 })(MarkedString || (MarkedString = {}));
 var Hover;
-(function(Hover2) {
+(function(Hover) {
   function is(value) {
     let candidate = value;
-    return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === undefined || Range2.is(value.range));
+    return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) || MarkedString.is(candidate.contents) || Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === undefined || Range.is(value.range));
   }
-  Hover2.is = is;
+  Hover.is = is;
 })(Hover || (Hover = {}));
 var ParameterInformation;
-(function(ParameterInformation2) {
+(function(ParameterInformation) {
   function create(label, documentation) {
     return documentation ? { label, documentation } : { label };
   }
-  ParameterInformation2.create = create;
+  ParameterInformation.create = create;
 })(ParameterInformation || (ParameterInformation = {}));
 var SignatureInformation;
-(function(SignatureInformation2) {
+(function(SignatureInformation) {
   function create(label, documentation, ...parameters) {
     let result = { label };
     if (Is.defined(documentation)) {
@@ -668,16 +667,16 @@ var SignatureInformation;
     }
     return result;
   }
-  SignatureInformation2.create = create;
+  SignatureInformation.create = create;
 })(SignatureInformation || (SignatureInformation = {}));
 var DocumentHighlightKind;
-(function(DocumentHighlightKind2) {
-  DocumentHighlightKind2.Text = 1;
-  DocumentHighlightKind2.Read = 2;
-  DocumentHighlightKind2.Write = 3;
+(function(DocumentHighlightKind) {
+  DocumentHighlightKind.Text = 1;
+  DocumentHighlightKind.Read = 2;
+  DocumentHighlightKind.Write = 3;
 })(DocumentHighlightKind || (DocumentHighlightKind = {}));
 var DocumentHighlight;
-(function(DocumentHighlight2) {
+(function(DocumentHighlight) {
   function create(range, kind) {
     let result = { range };
     if (Is.number(kind)) {
@@ -685,43 +684,43 @@ var DocumentHighlight;
     }
     return result;
   }
-  DocumentHighlight2.create = create;
+  DocumentHighlight.create = create;
 })(DocumentHighlight || (DocumentHighlight = {}));
 var SymbolKind;
-(function(SymbolKind2) {
-  SymbolKind2.File = 1;
-  SymbolKind2.Module = 2;
-  SymbolKind2.Namespace = 3;
-  SymbolKind2.Package = 4;
-  SymbolKind2.Class = 5;
-  SymbolKind2.Method = 6;
-  SymbolKind2.Property = 7;
-  SymbolKind2.Field = 8;
-  SymbolKind2.Constructor = 9;
-  SymbolKind2.Enum = 10;
-  SymbolKind2.Interface = 11;
-  SymbolKind2.Function = 12;
-  SymbolKind2.Variable = 13;
-  SymbolKind2.Constant = 14;
-  SymbolKind2.String = 15;
-  SymbolKind2.Number = 16;
-  SymbolKind2.Boolean = 17;
-  SymbolKind2.Array = 18;
-  SymbolKind2.Object = 19;
-  SymbolKind2.Key = 20;
-  SymbolKind2.Null = 21;
-  SymbolKind2.EnumMember = 22;
-  SymbolKind2.Struct = 23;
-  SymbolKind2.Event = 24;
-  SymbolKind2.Operator = 25;
-  SymbolKind2.TypeParameter = 26;
+(function(SymbolKind) {
+  SymbolKind.File = 1;
+  SymbolKind.Module = 2;
+  SymbolKind.Namespace = 3;
+  SymbolKind.Package = 4;
+  SymbolKind.Class = 5;
+  SymbolKind.Method = 6;
+  SymbolKind.Property = 7;
+  SymbolKind.Field = 8;
+  SymbolKind.Constructor = 9;
+  SymbolKind.Enum = 10;
+  SymbolKind.Interface = 11;
+  SymbolKind.Function = 12;
+  SymbolKind.Variable = 13;
+  SymbolKind.Constant = 14;
+  SymbolKind.String = 15;
+  SymbolKind.Number = 16;
+  SymbolKind.Boolean = 17;
+  SymbolKind.Array = 18;
+  SymbolKind.Object = 19;
+  SymbolKind.Key = 20;
+  SymbolKind.Null = 21;
+  SymbolKind.EnumMember = 22;
+  SymbolKind.Struct = 23;
+  SymbolKind.Event = 24;
+  SymbolKind.Operator = 25;
+  SymbolKind.TypeParameter = 26;
 })(SymbolKind || (SymbolKind = {}));
 var SymbolTag;
-(function(SymbolTag2) {
-  SymbolTag2.Deprecated = 1;
+(function(SymbolTag) {
+  SymbolTag.Deprecated = 1;
 })(SymbolTag || (SymbolTag = {}));
 var SymbolInformation;
-(function(SymbolInformation2) {
+(function(SymbolInformation) {
   function create(name, kind, range, uri, containerName) {
     let result = {
       name,
@@ -733,17 +732,17 @@ var SymbolInformation;
     }
     return result;
   }
-  SymbolInformation2.create = create;
+  SymbolInformation.create = create;
 })(SymbolInformation || (SymbolInformation = {}));
 var WorkspaceSymbol;
-(function(WorkspaceSymbol2) {
+(function(WorkspaceSymbol) {
   function create(name, kind, uri, range) {
     return range !== undefined ? { name, kind, location: { uri, range } } : { name, kind, location: { uri } };
   }
-  WorkspaceSymbol2.create = create;
+  WorkspaceSymbol.create = create;
 })(WorkspaceSymbol || (WorkspaceSymbol = {}));
 var DocumentSymbol;
-(function(DocumentSymbol2) {
+(function(DocumentSymbol) {
   function create(name, detail, kind, range, selectionRange, children) {
     let result = {
       name,
@@ -757,32 +756,32 @@ var DocumentSymbol;
     }
     return result;
   }
-  DocumentSymbol2.create = create;
+  DocumentSymbol.create = create;
   function is(value) {
     let candidate = value;
-    return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range2.is(candidate.range) && Range2.is(candidate.selectionRange) && (candidate.detail === undefined || Is.string(candidate.detail)) && (candidate.deprecated === undefined || Is.boolean(candidate.deprecated)) && (candidate.children === undefined || Array.isArray(candidate.children)) && (candidate.tags === undefined || Array.isArray(candidate.tags));
+    return candidate && Is.string(candidate.name) && Is.number(candidate.kind) && Range.is(candidate.range) && Range.is(candidate.selectionRange) && (candidate.detail === undefined || Is.string(candidate.detail)) && (candidate.deprecated === undefined || Is.boolean(candidate.deprecated)) && (candidate.children === undefined || Array.isArray(candidate.children)) && (candidate.tags === undefined || Array.isArray(candidate.tags));
   }
-  DocumentSymbol2.is = is;
+  DocumentSymbol.is = is;
 })(DocumentSymbol || (DocumentSymbol = {}));
 var CodeActionKind;
-(function(CodeActionKind2) {
-  CodeActionKind2.Empty = "";
-  CodeActionKind2.QuickFix = "quickfix";
-  CodeActionKind2.Refactor = "refactor";
-  CodeActionKind2.RefactorExtract = "refactor.extract";
-  CodeActionKind2.RefactorInline = "refactor.inline";
-  CodeActionKind2.RefactorRewrite = "refactor.rewrite";
-  CodeActionKind2.Source = "source";
-  CodeActionKind2.SourceOrganizeImports = "source.organizeImports";
-  CodeActionKind2.SourceFixAll = "source.fixAll";
+(function(CodeActionKind) {
+  CodeActionKind.Empty = "";
+  CodeActionKind.QuickFix = "quickfix";
+  CodeActionKind.Refactor = "refactor";
+  CodeActionKind.RefactorExtract = "refactor.extract";
+  CodeActionKind.RefactorInline = "refactor.inline";
+  CodeActionKind.RefactorRewrite = "refactor.rewrite";
+  CodeActionKind.Source = "source";
+  CodeActionKind.SourceOrganizeImports = "source.organizeImports";
+  CodeActionKind.SourceFixAll = "source.fixAll";
 })(CodeActionKind || (CodeActionKind = {}));
 var CodeActionTriggerKind;
-(function(CodeActionTriggerKind2) {
-  CodeActionTriggerKind2.Invoked = 1;
-  CodeActionTriggerKind2.Automatic = 2;
+(function(CodeActionTriggerKind) {
+  CodeActionTriggerKind.Invoked = 1;
+  CodeActionTriggerKind.Automatic = 2;
 })(CodeActionTriggerKind || (CodeActionTriggerKind = {}));
 var CodeActionContext;
-(function(CodeActionContext2) {
+(function(CodeActionContext) {
   function create(diagnostics, only, triggerKind) {
     let result = { diagnostics };
     if (only !== undefined && only !== null) {
@@ -793,15 +792,15 @@ var CodeActionContext;
     }
     return result;
   }
-  CodeActionContext2.create = create;
+  CodeActionContext.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === undefined || Is.typedArray(candidate.only, Is.string)) && (candidate.triggerKind === undefined || candidate.triggerKind === CodeActionTriggerKind.Invoked || candidate.triggerKind === CodeActionTriggerKind.Automatic);
   }
-  CodeActionContext2.is = is;
+  CodeActionContext.is = is;
 })(CodeActionContext || (CodeActionContext = {}));
 var CodeAction;
-(function(CodeAction2) {
+(function(CodeAction) {
   function create(title, kindOrCommandOrEdit, kind) {
     let result = { title };
     let checkKind = true;
@@ -818,15 +817,15 @@ var CodeAction;
     }
     return result;
   }
-  CodeAction2.create = create;
+  CodeAction.create = create;
   function is(value) {
     let candidate = value;
     return candidate && Is.string(candidate.title) && (candidate.diagnostics === undefined || Is.typedArray(candidate.diagnostics, Diagnostic.is)) && (candidate.kind === undefined || Is.string(candidate.kind)) && (candidate.edit !== undefined || candidate.command !== undefined) && (candidate.command === undefined || Command.is(candidate.command)) && (candidate.isPreferred === undefined || Is.boolean(candidate.isPreferred)) && (candidate.edit === undefined || WorkspaceEdit.is(candidate.edit));
   }
-  CodeAction2.is = is;
+  CodeAction.is = is;
 })(CodeAction || (CodeAction = {}));
 var CodeLens;
-(function(CodeLens2) {
+(function(CodeLens) {
   function create(range, data) {
     let result = { range };
     if (Is.defined(data)) {
@@ -834,167 +833,167 @@ var CodeLens;
     }
     return result;
   }
-  CodeLens2.create = create;
+  CodeLens.create = create;
   function is(value) {
     let candidate = value;
-    return Is.defined(candidate) && Range2.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
+    return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));
   }
-  CodeLens2.is = is;
+  CodeLens.is = is;
 })(CodeLens || (CodeLens = {}));
 var FormattingOptions;
-(function(FormattingOptions2) {
+(function(FormattingOptions) {
   function create(tabSize, insertSpaces) {
     return { tabSize, insertSpaces };
   }
-  FormattingOptions2.create = create;
+  FormattingOptions.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);
   }
-  FormattingOptions2.is = is;
+  FormattingOptions.is = is;
 })(FormattingOptions || (FormattingOptions = {}));
 var DocumentLink;
-(function(DocumentLink2) {
+(function(DocumentLink) {
   function create(range, target, data) {
     return { range, target, data };
   }
-  DocumentLink2.create = create;
+  DocumentLink.create = create;
   function is(value) {
     let candidate = value;
-    return Is.defined(candidate) && Range2.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
+    return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));
   }
-  DocumentLink2.is = is;
+  DocumentLink.is = is;
 })(DocumentLink || (DocumentLink = {}));
 var SelectionRange;
-(function(SelectionRange2) {
+(function(SelectionRange) {
   function create(range, parent) {
     return { range, parent };
   }
-  SelectionRange2.create = create;
+  SelectionRange.create = create;
   function is(value) {
     let candidate = value;
-    return Is.objectLiteral(candidate) && Range2.is(candidate.range) && (candidate.parent === undefined || SelectionRange2.is(candidate.parent));
+    return Is.objectLiteral(candidate) && Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent));
   }
-  SelectionRange2.is = is;
+  SelectionRange.is = is;
 })(SelectionRange || (SelectionRange = {}));
 var SemanticTokenTypes;
-(function(SemanticTokenTypes2) {
-  SemanticTokenTypes2["namespace"] = "namespace";
-  SemanticTokenTypes2["type"] = "type";
-  SemanticTokenTypes2["class"] = "class";
-  SemanticTokenTypes2["enum"] = "enum";
-  SemanticTokenTypes2["interface"] = "interface";
-  SemanticTokenTypes2["struct"] = "struct";
-  SemanticTokenTypes2["typeParameter"] = "typeParameter";
-  SemanticTokenTypes2["parameter"] = "parameter";
-  SemanticTokenTypes2["variable"] = "variable";
-  SemanticTokenTypes2["property"] = "property";
-  SemanticTokenTypes2["enumMember"] = "enumMember";
-  SemanticTokenTypes2["event"] = "event";
-  SemanticTokenTypes2["function"] = "function";
-  SemanticTokenTypes2["method"] = "method";
-  SemanticTokenTypes2["macro"] = "macro";
-  SemanticTokenTypes2["keyword"] = "keyword";
-  SemanticTokenTypes2["modifier"] = "modifier";
-  SemanticTokenTypes2["comment"] = "comment";
-  SemanticTokenTypes2["string"] = "string";
-  SemanticTokenTypes2["number"] = "number";
-  SemanticTokenTypes2["regexp"] = "regexp";
-  SemanticTokenTypes2["operator"] = "operator";
-  SemanticTokenTypes2["decorator"] = "decorator";
+(function(SemanticTokenTypes) {
+  SemanticTokenTypes["namespace"] = "namespace";
+  SemanticTokenTypes["type"] = "type";
+  SemanticTokenTypes["class"] = "class";
+  SemanticTokenTypes["enum"] = "enum";
+  SemanticTokenTypes["interface"] = "interface";
+  SemanticTokenTypes["struct"] = "struct";
+  SemanticTokenTypes["typeParameter"] = "typeParameter";
+  SemanticTokenTypes["parameter"] = "parameter";
+  SemanticTokenTypes["variable"] = "variable";
+  SemanticTokenTypes["property"] = "property";
+  SemanticTokenTypes["enumMember"] = "enumMember";
+  SemanticTokenTypes["event"] = "event";
+  SemanticTokenTypes["function"] = "function";
+  SemanticTokenTypes["method"] = "method";
+  SemanticTokenTypes["macro"] = "macro";
+  SemanticTokenTypes["keyword"] = "keyword";
+  SemanticTokenTypes["modifier"] = "modifier";
+  SemanticTokenTypes["comment"] = "comment";
+  SemanticTokenTypes["string"] = "string";
+  SemanticTokenTypes["number"] = "number";
+  SemanticTokenTypes["regexp"] = "regexp";
+  SemanticTokenTypes["operator"] = "operator";
+  SemanticTokenTypes["decorator"] = "decorator";
 })(SemanticTokenTypes || (SemanticTokenTypes = {}));
 var SemanticTokenModifiers;
-(function(SemanticTokenModifiers2) {
-  SemanticTokenModifiers2["declaration"] = "declaration";
-  SemanticTokenModifiers2["definition"] = "definition";
-  SemanticTokenModifiers2["readonly"] = "readonly";
-  SemanticTokenModifiers2["static"] = "static";
-  SemanticTokenModifiers2["deprecated"] = "deprecated";
-  SemanticTokenModifiers2["abstract"] = "abstract";
-  SemanticTokenModifiers2["async"] = "async";
-  SemanticTokenModifiers2["modification"] = "modification";
-  SemanticTokenModifiers2["documentation"] = "documentation";
-  SemanticTokenModifiers2["defaultLibrary"] = "defaultLibrary";
+(function(SemanticTokenModifiers) {
+  SemanticTokenModifiers["declaration"] = "declaration";
+  SemanticTokenModifiers["definition"] = "definition";
+  SemanticTokenModifiers["readonly"] = "readonly";
+  SemanticTokenModifiers["static"] = "static";
+  SemanticTokenModifiers["deprecated"] = "deprecated";
+  SemanticTokenModifiers["abstract"] = "abstract";
+  SemanticTokenModifiers["async"] = "async";
+  SemanticTokenModifiers["modification"] = "modification";
+  SemanticTokenModifiers["documentation"] = "documentation";
+  SemanticTokenModifiers["defaultLibrary"] = "defaultLibrary";
 })(SemanticTokenModifiers || (SemanticTokenModifiers = {}));
 var SemanticTokens;
-(function(SemanticTokens2) {
+(function(SemanticTokens) {
   function is(value) {
     const candidate = value;
     return Is.objectLiteral(candidate) && (candidate.resultId === undefined || typeof candidate.resultId === "string") && Array.isArray(candidate.data) && (candidate.data.length === 0 || typeof candidate.data[0] === "number");
   }
-  SemanticTokens2.is = is;
+  SemanticTokens.is = is;
 })(SemanticTokens || (SemanticTokens = {}));
 var InlineValueText;
-(function(InlineValueText2) {
+(function(InlineValueText) {
   function create(range, text) {
     return { range, text };
   }
-  InlineValueText2.create = create;
+  InlineValueText.create = create;
   function is(value) {
     const candidate = value;
-    return candidate !== undefined && candidate !== null && Range2.is(candidate.range) && Is.string(candidate.text);
+    return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.string(candidate.text);
   }
-  InlineValueText2.is = is;
+  InlineValueText.is = is;
 })(InlineValueText || (InlineValueText = {}));
 var InlineValueVariableLookup;
-(function(InlineValueVariableLookup2) {
+(function(InlineValueVariableLookup) {
   function create(range, variableName, caseSensitiveLookup) {
     return { range, variableName, caseSensitiveLookup };
   }
-  InlineValueVariableLookup2.create = create;
+  InlineValueVariableLookup.create = create;
   function is(value) {
     const candidate = value;
-    return candidate !== undefined && candidate !== null && Range2.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup) && (Is.string(candidate.variableName) || candidate.variableName === undefined);
+    return candidate !== undefined && candidate !== null && Range.is(candidate.range) && Is.boolean(candidate.caseSensitiveLookup) && (Is.string(candidate.variableName) || candidate.variableName === undefined);
   }
-  InlineValueVariableLookup2.is = is;
+  InlineValueVariableLookup.is = is;
 })(InlineValueVariableLookup || (InlineValueVariableLookup = {}));
 var InlineValueEvaluatableExpression;
-(function(InlineValueEvaluatableExpression2) {
+(function(InlineValueEvaluatableExpression) {
   function create(range, expression) {
     return { range, expression };
   }
-  InlineValueEvaluatableExpression2.create = create;
+  InlineValueEvaluatableExpression.create = create;
   function is(value) {
     const candidate = value;
-    return candidate !== undefined && candidate !== null && Range2.is(candidate.range) && (Is.string(candidate.expression) || candidate.expression === undefined);
+    return candidate !== undefined && candidate !== null && Range.is(candidate.range) && (Is.string(candidate.expression) || candidate.expression === undefined);
   }
-  InlineValueEvaluatableExpression2.is = is;
+  InlineValueEvaluatableExpression.is = is;
 })(InlineValueEvaluatableExpression || (InlineValueEvaluatableExpression = {}));
 var InlineValueContext;
-(function(InlineValueContext2) {
+(function(InlineValueContext) {
   function create(frameId, stoppedLocation) {
     return { frameId, stoppedLocation };
   }
-  InlineValueContext2.create = create;
+  InlineValueContext.create = create;
   function is(value) {
     const candidate = value;
-    return Is.defined(candidate) && Range2.is(value.stoppedLocation);
+    return Is.defined(candidate) && Range.is(value.stoppedLocation);
   }
-  InlineValueContext2.is = is;
+  InlineValueContext.is = is;
 })(InlineValueContext || (InlineValueContext = {}));
 var InlayHintKind;
-(function(InlayHintKind2) {
-  InlayHintKind2.Type = 1;
-  InlayHintKind2.Parameter = 2;
+(function(InlayHintKind) {
+  InlayHintKind.Type = 1;
+  InlayHintKind.Parameter = 2;
   function is(value) {
     return value === 1 || value === 2;
   }
-  InlayHintKind2.is = is;
+  InlayHintKind.is = is;
 })(InlayHintKind || (InlayHintKind = {}));
 var InlayHintLabelPart;
-(function(InlayHintLabelPart2) {
+(function(InlayHintLabelPart) {
   function create(value) {
     return { value };
   }
-  InlayHintLabelPart2.create = create;
+  InlayHintLabelPart.create = create;
   function is(value) {
     const candidate = value;
     return Is.objectLiteral(candidate) && (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.location === undefined || Location.is(candidate.location)) && (candidate.command === undefined || Command.is(candidate.command));
   }
-  InlayHintLabelPart2.is = is;
+  InlayHintLabelPart.is = is;
 })(InlayHintLabelPart || (InlayHintLabelPart = {}));
 var InlayHint;
-(function(InlayHint2) {
+(function(InlayHint) {
   function create(position, label, kind) {
     const result = { position, label };
     if (kind !== undefined) {
@@ -1002,72 +1001,72 @@ var InlayHint;
     }
     return result;
   }
-  InlayHint2.create = create;
+  InlayHint.create = create;
   function is(value) {
     const candidate = value;
     return Is.objectLiteral(candidate) && Position.is(candidate.position) && (Is.string(candidate.label) || Is.typedArray(candidate.label, InlayHintLabelPart.is)) && (candidate.kind === undefined || InlayHintKind.is(candidate.kind)) && candidate.textEdits === undefined || Is.typedArray(candidate.textEdits, TextEdit.is) && (candidate.tooltip === undefined || Is.string(candidate.tooltip) || MarkupContent.is(candidate.tooltip)) && (candidate.paddingLeft === undefined || Is.boolean(candidate.paddingLeft)) && (candidate.paddingRight === undefined || Is.boolean(candidate.paddingRight));
   }
-  InlayHint2.is = is;
+  InlayHint.is = is;
 })(InlayHint || (InlayHint = {}));
 var StringValue;
-(function(StringValue2) {
+(function(StringValue) {
   function createSnippet(value) {
     return { kind: "snippet", value };
   }
-  StringValue2.createSnippet = createSnippet;
+  StringValue.createSnippet = createSnippet;
 })(StringValue || (StringValue = {}));
 var InlineCompletionItem;
-(function(InlineCompletionItem2) {
+(function(InlineCompletionItem) {
   function create(insertText, filterText, range, command) {
     return { insertText, filterText, range, command };
   }
-  InlineCompletionItem2.create = create;
+  InlineCompletionItem.create = create;
 })(InlineCompletionItem || (InlineCompletionItem = {}));
 var InlineCompletionList;
-(function(InlineCompletionList2) {
+(function(InlineCompletionList) {
   function create(items) {
     return { items };
   }
-  InlineCompletionList2.create = create;
+  InlineCompletionList.create = create;
 })(InlineCompletionList || (InlineCompletionList = {}));
 var InlineCompletionTriggerKind;
-(function(InlineCompletionTriggerKind2) {
-  InlineCompletionTriggerKind2.Invoked = 0;
-  InlineCompletionTriggerKind2.Automatic = 1;
+(function(InlineCompletionTriggerKind) {
+  InlineCompletionTriggerKind.Invoked = 0;
+  InlineCompletionTriggerKind.Automatic = 1;
 })(InlineCompletionTriggerKind || (InlineCompletionTriggerKind = {}));
 var SelectedCompletionInfo;
-(function(SelectedCompletionInfo2) {
+(function(SelectedCompletionInfo) {
   function create(range, text) {
     return { range, text };
   }
-  SelectedCompletionInfo2.create = create;
+  SelectedCompletionInfo.create = create;
 })(SelectedCompletionInfo || (SelectedCompletionInfo = {}));
 var InlineCompletionContext;
-(function(InlineCompletionContext2) {
+(function(InlineCompletionContext) {
   function create(triggerKind, selectedCompletionInfo) {
     return { triggerKind, selectedCompletionInfo };
   }
-  InlineCompletionContext2.create = create;
+  InlineCompletionContext.create = create;
 })(InlineCompletionContext || (InlineCompletionContext = {}));
 var WorkspaceFolder;
-(function(WorkspaceFolder2) {
+(function(WorkspaceFolder) {
   function is(value) {
     const candidate = value;
     return Is.objectLiteral(candidate) && URI.is(candidate.uri) && Is.string(candidate.name);
   }
-  WorkspaceFolder2.is = is;
+  WorkspaceFolder.is = is;
 })(WorkspaceFolder || (WorkspaceFolder = {}));
 var TextDocument;
-(function(TextDocument2) {
+(function(TextDocument) {
   function create(uri, languageId, version, content) {
     return new FullTextDocument(uri, languageId, version, content);
   }
-  TextDocument2.create = create;
+  TextDocument.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount) && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;
   }
-  TextDocument2.is = is;
+  TextDocument.is = is;
   function applyEdits(document, edits) {
     let text = document.getText();
     let sortedEdits = mergeSort(edits, (a, b) => {
@@ -1091,7 +1090,7 @@ var TextDocument;
     }
     return text;
   }
-  TextDocument2.applyEdits = applyEdits;
+  TextDocument.applyEdits = applyEdits;
   function mergeSort(data, compare) {
     if (data.length <= 1) {
       return data;
@@ -1211,52 +1210,52 @@ class FullTextDocument {
   }
 }
 var Is;
-(function(Is2) {
+(function(Is) {
   const toString = Object.prototype.toString;
   function defined(value) {
     return typeof value !== "undefined";
   }
-  Is2.defined = defined;
+  Is.defined = defined;
   function undefined$1(value) {
     return typeof value === "undefined";
   }
-  Is2.undefined = undefined$1;
+  Is.undefined = undefined$1;
   function boolean(value) {
     return value === true || value === false;
   }
-  Is2.boolean = boolean;
+  Is.boolean = boolean;
   function string(value) {
     return toString.call(value) === "[object String]";
   }
-  Is2.string = string;
+  Is.string = string;
   function number(value) {
     return toString.call(value) === "[object Number]";
   }
-  Is2.number = number;
+  Is.number = number;
   function numberRange(value, min, max) {
     return toString.call(value) === "[object Number]" && min <= value && value <= max;
   }
-  Is2.numberRange = numberRange;
-  function integer2(value) {
+  Is.numberRange = numberRange;
+  function integer(value) {
     return toString.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
   }
-  Is2.integer = integer2;
-  function uinteger2(value) {
+  Is.integer = integer;
+  function uinteger(value) {
     return toString.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
   }
-  Is2.uinteger = uinteger2;
+  Is.uinteger = uinteger;
   function func(value) {
     return toString.call(value) === "[object Function]";
   }
-  Is2.func = func;
+  Is.func = func;
   function objectLiteral(value) {
     return value !== null && typeof value === "object";
   }
-  Is2.objectLiteral = objectLiteral;
+  Is.objectLiteral = objectLiteral;
   function typedArray(value, check) {
     return Array.isArray(value) && value.every(check);
   }
-  Is2.typedArray = typedArray;
+  Is.typedArray = typedArray;
 })(Is || (Is = {}));
 
 // ../../node_modules/monaco-editor/esm/vs/languages/features/common/lspLanguageFeatures.js
@@ -1279,7 +1278,7 @@ class DiagnosticsAdapter {
       this._doValidate(model.uri, modeId);
     };
     const onModelRemoved = (model) => {
-      editor.setModelMarkers(model, this._languageId, []);
+      editor2.setModelMarkers(model, this._languageId, []);
       let uriStr = model.uri.toString();
       let listener = this._listener[uriStr];
       if (listener) {
@@ -1287,14 +1286,14 @@ class DiagnosticsAdapter {
         delete this._listener[uriStr];
       }
     };
-    this._disposables.push(editor.onDidCreateModel(onModelAdd));
-    this._disposables.push(editor.onWillDisposeModel(onModelRemoved));
-    this._disposables.push(editor.onDidChangeModelLanguage((event) => {
+    this._disposables.push(editor2.onDidCreateModel(onModelAdd));
+    this._disposables.push(editor2.onWillDisposeModel(onModelRemoved));
+    this._disposables.push(editor2.onDidChangeModelLanguage((event) => {
       onModelRemoved(event.model);
       onModelAdd(event.model);
     }));
     this._disposables.push(configChangeEvent((_) => {
-      editor.getModels().forEach((model) => {
+      editor2.getModels().forEach((model) => {
         if (model.getLanguageId() === this._languageId) {
           onModelRemoved(model);
           onModelAdd(model);
@@ -1303,13 +1302,13 @@ class DiagnosticsAdapter {
     }));
     this._disposables.push({
       dispose: () => {
-        editor.getModels().forEach(onModelRemoved);
+        editor2.getModels().forEach(onModelRemoved);
         for (let key in this._listener) {
           this._listener[key].dispose();
         }
       }
     });
-    editor.getModels().forEach(onModelAdd);
+    editor2.getModels().forEach(onModelAdd);
   }
   dispose() {
     this._disposables.forEach((d) => d && d.dispose());
@@ -1320,9 +1319,9 @@ class DiagnosticsAdapter {
       return worker.doValidation(resource.toString());
     }).then((diagnostics) => {
       const markers = diagnostics.map((d) => toDiagnostics(resource, d));
-      let model = editor.getModel(resource);
+      let model = editor2.getModel(resource);
       if (model && model.getLanguageId() === languageId) {
-        editor.setModelMarkers(model, languageId, markers);
+        editor2.setModelMarkers(model, languageId, markers);
       }
     }).then(undefined, (err) => {
       console.error(err);
@@ -1332,15 +1331,15 @@ class DiagnosticsAdapter {
 function toSeverity(lsSeverity) {
   switch (lsSeverity) {
     case DiagnosticSeverity.Error:
-      return MarkerSeverity.Error;
+      return MarkerSeverity3.Error;
     case DiagnosticSeverity.Warning:
-      return MarkerSeverity.Warning;
+      return MarkerSeverity3.Warning;
     case DiagnosticSeverity.Information:
-      return MarkerSeverity.Info;
+      return MarkerSeverity3.Info;
     case DiagnosticSeverity.Hint:
-      return MarkerSeverity.Hint;
+      return MarkerSeverity3.Hint;
     default:
-      return MarkerSeverity.Info;
+      return MarkerSeverity3.Info;
   }
 }
 function toDiagnostics(resource, diag) {
@@ -1374,7 +1373,7 @@ class CompletionAdapter {
         return;
       }
       const wordInfo = model.getWordUntilPosition(position);
-      const wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
+      const wordRange = new Range3(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
       const items = info.items.map((entry) => {
         const item = {
           label: entry.label,
@@ -1402,7 +1401,7 @@ class CompletionAdapter {
           item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
         }
         if (entry.insertTextFormat === InsertTextFormat.Snippet) {
-          item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
+          item.insertTextRules = languages2.CompletionItemInsertTextRule.InsertAsSnippet;
         }
         return item;
       });
@@ -1435,13 +1434,13 @@ function toRange(range) {
   if (!range) {
     return;
   }
-  return new Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);
+  return new Range3(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);
 }
 function isInsertReplaceEdit(edit) {
   return typeof edit.insert !== "undefined" && typeof edit.replace !== "undefined";
 }
 function toCompletionItemKind(kind) {
-  const mItemKind = languages.CompletionItemKind;
+  const mItemKind = languages2.CompletionItemKind;
   switch (kind) {
     case CompletionItemKind.Text:
       return mItemKind.Text;
@@ -1568,13 +1567,13 @@ class DocumentHighlightAdapter {
 function toDocumentHighlightKind(kind) {
   switch (kind) {
     case DocumentHighlightKind.Read:
-      return languages.DocumentHighlightKind.Read;
+      return languages2.DocumentHighlightKind.Read;
     case DocumentHighlightKind.Write:
-      return languages.DocumentHighlightKind.Write;
+      return languages2.DocumentHighlightKind.Write;
     case DocumentHighlightKind.Text:
-      return languages.DocumentHighlightKind.Text;
+      return languages2.DocumentHighlightKind.Text;
   }
-  return languages.DocumentHighlightKind.Text;
+  return languages2.DocumentHighlightKind.Text;
 }
 
 class DefinitionAdapter {
@@ -1595,7 +1594,7 @@ class DefinitionAdapter {
 }
 function toLocation(location) {
   return {
-    uri: Uri.parse(location.uri),
+    uri: Uri2.parse(location.uri),
     range: toRange(location.range)
   };
 }
@@ -1636,7 +1635,7 @@ function toWorkspaceEdit(edit) {
   }
   let resourceEdits = [];
   for (let uri in edit.changes) {
-    const _uri = Uri.parse(uri);
+    const _uri = Uri2.parse(uri);
     for (let e of edit.changes[uri]) {
       resourceEdits.push({
         resource: _uri,
@@ -1695,7 +1694,7 @@ function toDocumentSymbol(symbol) {
   };
 }
 function toSymbolKind(kind) {
-  let mKind = languages.SymbolKind;
+  let mKind = languages2.SymbolKind;
   switch (kind) {
     case SymbolKind.File:
       return mKind.File;
@@ -1862,11 +1861,11 @@ class FoldingRangeAdapter {
 function toFoldingRangeKind(kind) {
   switch (kind) {
     case FoldingRangeKind.Comment:
-      return languages.FoldingRangeKind.Comment;
+      return languages2.FoldingRangeKind.Comment;
     case FoldingRangeKind.Imports:
-      return languages.FoldingRangeKind.Imports;
+      return languages2.FoldingRangeKind.Imports;
     case FoldingRangeKind.Region:
-      return languages.FoldingRangeKind.Region;
+      return languages2.FoldingRangeKind.Region;
   }
   return;
 }
@@ -1898,15 +1897,15 @@ function createScanner(text, ignoreTrivia = false) {
   let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
   function scanHexDigits(count, exact) {
     let digits = 0;
-    let value2 = 0;
+    let value = 0;
     while (digits < count) {
       let ch = text.charCodeAt(pos);
       if (ch >= 48 && ch <= 57) {
-        value2 = value2 * 16 + ch - 48;
+        value = value * 16 + ch - 48;
       } else if (ch >= 65 && ch <= 70) {
-        value2 = value2 * 16 + ch - 65 + 10;
+        value = value * 16 + ch - 65 + 10;
       } else if (ch >= 97 && ch <= 102) {
-        value2 = value2 * 16 + ch - 97 + 10;
+        value = value * 16 + ch - 97 + 10;
       } else {
         break;
       }
@@ -1914,9 +1913,9 @@ function createScanner(text, ignoreTrivia = false) {
       digits++;
     }
     if (digits < count) {
-      value2 = -1;
+      value = -1;
     }
-    return value2;
+    return value;
   }
   function setPosition(newPosition) {
     pos = newPosition;
@@ -2224,87 +2223,87 @@ function isDigit(ch) {
   return ch >= 48 && ch <= 57;
 }
 var CharacterCodes;
-(function(CharacterCodes2) {
-  CharacterCodes2[CharacterCodes2["lineFeed"] = 10] = "lineFeed";
-  CharacterCodes2[CharacterCodes2["carriageReturn"] = 13] = "carriageReturn";
-  CharacterCodes2[CharacterCodes2["space"] = 32] = "space";
-  CharacterCodes2[CharacterCodes2["_0"] = 48] = "_0";
-  CharacterCodes2[CharacterCodes2["_1"] = 49] = "_1";
-  CharacterCodes2[CharacterCodes2["_2"] = 50] = "_2";
-  CharacterCodes2[CharacterCodes2["_3"] = 51] = "_3";
-  CharacterCodes2[CharacterCodes2["_4"] = 52] = "_4";
-  CharacterCodes2[CharacterCodes2["_5"] = 53] = "_5";
-  CharacterCodes2[CharacterCodes2["_6"] = 54] = "_6";
-  CharacterCodes2[CharacterCodes2["_7"] = 55] = "_7";
-  CharacterCodes2[CharacterCodes2["_8"] = 56] = "_8";
-  CharacterCodes2[CharacterCodes2["_9"] = 57] = "_9";
-  CharacterCodes2[CharacterCodes2["a"] = 97] = "a";
-  CharacterCodes2[CharacterCodes2["b"] = 98] = "b";
-  CharacterCodes2[CharacterCodes2["c"] = 99] = "c";
-  CharacterCodes2[CharacterCodes2["d"] = 100] = "d";
-  CharacterCodes2[CharacterCodes2["e"] = 101] = "e";
-  CharacterCodes2[CharacterCodes2["f"] = 102] = "f";
-  CharacterCodes2[CharacterCodes2["g"] = 103] = "g";
-  CharacterCodes2[CharacterCodes2["h"] = 104] = "h";
-  CharacterCodes2[CharacterCodes2["i"] = 105] = "i";
-  CharacterCodes2[CharacterCodes2["j"] = 106] = "j";
-  CharacterCodes2[CharacterCodes2["k"] = 107] = "k";
-  CharacterCodes2[CharacterCodes2["l"] = 108] = "l";
-  CharacterCodes2[CharacterCodes2["m"] = 109] = "m";
-  CharacterCodes2[CharacterCodes2["n"] = 110] = "n";
-  CharacterCodes2[CharacterCodes2["o"] = 111] = "o";
-  CharacterCodes2[CharacterCodes2["p"] = 112] = "p";
-  CharacterCodes2[CharacterCodes2["q"] = 113] = "q";
-  CharacterCodes2[CharacterCodes2["r"] = 114] = "r";
-  CharacterCodes2[CharacterCodes2["s"] = 115] = "s";
-  CharacterCodes2[CharacterCodes2["t"] = 116] = "t";
-  CharacterCodes2[CharacterCodes2["u"] = 117] = "u";
-  CharacterCodes2[CharacterCodes2["v"] = 118] = "v";
-  CharacterCodes2[CharacterCodes2["w"] = 119] = "w";
-  CharacterCodes2[CharacterCodes2["x"] = 120] = "x";
-  CharacterCodes2[CharacterCodes2["y"] = 121] = "y";
-  CharacterCodes2[CharacterCodes2["z"] = 122] = "z";
-  CharacterCodes2[CharacterCodes2["A"] = 65] = "A";
-  CharacterCodes2[CharacterCodes2["B"] = 66] = "B";
-  CharacterCodes2[CharacterCodes2["C"] = 67] = "C";
-  CharacterCodes2[CharacterCodes2["D"] = 68] = "D";
-  CharacterCodes2[CharacterCodes2["E"] = 69] = "E";
-  CharacterCodes2[CharacterCodes2["F"] = 70] = "F";
-  CharacterCodes2[CharacterCodes2["G"] = 71] = "G";
-  CharacterCodes2[CharacterCodes2["H"] = 72] = "H";
-  CharacterCodes2[CharacterCodes2["I"] = 73] = "I";
-  CharacterCodes2[CharacterCodes2["J"] = 74] = "J";
-  CharacterCodes2[CharacterCodes2["K"] = 75] = "K";
-  CharacterCodes2[CharacterCodes2["L"] = 76] = "L";
-  CharacterCodes2[CharacterCodes2["M"] = 77] = "M";
-  CharacterCodes2[CharacterCodes2["N"] = 78] = "N";
-  CharacterCodes2[CharacterCodes2["O"] = 79] = "O";
-  CharacterCodes2[CharacterCodes2["P"] = 80] = "P";
-  CharacterCodes2[CharacterCodes2["Q"] = 81] = "Q";
-  CharacterCodes2[CharacterCodes2["R"] = 82] = "R";
-  CharacterCodes2[CharacterCodes2["S"] = 83] = "S";
-  CharacterCodes2[CharacterCodes2["T"] = 84] = "T";
-  CharacterCodes2[CharacterCodes2["U"] = 85] = "U";
-  CharacterCodes2[CharacterCodes2["V"] = 86] = "V";
-  CharacterCodes2[CharacterCodes2["W"] = 87] = "W";
-  CharacterCodes2[CharacterCodes2["X"] = 88] = "X";
-  CharacterCodes2[CharacterCodes2["Y"] = 89] = "Y";
-  CharacterCodes2[CharacterCodes2["Z"] = 90] = "Z";
-  CharacterCodes2[CharacterCodes2["asterisk"] = 42] = "asterisk";
-  CharacterCodes2[CharacterCodes2["backslash"] = 92] = "backslash";
-  CharacterCodes2[CharacterCodes2["closeBrace"] = 125] = "closeBrace";
-  CharacterCodes2[CharacterCodes2["closeBracket"] = 93] = "closeBracket";
-  CharacterCodes2[CharacterCodes2["colon"] = 58] = "colon";
-  CharacterCodes2[CharacterCodes2["comma"] = 44] = "comma";
-  CharacterCodes2[CharacterCodes2["dot"] = 46] = "dot";
-  CharacterCodes2[CharacterCodes2["doubleQuote"] = 34] = "doubleQuote";
-  CharacterCodes2[CharacterCodes2["minus"] = 45] = "minus";
-  CharacterCodes2[CharacterCodes2["openBrace"] = 123] = "openBrace";
-  CharacterCodes2[CharacterCodes2["openBracket"] = 91] = "openBracket";
-  CharacterCodes2[CharacterCodes2["plus"] = 43] = "plus";
-  CharacterCodes2[CharacterCodes2["slash"] = 47] = "slash";
-  CharacterCodes2[CharacterCodes2["formFeed"] = 12] = "formFeed";
-  CharacterCodes2[CharacterCodes2["tab"] = 9] = "tab";
+(function(CharacterCodes) {
+  CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed";
+  CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn";
+  CharacterCodes[CharacterCodes["space"] = 32] = "space";
+  CharacterCodes[CharacterCodes["_0"] = 48] = "_0";
+  CharacterCodes[CharacterCodes["_1"] = 49] = "_1";
+  CharacterCodes[CharacterCodes["_2"] = 50] = "_2";
+  CharacterCodes[CharacterCodes["_3"] = 51] = "_3";
+  CharacterCodes[CharacterCodes["_4"] = 52] = "_4";
+  CharacterCodes[CharacterCodes["_5"] = 53] = "_5";
+  CharacterCodes[CharacterCodes["_6"] = 54] = "_6";
+  CharacterCodes[CharacterCodes["_7"] = 55] = "_7";
+  CharacterCodes[CharacterCodes["_8"] = 56] = "_8";
+  CharacterCodes[CharacterCodes["_9"] = 57] = "_9";
+  CharacterCodes[CharacterCodes["a"] = 97] = "a";
+  CharacterCodes[CharacterCodes["b"] = 98] = "b";
+  CharacterCodes[CharacterCodes["c"] = 99] = "c";
+  CharacterCodes[CharacterCodes["d"] = 100] = "d";
+  CharacterCodes[CharacterCodes["e"] = 101] = "e";
+  CharacterCodes[CharacterCodes["f"] = 102] = "f";
+  CharacterCodes[CharacterCodes["g"] = 103] = "g";
+  CharacterCodes[CharacterCodes["h"] = 104] = "h";
+  CharacterCodes[CharacterCodes["i"] = 105] = "i";
+  CharacterCodes[CharacterCodes["j"] = 106] = "j";
+  CharacterCodes[CharacterCodes["k"] = 107] = "k";
+  CharacterCodes[CharacterCodes["l"] = 108] = "l";
+  CharacterCodes[CharacterCodes["m"] = 109] = "m";
+  CharacterCodes[CharacterCodes["n"] = 110] = "n";
+  CharacterCodes[CharacterCodes["o"] = 111] = "o";
+  CharacterCodes[CharacterCodes["p"] = 112] = "p";
+  CharacterCodes[CharacterCodes["q"] = 113] = "q";
+  CharacterCodes[CharacterCodes["r"] = 114] = "r";
+  CharacterCodes[CharacterCodes["s"] = 115] = "s";
+  CharacterCodes[CharacterCodes["t"] = 116] = "t";
+  CharacterCodes[CharacterCodes["u"] = 117] = "u";
+  CharacterCodes[CharacterCodes["v"] = 118] = "v";
+  CharacterCodes[CharacterCodes["w"] = 119] = "w";
+  CharacterCodes[CharacterCodes["x"] = 120] = "x";
+  CharacterCodes[CharacterCodes["y"] = 121] = "y";
+  CharacterCodes[CharacterCodes["z"] = 122] = "z";
+  CharacterCodes[CharacterCodes["A"] = 65] = "A";
+  CharacterCodes[CharacterCodes["B"] = 66] = "B";
+  CharacterCodes[CharacterCodes["C"] = 67] = "C";
+  CharacterCodes[CharacterCodes["D"] = 68] = "D";
+  CharacterCodes[CharacterCodes["E"] = 69] = "E";
+  CharacterCodes[CharacterCodes["F"] = 70] = "F";
+  CharacterCodes[CharacterCodes["G"] = 71] = "G";
+  CharacterCodes[CharacterCodes["H"] = 72] = "H";
+  CharacterCodes[CharacterCodes["I"] = 73] = "I";
+  CharacterCodes[CharacterCodes["J"] = 74] = "J";
+  CharacterCodes[CharacterCodes["K"] = 75] = "K";
+  CharacterCodes[CharacterCodes["L"] = 76] = "L";
+  CharacterCodes[CharacterCodes["M"] = 77] = "M";
+  CharacterCodes[CharacterCodes["N"] = 78] = "N";
+  CharacterCodes[CharacterCodes["O"] = 79] = "O";
+  CharacterCodes[CharacterCodes["P"] = 80] = "P";
+  CharacterCodes[CharacterCodes["Q"] = 81] = "Q";
+  CharacterCodes[CharacterCodes["R"] = 82] = "R";
+  CharacterCodes[CharacterCodes["S"] = 83] = "S";
+  CharacterCodes[CharacterCodes["T"] = 84] = "T";
+  CharacterCodes[CharacterCodes["U"] = 85] = "U";
+  CharacterCodes[CharacterCodes["V"] = 86] = "V";
+  CharacterCodes[CharacterCodes["W"] = 87] = "W";
+  CharacterCodes[CharacterCodes["X"] = 88] = "X";
+  CharacterCodes[CharacterCodes["Y"] = 89] = "Y";
+  CharacterCodes[CharacterCodes["Z"] = 90] = "Z";
+  CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk";
+  CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash";
+  CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace";
+  CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket";
+  CharacterCodes[CharacterCodes["colon"] = 58] = "colon";
+  CharacterCodes[CharacterCodes["comma"] = 44] = "comma";
+  CharacterCodes[CharacterCodes["dot"] = 46] = "dot";
+  CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote";
+  CharacterCodes[CharacterCodes["minus"] = 45] = "minus";
+  CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace";
+  CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket";
+  CharacterCodes[CharacterCodes["plus"] = 43] = "plus";
+  CharacterCodes[CharacterCodes["slash"] = 47] = "slash";
+  CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed";
+  CharacterCodes[CharacterCodes["tab"] = 9] = "tab";
 })(CharacterCodes || (CharacterCodes = {}));
 
 // ../../node_modules/monaco-editor/esm/external/jsonc-parser/lib/esm/impl/string-intern.js
@@ -2343,8 +2342,8 @@ var cachedBreakLinesWithSpaces = {
 
 // ../../node_modules/monaco-editor/esm/external/jsonc-parser/lib/esm/impl/parser.js
 var ParseOptions;
-(function(ParseOptions2) {
-  ParseOptions2.DEFAULT = {
+(function(ParseOptions) {
+  ParseOptions.DEFAULT = {
     allowTrailingComma: false
   };
 })(ParseOptions || (ParseOptions = {}));
@@ -2352,53 +2351,53 @@ var ParseOptions;
 // ../../node_modules/monaco-editor/esm/external/jsonc-parser/lib/esm/main.js
 var createScanner2 = createScanner;
 var ScanError;
-(function(ScanError2) {
-  ScanError2[ScanError2["None"] = 0] = "None";
-  ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
-  ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
-  ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
-  ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
-  ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
-  ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+(function(ScanError) {
+  ScanError[ScanError["None"] = 0] = "None";
+  ScanError[ScanError["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+  ScanError[ScanError["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+  ScanError[ScanError["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+  ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode";
+  ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+  ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter";
 })(ScanError || (ScanError = {}));
 var SyntaxKind;
-(function(SyntaxKind2) {
-  SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
-  SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
-  SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
-  SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
-  SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
-  SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
-  SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
-  SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
-  SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
-  SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
-  SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
-  SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
-  SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
-  SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
-  SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
-  SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
-  SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+(function(SyntaxKind) {
+  SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken";
+  SyntaxKind[SyntaxKind["CloseBraceToken"] = 2] = "CloseBraceToken";
+  SyntaxKind[SyntaxKind["OpenBracketToken"] = 3] = "OpenBracketToken";
+  SyntaxKind[SyntaxKind["CloseBracketToken"] = 4] = "CloseBracketToken";
+  SyntaxKind[SyntaxKind["CommaToken"] = 5] = "CommaToken";
+  SyntaxKind[SyntaxKind["ColonToken"] = 6] = "ColonToken";
+  SyntaxKind[SyntaxKind["NullKeyword"] = 7] = "NullKeyword";
+  SyntaxKind[SyntaxKind["TrueKeyword"] = 8] = "TrueKeyword";
+  SyntaxKind[SyntaxKind["FalseKeyword"] = 9] = "FalseKeyword";
+  SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral";
+  SyntaxKind[SyntaxKind["NumericLiteral"] = 11] = "NumericLiteral";
+  SyntaxKind[SyntaxKind["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+  SyntaxKind[SyntaxKind["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+  SyntaxKind[SyntaxKind["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+  SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia";
+  SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown";
+  SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF";
 })(SyntaxKind || (SyntaxKind = {}));
 var ParseErrorCode;
-(function(ParseErrorCode2) {
-  ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
-  ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
-  ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
-  ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
-  ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
-  ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
-  ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
-  ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
-  ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
-  ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
-  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
-  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
-  ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
-  ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
-  ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
-  ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+(function(ParseErrorCode) {
+  ParseErrorCode[ParseErrorCode["InvalidSymbol"] = 1] = "InvalidSymbol";
+  ParseErrorCode[ParseErrorCode["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+  ParseErrorCode[ParseErrorCode["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+  ParseErrorCode[ParseErrorCode["ValueExpected"] = 4] = "ValueExpected";
+  ParseErrorCode[ParseErrorCode["ColonExpected"] = 5] = "ColonExpected";
+  ParseErrorCode[ParseErrorCode["CommaExpected"] = 6] = "CommaExpected";
+  ParseErrorCode[ParseErrorCode["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+  ParseErrorCode[ParseErrorCode["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+  ParseErrorCode[ParseErrorCode["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+  ParseErrorCode[ParseErrorCode["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+  ParseErrorCode[ParseErrorCode["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+  ParseErrorCode[ParseErrorCode["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+  ParseErrorCode[ParseErrorCode["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+  ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode";
+  ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+  ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter";
 })(ParseErrorCode || (ParseErrorCode = {}));
 
 // ../../node_modules/monaco-editor/esm/vs/languages/features/json/tokenization.js
@@ -2597,10 +2596,10 @@ function getWorker() {
 class JSONDiagnosticsAdapter extends DiagnosticsAdapter {
   constructor(languageId, worker2, defaults) {
     super(languageId, worker2, defaults.onDidChange);
-    this._disposables.push(editor.onWillDisposeModel((model) => {
+    this._disposables.push(editor2.onWillDisposeModel((model) => {
       this._resetSchema(model.uri);
     }));
-    this._disposables.push(editor.onDidChangeModelLanguage((event) => {
+    this._disposables.push(editor2.onDidChangeModelLanguage((event) => {
       this._resetSchema(event.model.uri);
     }));
   }
@@ -2622,38 +2621,38 @@ function setupMode(defaults) {
     const { languageId, modeConfiguration: modeConfiguration2 } = defaults;
     disposeAll(providers);
     if (modeConfiguration2.documentFormattingEdits) {
-      providers.push(languages.registerDocumentFormattingEditProvider(languageId, new DocumentFormattingEditProvider(worker)));
+      providers.push(languages2.registerDocumentFormattingEditProvider(languageId, new DocumentFormattingEditProvider(worker)));
     }
     if (modeConfiguration2.documentRangeFormattingEdits) {
-      providers.push(languages.registerDocumentRangeFormattingEditProvider(languageId, new DocumentRangeFormattingEditProvider(worker)));
+      providers.push(languages2.registerDocumentRangeFormattingEditProvider(languageId, new DocumentRangeFormattingEditProvider(worker)));
     }
     if (modeConfiguration2.completionItems) {
-      providers.push(languages.registerCompletionItemProvider(languageId, new CompletionAdapter(worker, [" ", ":", '"'])));
+      providers.push(languages2.registerCompletionItemProvider(languageId, new CompletionAdapter(worker, [" ", ":", '"'])));
     }
     if (modeConfiguration2.hovers) {
-      providers.push(languages.registerHoverProvider(languageId, new HoverAdapter(worker)));
+      providers.push(languages2.registerHoverProvider(languageId, new HoverAdapter(worker)));
     }
     if (modeConfiguration2.documentSymbols) {
-      providers.push(languages.registerDocumentSymbolProvider(languageId, new DocumentSymbolAdapter(worker)));
+      providers.push(languages2.registerDocumentSymbolProvider(languageId, new DocumentSymbolAdapter(worker)));
     }
     if (modeConfiguration2.tokens) {
-      providers.push(languages.setTokensProvider(languageId, createTokenizationSupport(true)));
+      providers.push(languages2.setTokensProvider(languageId, createTokenizationSupport(true)));
     }
     if (modeConfiguration2.colors) {
-      providers.push(languages.registerColorProvider(languageId, new DocumentColorAdapter(worker)));
+      providers.push(languages2.registerColorProvider(languageId, new DocumentColorAdapter(worker)));
     }
     if (modeConfiguration2.foldingRanges) {
-      providers.push(languages.registerFoldingRangeProvider(languageId, new FoldingRangeAdapter(worker)));
+      providers.push(languages2.registerFoldingRangeProvider(languageId, new FoldingRangeAdapter(worker)));
     }
     if (modeConfiguration2.diagnostics) {
       providers.push(new JSONDiagnosticsAdapter(languageId, worker, defaults));
     }
     if (modeConfiguration2.selectionRanges) {
-      providers.push(languages.registerSelectionRangeProvider(languageId, new SelectionRangeAdapter(worker)));
+      providers.push(languages2.registerSelectionRangeProvider(languageId, new SelectionRangeAdapter(worker)));
     }
   }
   registerProviders();
-  disposables.push(languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration));
+  disposables.push(languages2.setLanguageConfiguration(defaults.languageId, richEditConfiguration));
   let modeConfiguration = defaults.modeConfiguration;
   defaults.onDidChange((newDefaults) => {
     if (newDefaults.modeConfiguration !== modeConfiguration) {
@@ -2712,5 +2711,5 @@ export {
   toTextEdit
 };
 
-//# debugId=933E27AE004B9DC664756E2164756E21
-//# sourceMappingURL=jsonMode-dkr040ga.js.map
+//# debugId=4300924A899AA13864756E2164756E21
+//# sourceMappingURL=jsonMode-tyx2kj6p.js.map