{"version":3,"sources":["webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/vscode-languageserver-types/main.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/workerManager.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/languageFeatures.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/impl/parser.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/impl/scanner.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/_deps/jsonc-parser/main.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/tokenization.js","webpack:///./node_modules/monaco-editor/esm/vs/language/json/jsonMode.js"],"names":["integer","uinteger","Position","Range","Location","LocationLink","Color","ColorInformation","ColorPresentation","FoldingRangeKind","FoldingRange","DiagnosticRelatedInformation","DiagnosticSeverity","DiagnosticTag","CodeDescription","Diagnostic","Command","TextEdit","ChangeAnnotation","ChangeAnnotationIdentifier","AnnotatedTextEdit","TextDocumentEdit","CreateFile","RenameFile","DeleteFile","WorkspaceEdit","STOP_WHEN_IDLE_FOR","WorkerManager","defaults","_this","this","_defaults","_worker","_idleCheckInterval","window","setInterval","_checkIfIdle","_lastUsedTime","_configChangeListener","onDidChange","_stopWorker","prototype","dispose","_client","clearInterval","timePassedSinceLastUsed","Date","now","_getClient","createWebWorker","moduleId","label","languageId","createData","languageSettings","diagnosticsOptions","enableSchemaRequest","getProxy","getLanguageServiceWorker","resources","_i","arguments","length","then","client","_","withSyncedResources","MIN_VALUE","MAX_VALUE","create","line","character","Number","is","value","candidate","Is","objectLiteral","one","two","three","four","start","end","Error","uri","range","defined","string","undefined","targetUri","targetRange","targetSelectionRange","originSelectionRange","red","green","blue","alpha","numberRange","color","textEdit","additionalTextEdits","typedArray","startLine","endLine","startCharacter","endCharacter","kind","result","location","message","Warning","Information","Hint","Unnecessary","Deprecated","href","severity","code","source","relatedInformation","_a","number","codeDescription","title","command","args","replace","newText","insert","position","del","needsConfirmation","description","boolean","annotation","annotationId","textDocument","edits","OptionalVersionedTextDocumentIdentifier","Array","isArray","options","overwrite","ignoreIfExists","oldUri","newUri","recursive","ignoreIfNotExists","changes","documentChanges","every","change","TextDocumentIdentifier","VersionedTextDocumentIdentifier","TextDocumentItem","MarkupKind","MarkupContent","CompletionItemKind","InsertTextFormat","CompletionItemTag","InsertReplaceEdit","InsertTextMode","CompletionItem","CompletionList","MarkedString","Hover","ParameterInformation","SignatureInformation","DocumentHighlightKind","DocumentHighlight","SymbolKind","SymbolTag","SymbolInformation","DocumentSymbol","CodeActionKind","CodeActionContext","CodeAction","CodeLens","FormattingOptions","DocumentLink","SelectionRange","TextEditChangeImpl","changeAnnotations","edit","id","assertChangeAnnotations","manage","push","delete","add","all","clear","splice","ChangeAnnotations","annotations","_annotations","Object","_counter","_size","defineProperty","get","enumerable","configurable","idOrAnnotation","nextId","toString","WorkspaceChange","workspaceEdit","_textEditChanges","_workspaceEdit","_changeAnnotations","forEach","textEditChange","keys","key","initDocumentChanges","size","getTextEditChange","version","textDocumentEdit","initChanges","createFile","optionsOrAnnotation","operation","renameFile","deleteFile","text","PlainText","Markdown","Text","Method","Function","Constructor","Field","Variable","Class","Interface","Module","Property","Unit","Value","Enum","Keyword","Snippet","File","Reference","Folder","EnumMember","Constant","Struct","Event","Operator","TypeParameter","asIs","adjustIndentation","items","isIncomplete","fromPlainText","plainText","language","contents","documentation","parameters","Read","Write","Namespace","Package","String","Boolean","Key","Null","name","containerName","detail","selectionRange","children","deprecated","tags","Empty","QuickFix","Refactor","RefactorExtract","RefactorInline","RefactorRewrite","Source","SourceOrganizeImports","SourceFixAll","diagnostics","only","kindOrCommandOrEdit","checkKind","isPreferred","data","tabSize","insertSpaces","target","parent","TextDocument","content","FullTextDocument","lineCount","func","getText","positionAt","offsetAt","applyEdits","document","sortedEdits","mergeSort","a","b","diff","lastModifiedOffset","i","e","startOffset","endOffset","substring","compare","p","left","slice","right","leftIdx","rightIdx","ret","_uri","_languageId","_version","_content","_lineOffsets","update","event","getLineOffsets","lineOffsets","isLineStart","ch","charAt","offset","Math","max","min","low","high","mid","floor","lineOffset","nextLineOffset","call","check","DiagnosticsAdapter","_disposables","_listener","onModelAdd","model","handle","modeId","getLanguageId","onDidChangeContent","clearTimeout","setTimeout","_doValidate","onModelRemoved","setModelMarkers","uriStr","listener","onDidCreateModel","onWillDisposeModel","_resetSchema","onDidChangeModelLanguage","getModels","d","resource","worker","resetSchema","doValidation","markers","map","toDiagnostics","getModel","err","console","error","toSeverity","lsSeverity","Info","diag","startLineNumber","startColumn","endLineNumber","endColumn","fromPosition","column","lineNumber","fromRange","toRange","isInsertReplaceEdit","toCompletionItemKind","mItemKind","toTextEdit","toCommand","c","CompletionAdapter","provideCompletionItems","context","token","doComplete","info","wordInfo","getWordUntilPosition","wordRange","entry","item","insertText","sortText","filterText","insertTextFormat","insertTextRules","CompletionItemInsertTextRule","InsertAsSnippet","suggestions","isMarkupContent","thing","toMarkdownString","toMarkedStringArray","HoverAdapter","provideHover","doHover","toSymbolKind","mKind","DocumentSymbolAdapter","provideDocumentSymbols","findDocumentSymbols","fromFormattingOptions","DocumentFormattingEditProvider","provideDocumentFormattingEdits","format","DocumentRangeFormattingEditProvider","provideDocumentRangeFormattingEdits","DocumentColorAdapter","provideDocumentColors","findDocumentColors","infos","provideColorPresentations","getColorPresentations","presentations","presentation","FoldingRangeAdapter","provideFoldingRanges","getFoldingRanges","ranges","toFoldingRangeKind","Comment","Imports","Region","ParseOptions","SelectionRangeAdapter","provideSelectionRanges","positions","getSelectionRanges","selectionRanges","createScanner","ignoreTrivia","len","pos","tokenOffset","lineStartOffset","tokenLineStartOffset","prevTokenLineStartOffset","scanError","scanHexDigits","count","exact","digits","charCodeAt","setPosition","newPosition","scanNumber","isDigit","scanString","isLineBreak","ch2","ch3","fromCharCode","scanNext","isWhiteSpace","safeLength","commentClosed","isUnknownContentCharacter","scanNextNonTrivia","getPosition","scan","getToken","getTokenValue","getTokenOffset","getTokenLength","getTokenStartLine","getTokenStartCharacter","getTokenError","DEFAULT","allowTrailingComma","createTokenizationSupport","supportComments","getInitialState","JSONState","tokenize","state","offsetDelta","stopAtOffset","TOKEN_DELIM_OBJECT","TOKEN_DELIM_ARRAY","TOKEN_DELIM_COLON","TOKEN_DELIM_COMMA","TOKEN_VALUE_BOOLEAN","TOKEN_VALUE_NULL","TOKEN_VALUE_STRING","TOKEN_VALUE_NUMBER","TOKEN_PROPERTY_NAME","TOKEN_COMMENT_BLOCK","TOKEN_COMMENT_LINE","ParentsStack","type","pop","parents","equals","lastWasColon","_state","clone","other","getStateData","setStateData","comments","numberOfInsertedCharacters","adjustOffset","scanner","tokens","endState","substr","currentParent","inArray","startIndex","scopes","setupMode","disposables","providers","uris","apply","registerProviders","modeConfiguration","disposeAll","documentFormattingEdits","registerDocumentFormattingEditProvider","documentRangeFormattingEdits","registerDocumentRangeFormattingEditProvider","completionItems","registerCompletionItemProvider","hovers","registerHoverProvider","documentSymbols","registerDocumentSymbolProvider","setTokensProvider","colors","registerColorProvider","foldingRanges","registerFoldingRangeProvider","registerSelectionRangeProvider","setLanguageConfiguration","richEditConfiguration","newDefaults","asDisposable","wordPattern","lineComment","blockComment","brackets","autoClosingPairs","open","close","notIn"],"mappings":"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","file":"js/chunk-2d0c1ed0.7fc4eb72.js","sourcesContent":["/* --------------------------------------------------------------------------------------------\n * Copyright (c) Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See License.txt in the project root for license information.\n * ------------------------------------------------------------------------------------------ */\n'use strict';\nexport var integer;\n(function (integer) {\n    integer.MIN_VALUE = -2147483648;\n    integer.MAX_VALUE = 2147483647;\n})(integer || (integer = {}));\nexport var uinteger;\n(function (uinteger) {\n    uinteger.MIN_VALUE = 0;\n    uinteger.MAX_VALUE = 2147483647;\n})(uinteger || (uinteger = {}));\n/**\n * The Position namespace provides helper functions to work with\n * [Position](#Position) literals.\n */\nexport var Position;\n(function (Position) {\n    /**\n     * Creates a new Position literal from the given line and character.\n     * @param line The position's line.\n     * @param character The position's character.\n     */\n    function create(line, character) {\n        if (line === Number.MAX_VALUE) {\n            line = uinteger.MAX_VALUE;\n        }\n        if (character === Number.MAX_VALUE) {\n            character = uinteger.MAX_VALUE;\n        }\n        return { line: line, character: character };\n    }\n    Position.create = create;\n    /**\n     * Checks whether the given literal conforms to the [Position](#Position) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.objectLiteral(candidate) && Is.uinteger(candidate.line) && Is.uinteger(candidate.character);\n    }\n    Position.is = is;\n})(Position || (Position = {}));\n/**\n * The Range namespace provides helper functions to work with\n * [Range](#Range) literals.\n */\nexport var Range;\n(function (Range) {\n    function create(one, two, three, four) {\n        if (Is.uinteger(one) && Is.uinteger(two) && Is.uinteger(three) && Is.uinteger(four)) {\n            return { start: Position.create(one, two), end: Position.create(three, four) };\n        }\n        else if (Position.is(one) && Position.is(two)) {\n            return { start: one, end: two };\n        }\n        else {\n            throw new Error(\"Range#create called with invalid arguments[\" + one + \", \" + two + \", \" + three + \", \" + four + \"]\");\n        }\n    }\n    Range.create = create;\n    /**\n     * Checks whether the given literal conforms to the [Range](#Range) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.objectLiteral(candidate) && Position.is(candidate.start) && Position.is(candidate.end);\n    }\n    Range.is = is;\n})(Range || (Range = {}));\n/**\n * The Location namespace provides helper functions to work with\n * [Location](#Location) literals.\n */\nexport var Location;\n(function (Location) {\n    /**\n     * Creates a Location literal.\n     * @param uri The location's uri.\n     * @param range The location's range.\n     */\n    function create(uri, range) {\n        return { uri: uri, range: range };\n    }\n    Location.create = create;\n    /**\n     * Checks whether the given literal conforms to the [Location](#Location) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Range.is(candidate.range) && (Is.string(candidate.uri) || Is.undefined(candidate.uri));\n    }\n    Location.is = is;\n})(Location || (Location = {}));\n/**\n * The LocationLink namespace provides helper functions to work with\n * [LocationLink](#LocationLink) literals.\n */\nexport var LocationLink;\n(function (LocationLink) {\n    /**\n     * Creates a LocationLink literal.\n     * @param targetUri The definition's uri.\n     * @param targetRange The full range of the definition.\n     * @param targetSelectionRange The span of the symbol definition at the target.\n     * @param originSelectionRange The span of the symbol being defined in the originating source file.\n     */\n    function create(targetUri, targetRange, targetSelectionRange, originSelectionRange) {\n        return { targetUri: targetUri, targetRange: targetRange, targetSelectionRange: targetSelectionRange, originSelectionRange: originSelectionRange };\n    }\n    LocationLink.create = create;\n    /**\n     * Checks whether the given literal conforms to the [LocationLink](#LocationLink) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Range.is(candidate.targetRange) && Is.string(candidate.targetUri)\n            && (Range.is(candidate.targetSelectionRange) || Is.undefined(candidate.targetSelectionRange))\n            && (Range.is(candidate.originSelectionRange) || Is.undefined(candidate.originSelectionRange));\n    }\n    LocationLink.is = is;\n})(LocationLink || (LocationLink = {}));\n/**\n * The Color namespace provides helper functions to work with\n * [Color](#Color) literals.\n */\nexport var Color;\n(function (Color) {\n    /**\n     * Creates a new Color literal.\n     */\n    function create(red, green, blue, alpha) {\n        return {\n            red: red,\n            green: green,\n            blue: blue,\n            alpha: alpha,\n        };\n    }\n    Color.create = create;\n    /**\n     * Checks whether the given literal conforms to the [Color](#Color) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.numberRange(candidate.red, 0, 1)\n            && Is.numberRange(candidate.green, 0, 1)\n            && Is.numberRange(candidate.blue, 0, 1)\n            && Is.numberRange(candidate.alpha, 0, 1);\n    }\n    Color.is = is;\n})(Color || (Color = {}));\n/**\n * The ColorInformation namespace provides helper functions to work with\n * [ColorInformation](#ColorInformation) literals.\n */\nexport var ColorInformation;\n(function (ColorInformation) {\n    /**\n     * Creates a new ColorInformation literal.\n     */\n    function create(range, color) {\n        return {\n            range: range,\n            color: color,\n        };\n    }\n    ColorInformation.create = create;\n    /**\n     * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Range.is(candidate.range) && Color.is(candidate.color);\n    }\n    ColorInformation.is = is;\n})(ColorInformation || (ColorInformation = {}));\n/**\n * The Color namespace provides helper functions to work with\n * [ColorPresentation](#ColorPresentation) literals.\n */\nexport var ColorPresentation;\n(function (ColorPresentation) {\n    /**\n     * Creates a new ColorInformation literal.\n     */\n    function create(label, textEdit, additionalTextEdits) {\n        return {\n            label: label,\n            textEdit: textEdit,\n            additionalTextEdits: additionalTextEdits,\n        };\n    }\n    ColorPresentation.create = create;\n    /**\n     * Checks whether the given literal conforms to the [ColorInformation](#ColorInformation) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.string(candidate.label)\n            && (Is.undefined(candidate.textEdit) || TextEdit.is(candidate))\n            && (Is.undefined(candidate.additionalTextEdits) || Is.typedArray(candidate.additionalTextEdits, TextEdit.is));\n    }\n    ColorPresentation.is = is;\n})(ColorPresentation || (ColorPresentation = {}));\n/**\n * Enum of known range kinds\n */\nexport var FoldingRangeKind;\n(function (FoldingRangeKind) {\n    /**\n     * Folding range for a comment\n     */\n    FoldingRangeKind[\"Comment\"] = \"comment\";\n    /**\n     * Folding range for a imports or includes\n     */\n    FoldingRangeKind[\"Imports\"] = \"imports\";\n    /**\n     * Folding range for a region (e.g. `#region`)\n     */\n    FoldingRangeKind[\"Region\"] = \"region\";\n})(FoldingRangeKind || (FoldingRangeKind = {}));\n/**\n * The folding range namespace provides helper functions to work with\n * [FoldingRange](#FoldingRange) literals.\n */\nexport var FoldingRange;\n(function (FoldingRange) {\n    /**\n     * Creates a new FoldingRange literal.\n     */\n    function create(startLine, endLine, startCharacter, endCharacter, kind) {\n        var result = {\n            startLine: startLine,\n            endLine: endLine\n        };\n        if (Is.defined(startCharacter)) {\n            result.startCharacter = startCharacter;\n        }\n        if (Is.defined(endCharacter)) {\n            result.endCharacter = endCharacter;\n        }\n        if (Is.defined(kind)) {\n            result.kind = kind;\n        }\n        return result;\n    }\n    FoldingRange.create = create;\n    /**\n     * Checks whether the given literal conforms to the [FoldingRange](#FoldingRange) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.uinteger(candidate.startLine) && Is.uinteger(candidate.startLine)\n            && (Is.undefined(candidate.startCharacter) || Is.uinteger(candidate.startCharacter))\n            && (Is.undefined(candidate.endCharacter) || Is.uinteger(candidate.endCharacter))\n            && (Is.undefined(candidate.kind) || Is.string(candidate.kind));\n    }\n    FoldingRange.is = is;\n})(FoldingRange || (FoldingRange = {}));\n/**\n * The DiagnosticRelatedInformation namespace provides helper functions to work with\n * [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) literals.\n */\nexport var DiagnosticRelatedInformation;\n(function (DiagnosticRelatedInformation) {\n    /**\n     * Creates a new DiagnosticRelatedInformation literal.\n     */\n    function create(location, message) {\n        return {\n            location: location,\n            message: message\n        };\n    }\n    DiagnosticRelatedInformation.create = create;\n    /**\n     * Checks whether the given literal conforms to the [DiagnosticRelatedInformation](#DiagnosticRelatedInformation) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Location.is(candidate.location) && Is.string(candidate.message);\n    }\n    DiagnosticRelatedInformation.is = is;\n})(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));\n/**\n * The diagnostic's severity.\n */\nexport var DiagnosticSeverity;\n(function (DiagnosticSeverity) {\n    /**\n     * Reports an error.\n     */\n    DiagnosticSeverity.Error = 1;\n    /**\n     * Reports a warning.\n     */\n    DiagnosticSeverity.Warning = 2;\n    /**\n     * Reports an information.\n     */\n    DiagnosticSeverity.Information = 3;\n    /**\n     * Reports a hint.\n     */\n    DiagnosticSeverity.Hint = 4;\n})(DiagnosticSeverity || (DiagnosticSeverity = {}));\n/**\n * The diagnostic tags.\n *\n * @since 3.15.0\n */\nexport var DiagnosticTag;\n(function (DiagnosticTag) {\n    /**\n     * Unused or unnecessary code.\n     *\n     * Clients are allowed to render diagnostics with this tag faded out instead of having\n     * an error squiggle.\n     */\n    DiagnosticTag.Unnecessary = 1;\n    /**\n     * Deprecated or obsolete code.\n     *\n     * Clients are allowed to rendered diagnostics with this tag strike through.\n     */\n    DiagnosticTag.Deprecated = 2;\n})(DiagnosticTag || (DiagnosticTag = {}));\n/**\n * The CodeDescription namespace provides functions to deal with descriptions for diagnostic codes.\n *\n * @since 3.16.0\n */\nexport var CodeDescription;\n(function (CodeDescription) {\n    function is(value) {\n        var candidate = value;\n        return candidate !== undefined && candidate !== null && Is.string(candidate.href);\n    }\n    CodeDescription.is = is;\n})(CodeDescription || (CodeDescription = {}));\n/**\n * The Diagnostic namespace provides helper functions to work with\n * [Diagnostic](#Diagnostic) literals.\n */\nexport var Diagnostic;\n(function (Diagnostic) {\n    /**\n     * Creates a new Diagnostic literal.\n     */\n    function create(range, message, severity, code, source, relatedInformation) {\n        var result = { range: range, message: message };\n        if (Is.defined(severity)) {\n            result.severity = severity;\n        }\n        if (Is.defined(code)) {\n            result.code = code;\n        }\n        if (Is.defined(source)) {\n            result.source = source;\n        }\n        if (Is.defined(relatedInformation)) {\n            result.relatedInformation = relatedInformation;\n        }\n        return result;\n    }\n    Diagnostic.create = create;\n    /**\n     * Checks whether the given literal conforms to the [Diagnostic](#Diagnostic) interface.\n     */\n    function is(value) {\n        var _a;\n        var candidate = value;\n        return Is.defined(candidate)\n            && Range.is(candidate.range)\n            && Is.string(candidate.message)\n            && (Is.number(candidate.severity) || Is.undefined(candidate.severity))\n            && (Is.integer(candidate.code) || Is.string(candidate.code) || Is.undefined(candidate.code))\n            && (Is.undefined(candidate.codeDescription) || (Is.string((_a = candidate.codeDescription) === null || _a === void 0 ? void 0 : _a.href)))\n            && (Is.string(candidate.source) || Is.undefined(candidate.source))\n            && (Is.undefined(candidate.relatedInformation) || Is.typedArray(candidate.relatedInformation, DiagnosticRelatedInformation.is));\n    }\n    Diagnostic.is = is;\n})(Diagnostic || (Diagnostic = {}));\n/**\n * The Command namespace provides helper functions to work with\n * [Command](#Command) literals.\n */\nexport var Command;\n(function (Command) {\n    /**\n     * Creates a new Command literal.\n     */\n    function create(title, command) {\n        var args = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            args[_i - 2] = arguments[_i];\n        }\n        var result = { title: title, command: command };\n        if (Is.defined(args) && args.length > 0) {\n            result.arguments = args;\n        }\n        return result;\n    }\n    Command.create = create;\n    /**\n     * Checks whether the given literal conforms to the [Command](#Command) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);\n    }\n    Command.is = is;\n})(Command || (Command = {}));\n/**\n * The TextEdit namespace provides helper function to create replace,\n * insert and delete edits more easily.\n */\nexport var TextEdit;\n(function (TextEdit) {\n    /**\n     * Creates a replace text edit.\n     * @param range The range of text to be replaced.\n     * @param newText The new text.\n     */\n    function replace(range, newText) {\n        return { range: range, newText: newText };\n    }\n    TextEdit.replace = replace;\n    /**\n     * Creates a insert text edit.\n     * @param position The position to insert the text at.\n     * @param newText The text to be inserted.\n     */\n    function insert(position, newText) {\n        return { range: { start: position, end: position }, newText: newText };\n    }\n    TextEdit.insert = insert;\n    /**\n     * Creates a delete text edit.\n     * @param range The range of text to be deleted.\n     */\n    function del(range) {\n        return { range: range, newText: '' };\n    }\n    TextEdit.del = del;\n    function is(value) {\n        var candidate = value;\n        return Is.objectLiteral(candidate)\n            && Is.string(candidate.newText)\n            && Range.is(candidate.range);\n    }\n    TextEdit.is = is;\n})(TextEdit || (TextEdit = {}));\nexport var ChangeAnnotation;\n(function (ChangeAnnotation) {\n    function create(label, needsConfirmation, description) {\n        var result = { label: label };\n        if (needsConfirmation !== undefined) {\n            result.needsConfirmation = needsConfirmation;\n        }\n        if (description !== undefined) {\n            result.description = description;\n        }\n        return result;\n    }\n    ChangeAnnotation.create = create;\n    function is(value) {\n        var candidate = value;\n        return candidate !== undefined && Is.objectLiteral(candidate) && Is.string(candidate.label) &&\n            (Is.boolean(candidate.needsConfirmation) || candidate.needsConfirmation === undefined) &&\n            (Is.string(candidate.description) || candidate.description === undefined);\n    }\n    ChangeAnnotation.is = is;\n})(ChangeAnnotation || (ChangeAnnotation = {}));\nexport var ChangeAnnotationIdentifier;\n(function (ChangeAnnotationIdentifier) {\n    function is(value) {\n        var candidate = value;\n        return typeof candidate === 'string';\n    }\n    ChangeAnnotationIdentifier.is = is;\n})(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));\nexport var AnnotatedTextEdit;\n(function (AnnotatedTextEdit) {\n    /**\n     * Creates an annotated replace text edit.\n     *\n     * @param range The range of text to be replaced.\n     * @param newText The new text.\n     * @param annotation The annotation.\n     */\n    function replace(range, newText, annotation) {\n        return { range: range, newText: newText, annotationId: annotation };\n    }\n    AnnotatedTextEdit.replace = replace;\n    /**\n     * Creates an annotated insert text edit.\n     *\n     * @param position The position to insert the text at.\n     * @param newText The text to be inserted.\n     * @param annotation The annotation.\n     */\n    function insert(position, newText, annotation) {\n        return { range: { start: position, end: position }, newText: newText, annotationId: annotation };\n    }\n    AnnotatedTextEdit.insert = insert;\n    /**\n     * Creates an annotated delete text edit.\n     *\n     * @param range The range of text to be deleted.\n     * @param annotation The annotation.\n     */\n    function del(range, annotation) {\n        return { range: range, newText: '', annotationId: annotation };\n    }\n    AnnotatedTextEdit.del = del;\n    function is(value) {\n        var candidate = value;\n        return TextEdit.is(candidate) && (ChangeAnnotation.is(candidate.annotationId) || ChangeAnnotationIdentifier.is(candidate.annotationId));\n    }\n    AnnotatedTextEdit.is = is;\n})(AnnotatedTextEdit || (AnnotatedTextEdit = {}));\n/**\n * The TextDocumentEdit namespace provides helper function to create\n * an edit that manipulates a text document.\n */\nexport var TextDocumentEdit;\n(function (TextDocumentEdit) {\n    /**\n     * Creates a new `TextDocumentEdit`\n     */\n    function create(textDocument, edits) {\n        return { textDocument: textDocument, edits: edits };\n    }\n    TextDocumentEdit.create = create;\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate)\n            && OptionalVersionedTextDocumentIdentifier.is(candidate.textDocument)\n            && Array.isArray(candidate.edits);\n    }\n    TextDocumentEdit.is = is;\n})(TextDocumentEdit || (TextDocumentEdit = {}));\nexport var CreateFile;\n(function (CreateFile) {\n    function create(uri, options, annotation) {\n        var result = {\n            kind: 'create',\n            uri: uri\n        };\n        if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {\n            result.options = options;\n        }\n        if (annotation !== undefined) {\n            result.annotationId = annotation;\n        }\n        return result;\n    }\n    CreateFile.create = create;\n    function is(value) {\n        var candidate = value;\n        return candidate && candidate.kind === 'create' && Is.string(candidate.uri) && (candidate.options === undefined ||\n            ((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));\n    }\n    CreateFile.is = is;\n})(CreateFile || (CreateFile = {}));\nexport var RenameFile;\n(function (RenameFile) {\n    function create(oldUri, newUri, options, annotation) {\n        var result = {\n            kind: 'rename',\n            oldUri: oldUri,\n            newUri: newUri\n        };\n        if (options !== undefined && (options.overwrite !== undefined || options.ignoreIfExists !== undefined)) {\n            result.options = options;\n        }\n        if (annotation !== undefined) {\n            result.annotationId = annotation;\n        }\n        return result;\n    }\n    RenameFile.create = create;\n    function is(value) {\n        var candidate = value;\n        return candidate && candidate.kind === 'rename' && Is.string(candidate.oldUri) && Is.string(candidate.newUri) && (candidate.options === undefined ||\n            ((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));\n    }\n    RenameFile.is = is;\n})(RenameFile || (RenameFile = {}));\nexport var DeleteFile;\n(function (DeleteFile) {\n    function create(uri, options, annotation) {\n        var result = {\n            kind: 'delete',\n            uri: uri\n        };\n        if (options !== undefined && (options.recursive !== undefined || options.ignoreIfNotExists !== undefined)) {\n            result.options = options;\n        }\n        if (annotation !== undefined) {\n            result.annotationId = annotation;\n        }\n        return result;\n    }\n    DeleteFile.create = create;\n    function is(value) {\n        var candidate = value;\n        return candidate && candidate.kind === 'delete' && Is.string(candidate.uri) && (candidate.options === undefined ||\n            ((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));\n    }\n    DeleteFile.is = is;\n})(DeleteFile || (DeleteFile = {}));\nexport var WorkspaceEdit;\n(function (WorkspaceEdit) {\n    function is(value) {\n        var candidate = value;\n        return candidate &&\n            (candidate.changes !== undefined || candidate.documentChanges !== undefined) &&\n            (candidate.documentChanges === undefined || candidate.documentChanges.every(function (change) {\n                if (Is.string(change.kind)) {\n                    return CreateFile.is(change) || RenameFile.is(change) || DeleteFile.is(change);\n                }\n                else {\n                    return TextDocumentEdit.is(change);\n                }\n            }));\n    }\n    WorkspaceEdit.is = is;\n})(WorkspaceEdit || (WorkspaceEdit = {}));\nvar TextEditChangeImpl = /** @class */ (function () {\n    function TextEditChangeImpl(edits, changeAnnotations) {\n        this.edits = edits;\n        this.changeAnnotations = changeAnnotations;\n    }\n    TextEditChangeImpl.prototype.insert = function (position, newText, annotation) {\n        var edit;\n        var id;\n        if (annotation === undefined) {\n            edit = TextEdit.insert(position, newText);\n        }\n        else if (ChangeAnnotationIdentifier.is(annotation)) {\n            id = annotation;\n            edit = AnnotatedTextEdit.insert(position, newText, annotation);\n        }\n        else {\n            this.assertChangeAnnotations(this.changeAnnotations);\n            id = this.changeAnnotations.manage(annotation);\n            edit = AnnotatedTextEdit.insert(position, newText, id);\n        }\n        this.edits.push(edit);\n        if (id !== undefined) {\n            return id;\n        }\n    };\n    TextEditChangeImpl.prototype.replace = function (range, newText, annotation) {\n        var edit;\n        var id;\n        if (annotation === undefined) {\n            edit = TextEdit.replace(range, newText);\n        }\n        else if (ChangeAnnotationIdentifier.is(annotation)) {\n            id = annotation;\n            edit = AnnotatedTextEdit.replace(range, newText, annotation);\n        }\n        else {\n            this.assertChangeAnnotations(this.changeAnnotations);\n            id = this.changeAnnotations.manage(annotation);\n            edit = AnnotatedTextEdit.replace(range, newText, id);\n        }\n        this.edits.push(edit);\n        if (id !== undefined) {\n            return id;\n        }\n    };\n    TextEditChangeImpl.prototype.delete = function (range, annotation) {\n        var edit;\n        var id;\n        if (annotation === undefined) {\n            edit = TextEdit.del(range);\n        }\n        else if (ChangeAnnotationIdentifier.is(annotation)) {\n            id = annotation;\n            edit = AnnotatedTextEdit.del(range, annotation);\n        }\n        else {\n            this.assertChangeAnnotations(this.changeAnnotations);\n            id = this.changeAnnotations.manage(annotation);\n            edit = AnnotatedTextEdit.del(range, id);\n        }\n        this.edits.push(edit);\n        if (id !== undefined) {\n            return id;\n        }\n    };\n    TextEditChangeImpl.prototype.add = function (edit) {\n        this.edits.push(edit);\n    };\n    TextEditChangeImpl.prototype.all = function () {\n        return this.edits;\n    };\n    TextEditChangeImpl.prototype.clear = function () {\n        this.edits.splice(0, this.edits.length);\n    };\n    TextEditChangeImpl.prototype.assertChangeAnnotations = function (value) {\n        if (value === undefined) {\n            throw new Error(\"Text edit change is not configured to manage change annotations.\");\n        }\n    };\n    return TextEditChangeImpl;\n}());\n/**\n * A helper class\n */\nvar ChangeAnnotations = /** @class */ (function () {\n    function ChangeAnnotations(annotations) {\n        this._annotations = annotations === undefined ? Object.create(null) : annotations;\n        this._counter = 0;\n        this._size = 0;\n    }\n    ChangeAnnotations.prototype.all = function () {\n        return this._annotations;\n    };\n    Object.defineProperty(ChangeAnnotations.prototype, \"size\", {\n        get: function () {\n            return this._size;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    ChangeAnnotations.prototype.manage = function (idOrAnnotation, annotation) {\n        var id;\n        if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {\n            id = idOrAnnotation;\n        }\n        else {\n            id = this.nextId();\n            annotation = idOrAnnotation;\n        }\n        if (this._annotations[id] !== undefined) {\n            throw new Error(\"Id \" + id + \" is already in use.\");\n        }\n        if (annotation === undefined) {\n            throw new Error(\"No annotation provided for id \" + id);\n        }\n        this._annotations[id] = annotation;\n        this._size++;\n        return id;\n    };\n    ChangeAnnotations.prototype.nextId = function () {\n        this._counter++;\n        return this._counter.toString();\n    };\n    return ChangeAnnotations;\n}());\n/**\n * A workspace change helps constructing changes to a workspace.\n */\nvar WorkspaceChange = /** @class */ (function () {\n    function WorkspaceChange(workspaceEdit) {\n        var _this = this;\n        this._textEditChanges = Object.create(null);\n        if (workspaceEdit !== undefined) {\n            this._workspaceEdit = workspaceEdit;\n            if (workspaceEdit.documentChanges) {\n                this._changeAnnotations = new ChangeAnnotations(workspaceEdit.changeAnnotations);\n                workspaceEdit.changeAnnotations = this._changeAnnotations.all();\n                workspaceEdit.documentChanges.forEach(function (change) {\n                    if (TextDocumentEdit.is(change)) {\n                        var textEditChange = new TextEditChangeImpl(change.edits, _this._changeAnnotations);\n                        _this._textEditChanges[change.textDocument.uri] = textEditChange;\n                    }\n                });\n            }\n            else if (workspaceEdit.changes) {\n                Object.keys(workspaceEdit.changes).forEach(function (key) {\n                    var textEditChange = new TextEditChangeImpl(workspaceEdit.changes[key]);\n                    _this._textEditChanges[key] = textEditChange;\n                });\n            }\n        }\n        else {\n            this._workspaceEdit = {};\n        }\n    }\n    Object.defineProperty(WorkspaceChange.prototype, \"edit\", {\n        /**\n         * Returns the underlying [WorkspaceEdit](#WorkspaceEdit) literal\n         * use to be returned from a workspace edit operation like rename.\n         */\n        get: function () {\n            this.initDocumentChanges();\n            if (this._changeAnnotations !== undefined) {\n                if (this._changeAnnotations.size === 0) {\n                    this._workspaceEdit.changeAnnotations = undefined;\n                }\n                else {\n                    this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();\n                }\n            }\n            return this._workspaceEdit;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    WorkspaceChange.prototype.getTextEditChange = function (key) {\n        if (OptionalVersionedTextDocumentIdentifier.is(key)) {\n            this.initDocumentChanges();\n            if (this._workspaceEdit.documentChanges === undefined) {\n                throw new Error('Workspace edit is not configured for document changes.');\n            }\n            var textDocument = { uri: key.uri, version: key.version };\n            var result = this._textEditChanges[textDocument.uri];\n            if (!result) {\n                var edits = [];\n                var textDocumentEdit = {\n                    textDocument: textDocument,\n                    edits: edits\n                };\n                this._workspaceEdit.documentChanges.push(textDocumentEdit);\n                result = new TextEditChangeImpl(edits, this._changeAnnotations);\n                this._textEditChanges[textDocument.uri] = result;\n            }\n            return result;\n        }\n        else {\n            this.initChanges();\n            if (this._workspaceEdit.changes === undefined) {\n                throw new Error('Workspace edit is not configured for normal text edit changes.');\n            }\n            var result = this._textEditChanges[key];\n            if (!result) {\n                var edits = [];\n                this._workspaceEdit.changes[key] = edits;\n                result = new TextEditChangeImpl(edits);\n                this._textEditChanges[key] = result;\n            }\n            return result;\n        }\n    };\n    WorkspaceChange.prototype.initDocumentChanges = function () {\n        if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {\n            this._changeAnnotations = new ChangeAnnotations();\n            this._workspaceEdit.documentChanges = [];\n            this._workspaceEdit.changeAnnotations = this._changeAnnotations.all();\n        }\n    };\n    WorkspaceChange.prototype.initChanges = function () {\n        if (this._workspaceEdit.documentChanges === undefined && this._workspaceEdit.changes === undefined) {\n            this._workspaceEdit.changes = Object.create(null);\n        }\n    };\n    WorkspaceChange.prototype.createFile = function (uri, optionsOrAnnotation, options) {\n        this.initDocumentChanges();\n        if (this._workspaceEdit.documentChanges === undefined) {\n            throw new Error('Workspace edit is not configured for document changes.');\n        }\n        var annotation;\n        if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {\n            annotation = optionsOrAnnotation;\n        }\n        else {\n            options = optionsOrAnnotation;\n        }\n        var operation;\n        var id;\n        if (annotation === undefined) {\n            operation = CreateFile.create(uri, options);\n        }\n        else {\n            id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);\n            operation = CreateFile.create(uri, options, id);\n        }\n        this._workspaceEdit.documentChanges.push(operation);\n        if (id !== undefined) {\n            return id;\n        }\n    };\n    WorkspaceChange.prototype.renameFile = function (oldUri, newUri, optionsOrAnnotation, options) {\n        this.initDocumentChanges();\n        if (this._workspaceEdit.documentChanges === undefined) {\n            throw new Error('Workspace edit is not configured for document changes.');\n        }\n        var annotation;\n        if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {\n            annotation = optionsOrAnnotation;\n        }\n        else {\n            options = optionsOrAnnotation;\n        }\n        var operation;\n        var id;\n        if (annotation === undefined) {\n            operation = RenameFile.create(oldUri, newUri, options);\n        }\n        else {\n            id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);\n            operation = RenameFile.create(oldUri, newUri, options, id);\n        }\n        this._workspaceEdit.documentChanges.push(operation);\n        if (id !== undefined) {\n            return id;\n        }\n    };\n    WorkspaceChange.prototype.deleteFile = function (uri, optionsOrAnnotation, options) {\n        this.initDocumentChanges();\n        if (this._workspaceEdit.documentChanges === undefined) {\n            throw new Error('Workspace edit is not configured for document changes.');\n        }\n        var annotation;\n        if (ChangeAnnotation.is(optionsOrAnnotation) || ChangeAnnotationIdentifier.is(optionsOrAnnotation)) {\n            annotation = optionsOrAnnotation;\n        }\n        else {\n            options = optionsOrAnnotation;\n        }\n        var operation;\n        var id;\n        if (annotation === undefined) {\n            operation = DeleteFile.create(uri, options);\n        }\n        else {\n            id = ChangeAnnotationIdentifier.is(annotation) ? annotation : this._changeAnnotations.manage(annotation);\n            operation = DeleteFile.create(uri, options, id);\n        }\n        this._workspaceEdit.documentChanges.push(operation);\n        if (id !== undefined) {\n            return id;\n        }\n    };\n    return WorkspaceChange;\n}());\nexport { WorkspaceChange };\n/**\n * The TextDocumentIdentifier namespace provides helper functions to work with\n * [TextDocumentIdentifier](#TextDocumentIdentifier) literals.\n */\nexport var TextDocumentIdentifier;\n(function (TextDocumentIdentifier) {\n    /**\n     * Creates a new TextDocumentIdentifier literal.\n     * @param uri The document's uri.\n     */\n    function create(uri) {\n        return { uri: uri };\n    }\n    TextDocumentIdentifier.create = create;\n    /**\n     * Checks whether the given literal conforms to the [TextDocumentIdentifier](#TextDocumentIdentifier) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.uri);\n    }\n    TextDocumentIdentifier.is = is;\n})(TextDocumentIdentifier || (TextDocumentIdentifier = {}));\n/**\n * The VersionedTextDocumentIdentifier namespace provides helper functions to work with\n * [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) literals.\n */\nexport var VersionedTextDocumentIdentifier;\n(function (VersionedTextDocumentIdentifier) {\n    /**\n     * Creates a new VersionedTextDocumentIdentifier literal.\n     * @param uri The document's uri.\n     * @param uri The document's text.\n     */\n    function create(uri, version) {\n        return { uri: uri, version: version };\n    }\n    VersionedTextDocumentIdentifier.create = create;\n    /**\n     * Checks whether the given literal conforms to the [VersionedTextDocumentIdentifier](#VersionedTextDocumentIdentifier) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.uri) && Is.integer(candidate.version);\n    }\n    VersionedTextDocumentIdentifier.is = is;\n})(VersionedTextDocumentIdentifier || (VersionedTextDocumentIdentifier = {}));\n/**\n * The OptionalVersionedTextDocumentIdentifier namespace provides helper functions to work with\n * [OptionalVersionedTextDocumentIdentifier](#OptionalVersionedTextDocumentIdentifier) literals.\n */\nexport var OptionalVersionedTextDocumentIdentifier;\n(function (OptionalVersionedTextDocumentIdentifier) {\n    /**\n     * Creates a new OptionalVersionedTextDocumentIdentifier literal.\n     * @param uri The document's uri.\n     * @param uri The document's text.\n     */\n    function create(uri, version) {\n        return { uri: uri, version: version };\n    }\n    OptionalVersionedTextDocumentIdentifier.create = create;\n    /**\n     * Checks whether the given literal conforms to the [OptionalVersionedTextDocumentIdentifier](#OptionalVersionedTextDocumentIdentifier) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.uri) && (candidate.version === null || Is.integer(candidate.version));\n    }\n    OptionalVersionedTextDocumentIdentifier.is = is;\n})(OptionalVersionedTextDocumentIdentifier || (OptionalVersionedTextDocumentIdentifier = {}));\n/**\n * The TextDocumentItem namespace provides helper functions to work with\n * [TextDocumentItem](#TextDocumentItem) literals.\n */\nexport var TextDocumentItem;\n(function (TextDocumentItem) {\n    /**\n     * Creates a new TextDocumentItem literal.\n     * @param uri The document's uri.\n     * @param languageId The document's language identifier.\n     * @param version The document's version number.\n     * @param text The document's text.\n     */\n    function create(uri, languageId, version, text) {\n        return { uri: uri, languageId: languageId, version: version, text: text };\n    }\n    TextDocumentItem.create = create;\n    /**\n     * Checks whether the given literal conforms to the [TextDocumentItem](#TextDocumentItem) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.uri) && Is.string(candidate.languageId) && Is.integer(candidate.version) && Is.string(candidate.text);\n    }\n    TextDocumentItem.is = is;\n})(TextDocumentItem || (TextDocumentItem = {}));\n/**\n * Describes the content type that a client supports in various\n * result literals like `Hover`, `ParameterInfo` or `CompletionItem`.\n *\n * Please note that `MarkupKinds` must not start with a `$`. This kinds\n * are reserved for internal usage.\n */\nexport var MarkupKind;\n(function (MarkupKind) {\n    /**\n     * Plain text is supported as a content format\n     */\n    MarkupKind.PlainText = 'plaintext';\n    /**\n     * Markdown is supported as a content format\n     */\n    MarkupKind.Markdown = 'markdown';\n})(MarkupKind || (MarkupKind = {}));\n(function (MarkupKind) {\n    /**\n     * Checks whether the given value is a value of the [MarkupKind](#MarkupKind) type.\n     */\n    function is(value) {\n        var candidate = value;\n        return candidate === MarkupKind.PlainText || candidate === MarkupKind.Markdown;\n    }\n    MarkupKind.is = is;\n})(MarkupKind || (MarkupKind = {}));\nexport var MarkupContent;\n(function (MarkupContent) {\n    /**\n     * Checks whether the given value conforms to the [MarkupContent](#MarkupContent) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.objectLiteral(value) && MarkupKind.is(candidate.kind) && Is.string(candidate.value);\n    }\n    MarkupContent.is = is;\n})(MarkupContent || (MarkupContent = {}));\n/**\n * The kind of a completion entry.\n */\nexport var CompletionItemKind;\n(function (CompletionItemKind) {\n    CompletionItemKind.Text = 1;\n    CompletionItemKind.Method = 2;\n    CompletionItemKind.Function = 3;\n    CompletionItemKind.Constructor = 4;\n    CompletionItemKind.Field = 5;\n    CompletionItemKind.Variable = 6;\n    CompletionItemKind.Class = 7;\n    CompletionItemKind.Interface = 8;\n    CompletionItemKind.Module = 9;\n    CompletionItemKind.Property = 10;\n    CompletionItemKind.Unit = 11;\n    CompletionItemKind.Value = 12;\n    CompletionItemKind.Enum = 13;\n    CompletionItemKind.Keyword = 14;\n    CompletionItemKind.Snippet = 15;\n    CompletionItemKind.Color = 16;\n    CompletionItemKind.File = 17;\n    CompletionItemKind.Reference = 18;\n    CompletionItemKind.Folder = 19;\n    CompletionItemKind.EnumMember = 20;\n    CompletionItemKind.Constant = 21;\n    CompletionItemKind.Struct = 22;\n    CompletionItemKind.Event = 23;\n    CompletionItemKind.Operator = 24;\n    CompletionItemKind.TypeParameter = 25;\n})(CompletionItemKind || (CompletionItemKind = {}));\n/**\n * Defines whether the insert text in a completion item should be interpreted as\n * plain text or a snippet.\n */\nexport var InsertTextFormat;\n(function (InsertTextFormat) {\n    /**\n     * The primary text to be inserted is treated as a plain string.\n     */\n    InsertTextFormat.PlainText = 1;\n    /**\n     * The primary text to be inserted is treated as a snippet.\n     *\n     * A snippet can define tab stops and placeholders with `$1`, `$2`\n     * and `${3:foo}`. `$0` defines the final tab stop, it defaults to\n     * the end of the snippet. Placeholders with equal identifiers are linked,\n     * that is typing in one will update others too.\n     *\n     * See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax\n     */\n    InsertTextFormat.Snippet = 2;\n})(InsertTextFormat || (InsertTextFormat = {}));\n/**\n * Completion item tags are extra annotations that tweak the rendering of a completion\n * item.\n *\n * @since 3.15.0\n */\nexport var CompletionItemTag;\n(function (CompletionItemTag) {\n    /**\n     * Render a completion as obsolete, usually using a strike-out.\n     */\n    CompletionItemTag.Deprecated = 1;\n})(CompletionItemTag || (CompletionItemTag = {}));\n/**\n * The InsertReplaceEdit namespace provides functions to deal with insert / replace edits.\n *\n * @since 3.16.0\n */\nexport var InsertReplaceEdit;\n(function (InsertReplaceEdit) {\n    /**\n     * Creates a new insert / replace edit\n     */\n    function create(newText, insert, replace) {\n        return { newText: newText, insert: insert, replace: replace };\n    }\n    InsertReplaceEdit.create = create;\n    /**\n     * Checks whether the given literal conforms to the [InsertReplaceEdit](#InsertReplaceEdit) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return candidate && Is.string(candidate.newText) && Range.is(candidate.insert) && Range.is(candidate.replace);\n    }\n    InsertReplaceEdit.is = is;\n})(InsertReplaceEdit || (InsertReplaceEdit = {}));\n/**\n * How whitespace and indentation is handled during completion\n * item insertion.\n *\n * @since 3.16.0\n */\nexport var InsertTextMode;\n(function (InsertTextMode) {\n    /**\n     * The insertion or replace strings is taken as it is. If the\n     * value is multi line the lines below the cursor will be\n     * inserted using the indentation defined in the string value.\n     * The client will not apply any kind of adjustments to the\n     * string.\n     */\n    InsertTextMode.asIs = 1;\n    /**\n     * The editor adjusts leading whitespace of new lines so that\n     * they match the indentation up to the cursor of the line for\n     * which the item is accepted.\n     *\n     * Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a\n     * multi line completion item is indented using 2 tabs and all\n     * following lines inserted will be indented using 2 tabs as well.\n     */\n    InsertTextMode.adjustIndentation = 2;\n})(InsertTextMode || (InsertTextMode = {}));\n/**\n * The CompletionItem namespace provides functions to deal with\n * completion items.\n */\nexport var CompletionItem;\n(function (CompletionItem) {\n    /**\n     * Create a completion item and seed it with a label.\n     * @param label The completion item's label\n     */\n    function create(label) {\n        return { label: label };\n    }\n    CompletionItem.create = create;\n})(CompletionItem || (CompletionItem = {}));\n/**\n * The CompletionList namespace provides functions to deal with\n * completion lists.\n */\nexport var CompletionList;\n(function (CompletionList) {\n    /**\n     * Creates a new completion list.\n     *\n     * @param items The completion items.\n     * @param isIncomplete The list is not complete.\n     */\n    function create(items, isIncomplete) {\n        return { items: items ? items : [], isIncomplete: !!isIncomplete };\n    }\n    CompletionList.create = create;\n})(CompletionList || (CompletionList = {}));\nexport var MarkedString;\n(function (MarkedString) {\n    /**\n     * Creates a marked string from plain text.\n     *\n     * @param plainText The plain text.\n     */\n    function fromPlainText(plainText) {\n        return plainText.replace(/[\\\\`*_{}[\\]()#+\\-.!]/g, '\\\\$&'); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash\n    }\n    MarkedString.fromPlainText = fromPlainText;\n    /**\n     * Checks whether the given value conforms to the [MarkedString](#MarkedString) type.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.string(candidate) || (Is.objectLiteral(candidate) && Is.string(candidate.language) && Is.string(candidate.value));\n    }\n    MarkedString.is = is;\n})(MarkedString || (MarkedString = {}));\nexport var Hover;\n(function (Hover) {\n    /**\n     * Checks whether the given value conforms to the [Hover](#Hover) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return !!candidate && Is.objectLiteral(candidate) && (MarkupContent.is(candidate.contents) ||\n            MarkedString.is(candidate.contents) ||\n            Is.typedArray(candidate.contents, MarkedString.is)) && (value.range === undefined || Range.is(value.range));\n    }\n    Hover.is = is;\n})(Hover || (Hover = {}));\n/**\n * The ParameterInformation namespace provides helper functions to work with\n * [ParameterInformation](#ParameterInformation) literals.\n */\nexport var ParameterInformation;\n(function (ParameterInformation) {\n    /**\n     * Creates a new parameter information literal.\n     *\n     * @param label A label string.\n     * @param documentation A doc string.\n     */\n    function create(label, documentation) {\n        return documentation ? { label: label, documentation: documentation } : { label: label };\n    }\n    ParameterInformation.create = create;\n})(ParameterInformation || (ParameterInformation = {}));\n/**\n * The SignatureInformation namespace provides helper functions to work with\n * [SignatureInformation](#SignatureInformation) literals.\n */\nexport var SignatureInformation;\n(function (SignatureInformation) {\n    function create(label, documentation) {\n        var parameters = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            parameters[_i - 2] = arguments[_i];\n        }\n        var result = { label: label };\n        if (Is.defined(documentation)) {\n            result.documentation = documentation;\n        }\n        if (Is.defined(parameters)) {\n            result.parameters = parameters;\n        }\n        else {\n            result.parameters = [];\n        }\n        return result;\n    }\n    SignatureInformation.create = create;\n})(SignatureInformation || (SignatureInformation = {}));\n/**\n * A document highlight kind.\n */\nexport var DocumentHighlightKind;\n(function (DocumentHighlightKind) {\n    /**\n     * A textual occurrence.\n     */\n    DocumentHighlightKind.Text = 1;\n    /**\n     * Read-access of a symbol, like reading a variable.\n     */\n    DocumentHighlightKind.Read = 2;\n    /**\n     * Write-access of a symbol, like writing to a variable.\n     */\n    DocumentHighlightKind.Write = 3;\n})(DocumentHighlightKind || (DocumentHighlightKind = {}));\n/**\n * DocumentHighlight namespace to provide helper functions to work with\n * [DocumentHighlight](#DocumentHighlight) literals.\n */\nexport var DocumentHighlight;\n(function (DocumentHighlight) {\n    /**\n     * Create a DocumentHighlight object.\n     * @param range The range the highlight applies to.\n     */\n    function create(range, kind) {\n        var result = { range: range };\n        if (Is.number(kind)) {\n            result.kind = kind;\n        }\n        return result;\n    }\n    DocumentHighlight.create = create;\n})(DocumentHighlight || (DocumentHighlight = {}));\n/**\n * A symbol kind.\n */\nexport var SymbolKind;\n(function (SymbolKind) {\n    SymbolKind.File = 1;\n    SymbolKind.Module = 2;\n    SymbolKind.Namespace = 3;\n    SymbolKind.Package = 4;\n    SymbolKind.Class = 5;\n    SymbolKind.Method = 6;\n    SymbolKind.Property = 7;\n    SymbolKind.Field = 8;\n    SymbolKind.Constructor = 9;\n    SymbolKind.Enum = 10;\n    SymbolKind.Interface = 11;\n    SymbolKind.Function = 12;\n    SymbolKind.Variable = 13;\n    SymbolKind.Constant = 14;\n    SymbolKind.String = 15;\n    SymbolKind.Number = 16;\n    SymbolKind.Boolean = 17;\n    SymbolKind.Array = 18;\n    SymbolKind.Object = 19;\n    SymbolKind.Key = 20;\n    SymbolKind.Null = 21;\n    SymbolKind.EnumMember = 22;\n    SymbolKind.Struct = 23;\n    SymbolKind.Event = 24;\n    SymbolKind.Operator = 25;\n    SymbolKind.TypeParameter = 26;\n})(SymbolKind || (SymbolKind = {}));\n/**\n * Symbol tags are extra annotations that tweak the rendering of a symbol.\n * @since 3.16\n */\nexport var SymbolTag;\n(function (SymbolTag) {\n    /**\n     * Render a symbol as obsolete, usually using a strike-out.\n     */\n    SymbolTag.Deprecated = 1;\n})(SymbolTag || (SymbolTag = {}));\nexport var SymbolInformation;\n(function (SymbolInformation) {\n    /**\n     * Creates a new symbol information literal.\n     *\n     * @param name The name of the symbol.\n     * @param kind The kind of the symbol.\n     * @param range The range of the location of the symbol.\n     * @param uri The resource of the location of symbol, defaults to the current document.\n     * @param containerName The name of the symbol containing the symbol.\n     */\n    function create(name, kind, range, uri, containerName) {\n        var result = {\n            name: name,\n            kind: kind,\n            location: { uri: uri, range: range }\n        };\n        if (containerName) {\n            result.containerName = containerName;\n        }\n        return result;\n    }\n    SymbolInformation.create = create;\n})(SymbolInformation || (SymbolInformation = {}));\nexport var DocumentSymbol;\n(function (DocumentSymbol) {\n    /**\n     * Creates a new symbol information literal.\n     *\n     * @param name The name of the symbol.\n     * @param detail The detail of the symbol.\n     * @param kind The kind of the symbol.\n     * @param range The range of the symbol.\n     * @param selectionRange The selectionRange of the symbol.\n     * @param children Children of the symbol.\n     */\n    function create(name, detail, kind, range, selectionRange, children) {\n        var result = {\n            name: name,\n            detail: detail,\n            kind: kind,\n            range: range,\n            selectionRange: selectionRange\n        };\n        if (children !== undefined) {\n            result.children = children;\n        }\n        return result;\n    }\n    DocumentSymbol.create = create;\n    /**\n     * Checks whether the given literal conforms to the [DocumentSymbol](#DocumentSymbol) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return candidate &&\n            Is.string(candidate.name) && Is.number(candidate.kind) &&\n            Range.is(candidate.range) && Range.is(candidate.selectionRange) &&\n            (candidate.detail === undefined || Is.string(candidate.detail)) &&\n            (candidate.deprecated === undefined || Is.boolean(candidate.deprecated)) &&\n            (candidate.children === undefined || Array.isArray(candidate.children)) &&\n            (candidate.tags === undefined || Array.isArray(candidate.tags));\n    }\n    DocumentSymbol.is = is;\n})(DocumentSymbol || (DocumentSymbol = {}));\n/**\n * A set of predefined code action kinds\n */\nexport var CodeActionKind;\n(function (CodeActionKind) {\n    /**\n     * Empty kind.\n     */\n    CodeActionKind.Empty = '';\n    /**\n     * Base kind for quickfix actions: 'quickfix'\n     */\n    CodeActionKind.QuickFix = 'quickfix';\n    /**\n     * Base kind for refactoring actions: 'refactor'\n     */\n    CodeActionKind.Refactor = 'refactor';\n    /**\n     * Base kind for refactoring extraction actions: 'refactor.extract'\n     *\n     * Example extract actions:\n     *\n     * - Extract method\n     * - Extract function\n     * - Extract variable\n     * - Extract interface from class\n     * - ...\n     */\n    CodeActionKind.RefactorExtract = 'refactor.extract';\n    /**\n     * Base kind for refactoring inline actions: 'refactor.inline'\n     *\n     * Example inline actions:\n     *\n     * - Inline function\n     * - Inline variable\n     * - Inline constant\n     * - ...\n     */\n    CodeActionKind.RefactorInline = 'refactor.inline';\n    /**\n     * Base kind for refactoring rewrite actions: 'refactor.rewrite'\n     *\n     * Example rewrite actions:\n     *\n     * - Convert JavaScript function to class\n     * - Add or remove parameter\n     * - Encapsulate field\n     * - Make method static\n     * - Move method to base class\n     * - ...\n     */\n    CodeActionKind.RefactorRewrite = 'refactor.rewrite';\n    /**\n     * Base kind for source actions: `source`\n     *\n     * Source code actions apply to the entire file.\n     */\n    CodeActionKind.Source = 'source';\n    /**\n     * Base kind for an organize imports source action: `source.organizeImports`\n     */\n    CodeActionKind.SourceOrganizeImports = 'source.organizeImports';\n    /**\n     * Base kind for auto-fix source actions: `source.fixAll`.\n     *\n     * Fix all actions automatically fix errors that have a clear fix that do not require user input.\n     * They should not suppress errors or perform unsafe fixes such as generating new types or classes.\n     *\n     * @since 3.15.0\n     */\n    CodeActionKind.SourceFixAll = 'source.fixAll';\n})(CodeActionKind || (CodeActionKind = {}));\n/**\n * The CodeActionContext namespace provides helper functions to work with\n * [CodeActionContext](#CodeActionContext) literals.\n */\nexport var CodeActionContext;\n(function (CodeActionContext) {\n    /**\n     * Creates a new CodeActionContext literal.\n     */\n    function create(diagnostics, only) {\n        var result = { diagnostics: diagnostics };\n        if (only !== undefined && only !== null) {\n            result.only = only;\n        }\n        return result;\n    }\n    CodeActionContext.create = create;\n    /**\n     * Checks whether the given literal conforms to the [CodeActionContext](#CodeActionContext) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Is.typedArray(candidate.diagnostics, Diagnostic.is) && (candidate.only === undefined || Is.typedArray(candidate.only, Is.string));\n    }\n    CodeActionContext.is = is;\n})(CodeActionContext || (CodeActionContext = {}));\nexport var CodeAction;\n(function (CodeAction) {\n    function create(title, kindOrCommandOrEdit, kind) {\n        var result = { title: title };\n        var checkKind = true;\n        if (typeof kindOrCommandOrEdit === 'string') {\n            checkKind = false;\n            result.kind = kindOrCommandOrEdit;\n        }\n        else if (Command.is(kindOrCommandOrEdit)) {\n            result.command = kindOrCommandOrEdit;\n        }\n        else {\n            result.edit = kindOrCommandOrEdit;\n        }\n        if (checkKind && kind !== undefined) {\n            result.kind = kind;\n        }\n        return result;\n    }\n    CodeAction.create = create;\n    function is(value) {\n        var candidate = value;\n        return candidate && Is.string(candidate.title) &&\n            (candidate.diagnostics === undefined || Is.typedArray(candidate.diagnostics, Diagnostic.is)) &&\n            (candidate.kind === undefined || Is.string(candidate.kind)) &&\n            (candidate.edit !== undefined || candidate.command !== undefined) &&\n            (candidate.command === undefined || Command.is(candidate.command)) &&\n            (candidate.isPreferred === undefined || Is.boolean(candidate.isPreferred)) &&\n            (candidate.edit === undefined || WorkspaceEdit.is(candidate.edit));\n    }\n    CodeAction.is = is;\n})(CodeAction || (CodeAction = {}));\n/**\n * The CodeLens namespace provides helper functions to work with\n * [CodeLens](#CodeLens) literals.\n */\nexport var CodeLens;\n(function (CodeLens) {\n    /**\n     * Creates a new CodeLens literal.\n     */\n    function create(range, data) {\n        var result = { range: range };\n        if (Is.defined(data)) {\n            result.data = data;\n        }\n        return result;\n    }\n    CodeLens.create = create;\n    /**\n     * Checks whether the given literal conforms to the [CodeLens](#CodeLens) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.command) || Command.is(candidate.command));\n    }\n    CodeLens.is = is;\n})(CodeLens || (CodeLens = {}));\n/**\n * The FormattingOptions namespace provides helper functions to work with\n * [FormattingOptions](#FormattingOptions) literals.\n */\nexport var FormattingOptions;\n(function (FormattingOptions) {\n    /**\n     * Creates a new FormattingOptions literal.\n     */\n    function create(tabSize, insertSpaces) {\n        return { tabSize: tabSize, insertSpaces: insertSpaces };\n    }\n    FormattingOptions.create = create;\n    /**\n     * Checks whether the given literal conforms to the [FormattingOptions](#FormattingOptions) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Is.uinteger(candidate.tabSize) && Is.boolean(candidate.insertSpaces);\n    }\n    FormattingOptions.is = is;\n})(FormattingOptions || (FormattingOptions = {}));\n/**\n * The DocumentLink namespace provides helper functions to work with\n * [DocumentLink](#DocumentLink) literals.\n */\nexport var DocumentLink;\n(function (DocumentLink) {\n    /**\n     * Creates a new DocumentLink literal.\n     */\n    function create(range, target, data) {\n        return { range: range, target: target, data: data };\n    }\n    DocumentLink.create = create;\n    /**\n     * Checks whether the given literal conforms to the [DocumentLink](#DocumentLink) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Range.is(candidate.range) && (Is.undefined(candidate.target) || Is.string(candidate.target));\n    }\n    DocumentLink.is = is;\n})(DocumentLink || (DocumentLink = {}));\n/**\n * The SelectionRange namespace provides helper function to work with\n * SelectionRange literals.\n */\nexport var SelectionRange;\n(function (SelectionRange) {\n    /**\n     * Creates a new SelectionRange\n     * @param range the range.\n     * @param parent an optional parent.\n     */\n    function create(range, parent) {\n        return { range: range, parent: parent };\n    }\n    SelectionRange.create = create;\n    function is(value) {\n        var candidate = value;\n        return candidate !== undefined && Range.is(candidate.range) && (candidate.parent === undefined || SelectionRange.is(candidate.parent));\n    }\n    SelectionRange.is = is;\n})(SelectionRange || (SelectionRange = {}));\nexport var EOL = ['\\n', '\\r\\n', '\\r'];\n/**\n * @deprecated Use the text document from the new vscode-languageserver-textdocument package.\n */\nexport var TextDocument;\n(function (TextDocument) {\n    /**\n     * Creates a new ITextDocument literal from the given uri and content.\n     * @param uri The document's uri.\n     * @param languageId  The document's language Id.\n     * @param content The document's content.\n     */\n    function create(uri, languageId, version, content) {\n        return new FullTextDocument(uri, languageId, version, content);\n    }\n    TextDocument.create = create;\n    /**\n     * Checks whether the given literal conforms to the [ITextDocument](#ITextDocument) interface.\n     */\n    function is(value) {\n        var candidate = value;\n        return Is.defined(candidate) && Is.string(candidate.uri) && (Is.undefined(candidate.languageId) || Is.string(candidate.languageId)) && Is.uinteger(candidate.lineCount)\n            && Is.func(candidate.getText) && Is.func(candidate.positionAt) && Is.func(candidate.offsetAt) ? true : false;\n    }\n    TextDocument.is = is;\n    function applyEdits(document, edits) {\n        var text = document.getText();\n        var sortedEdits = mergeSort(edits, function (a, b) {\n            var diff = a.range.start.line - b.range.start.line;\n            if (diff === 0) {\n                return a.range.start.character - b.range.start.character;\n            }\n            return diff;\n        });\n        var lastModifiedOffset = text.length;\n        for (var i = sortedEdits.length - 1; i >= 0; i--) {\n            var e = sortedEdits[i];\n            var startOffset = document.offsetAt(e.range.start);\n            var endOffset = document.offsetAt(e.range.end);\n            if (endOffset <= lastModifiedOffset) {\n                text = text.substring(0, startOffset) + e.newText + text.substring(endOffset, text.length);\n            }\n            else {\n                throw new Error('Overlapping edit');\n            }\n            lastModifiedOffset = startOffset;\n        }\n        return text;\n    }\n    TextDocument.applyEdits = applyEdits;\n    function mergeSort(data, compare) {\n        if (data.length <= 1) {\n            // sorted\n            return data;\n        }\n        var p = (data.length / 2) | 0;\n        var left = data.slice(0, p);\n        var right = data.slice(p);\n        mergeSort(left, compare);\n        mergeSort(right, compare);\n        var leftIdx = 0;\n        var rightIdx = 0;\n        var i = 0;\n        while (leftIdx < left.length && rightIdx < right.length) {\n            var ret = compare(left[leftIdx], right[rightIdx]);\n            if (ret <= 0) {\n                // smaller_equal -> take left to preserve order\n                data[i++] = left[leftIdx++];\n            }\n            else {\n                // greater -> take right\n                data[i++] = right[rightIdx++];\n            }\n        }\n        while (leftIdx < left.length) {\n            data[i++] = left[leftIdx++];\n        }\n        while (rightIdx < right.length) {\n            data[i++] = right[rightIdx++];\n        }\n        return data;\n    }\n})(TextDocument || (TextDocument = {}));\n/**\n * @deprecated Use the text document from the new vscode-languageserver-textdocument package.\n */\nvar FullTextDocument = /** @class */ (function () {\n    function FullTextDocument(uri, languageId, version, content) {\n        this._uri = uri;\n        this._languageId = languageId;\n        this._version = version;\n        this._content = content;\n        this._lineOffsets = undefined;\n    }\n    Object.defineProperty(FullTextDocument.prototype, \"uri\", {\n        get: function () {\n            return this._uri;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(FullTextDocument.prototype, \"languageId\", {\n        get: function () {\n            return this._languageId;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(FullTextDocument.prototype, \"version\", {\n        get: function () {\n            return this._version;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    FullTextDocument.prototype.getText = function (range) {\n        if (range) {\n            var start = this.offsetAt(range.start);\n            var end = this.offsetAt(range.end);\n            return this._content.substring(start, end);\n        }\n        return this._content;\n    };\n    FullTextDocument.prototype.update = function (event, version) {\n        this._content = event.text;\n        this._version = version;\n        this._lineOffsets = undefined;\n    };\n    FullTextDocument.prototype.getLineOffsets = function () {\n        if (this._lineOffsets === undefined) {\n            var lineOffsets = [];\n            var text = this._content;\n            var isLineStart = true;\n            for (var i = 0; i < text.length; i++) {\n                if (isLineStart) {\n                    lineOffsets.push(i);\n                    isLineStart = false;\n                }\n                var ch = text.charAt(i);\n                isLineStart = (ch === '\\r' || ch === '\\n');\n                if (ch === '\\r' && i + 1 < text.length && text.charAt(i + 1) === '\\n') {\n                    i++;\n                }\n            }\n            if (isLineStart && text.length > 0) {\n                lineOffsets.push(text.length);\n            }\n            this._lineOffsets = lineOffsets;\n        }\n        return this._lineOffsets;\n    };\n    FullTextDocument.prototype.positionAt = function (offset) {\n        offset = Math.max(Math.min(offset, this._content.length), 0);\n        var lineOffsets = this.getLineOffsets();\n        var low = 0, high = lineOffsets.length;\n        if (high === 0) {\n            return Position.create(0, offset);\n        }\n        while (low < high) {\n            var mid = Math.floor((low + high) / 2);\n            if (lineOffsets[mid] > offset) {\n                high = mid;\n            }\n            else {\n                low = mid + 1;\n            }\n        }\n        // low is the least x for which the line offset is larger than the current offset\n        // or array.length if no line offset is larger than the current offset\n        var line = low - 1;\n        return Position.create(line, offset - lineOffsets[line]);\n    };\n    FullTextDocument.prototype.offsetAt = function (position) {\n        var lineOffsets = this.getLineOffsets();\n        if (position.line >= lineOffsets.length) {\n            return this._content.length;\n        }\n        else if (position.line < 0) {\n            return 0;\n        }\n        var lineOffset = lineOffsets[position.line];\n        var nextLineOffset = (position.line + 1 < lineOffsets.length) ? lineOffsets[position.line + 1] : this._content.length;\n        return Math.max(Math.min(lineOffset + position.character, nextLineOffset), lineOffset);\n    };\n    Object.defineProperty(FullTextDocument.prototype, \"lineCount\", {\n        get: function () {\n            return this.getLineOffsets().length;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return FullTextDocument;\n}());\nvar Is;\n(function (Is) {\n    var toString = Object.prototype.toString;\n    function defined(value) {\n        return typeof value !== 'undefined';\n    }\n    Is.defined = defined;\n    function undefined(value) {\n        return typeof value === 'undefined';\n    }\n    Is.undefined = undefined;\n    function boolean(value) {\n        return value === true || value === false;\n    }\n    Is.boolean = boolean;\n    function string(value) {\n        return toString.call(value) === '[object String]';\n    }\n    Is.string = string;\n    function number(value) {\n        return toString.call(value) === '[object Number]';\n    }\n    Is.number = number;\n    function numberRange(value, min, max) {\n        return toString.call(value) === '[object Number]' && min <= value && value <= max;\n    }\n    Is.numberRange = numberRange;\n    function integer(value) {\n        return toString.call(value) === '[object Number]' && -2147483648 <= value && value <= 2147483647;\n    }\n    Is.integer = integer;\n    function uinteger(value) {\n        return toString.call(value) === '[object Number]' && 0 <= value && value <= 2147483647;\n    }\n    Is.uinteger = uinteger;\n    function func(value) {\n        return toString.call(value) === '[object Function]';\n    }\n    Is.func = func;\n    function objectLiteral(value) {\n        // Strictly speaking class instances pass this check as well. Since the LSP\n        // doesn't use classes we ignore this for now. If we do we need to add something\n        // like this: `Object.getPrototypeOf(Object.getPrototypeOf(x)) === null`\n        return value !== null && typeof value === 'object';\n    }\n    Is.objectLiteral = objectLiteral;\n    function typedArray(value, check) {\n        return Array.isArray(value) && value.every(check);\n    }\n    Is.typedArray = typedArray;\n})(Is || (Is = {}));\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { editor } from './fillers/monaco-editor-core.js';\nvar STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min\nvar WorkerManager = /** @class */ (function () {\n    function WorkerManager(defaults) {\n        var _this = this;\n        this._defaults = defaults;\n        this._worker = null;\n        this._idleCheckInterval = window.setInterval(function () { return _this._checkIfIdle(); }, 30 * 1000);\n        this._lastUsedTime = 0;\n        this._configChangeListener = this._defaults.onDidChange(function () { return _this._stopWorker(); });\n    }\n    WorkerManager.prototype._stopWorker = function () {\n        if (this._worker) {\n            this._worker.dispose();\n            this._worker = null;\n        }\n        this._client = null;\n    };\n    WorkerManager.prototype.dispose = function () {\n        clearInterval(this._idleCheckInterval);\n        this._configChangeListener.dispose();\n        this._stopWorker();\n    };\n    WorkerManager.prototype._checkIfIdle = function () {\n        if (!this._worker) {\n            return;\n        }\n        var timePassedSinceLastUsed = Date.now() - this._lastUsedTime;\n        if (timePassedSinceLastUsed > STOP_WHEN_IDLE_FOR) {\n            this._stopWorker();\n        }\n    };\n    WorkerManager.prototype._getClient = function () {\n        this._lastUsedTime = Date.now();\n        if (!this._client) {\n            this._worker = editor.createWebWorker({\n                // module that exports the create() method and returns a `JSONWorker` instance\n                moduleId: 'vs/language/json/jsonWorker',\n                label: this._defaults.languageId,\n                // passed in to the create() method\n                createData: {\n                    languageSettings: this._defaults.diagnosticsOptions,\n                    languageId: this._defaults.languageId,\n                    enableSchemaRequest: this._defaults.diagnosticsOptions.enableSchemaRequest\n                }\n            });\n            this._client = this._worker.getProxy();\n        }\n        return this._client;\n    };\n    WorkerManager.prototype.getLanguageServiceWorker = function () {\n        var _this = this;\n        var resources = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            resources[_i] = arguments[_i];\n        }\n        var _client;\n        return this._getClient()\n            .then(function (client) {\n            _client = client;\n        })\n            .then(function (_) {\n            return _this._worker.withSyncedResources(resources);\n        })\n            .then(function (_) { return _client; });\n    };\n    return WorkerManager;\n}());\nexport { WorkerManager };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { Uri, Range, editor, languages, MarkerSeverity } from './fillers/monaco-editor-core.js';\nimport * as lsTypes from './_deps/vscode-languageserver-types/main.js';\n// --- diagnostics --- ---\nvar DiagnosticsAdapter = /** @class */ (function () {\n    function DiagnosticsAdapter(_languageId, _worker, defaults) {\n        var _this = this;\n        this._languageId = _languageId;\n        this._worker = _worker;\n        this._disposables = [];\n        this._listener = Object.create(null);\n        var onModelAdd = function (model) {\n            var modeId = model.getLanguageId();\n            if (modeId !== _this._languageId) {\n                return;\n            }\n            var handle;\n            _this._listener[model.uri.toString()] = model.onDidChangeContent(function () {\n                clearTimeout(handle);\n                handle = window.setTimeout(function () { return _this._doValidate(model.uri, modeId); }, 500);\n            });\n            _this._doValidate(model.uri, modeId);\n        };\n        var onModelRemoved = function (model) {\n            editor.setModelMarkers(model, _this._languageId, []);\n            var uriStr = model.uri.toString();\n            var listener = _this._listener[uriStr];\n            if (listener) {\n                listener.dispose();\n                delete _this._listener[uriStr];\n            }\n        };\n        this._disposables.push(editor.onDidCreateModel(onModelAdd));\n        this._disposables.push(editor.onWillDisposeModel(function (model) {\n            onModelRemoved(model);\n            _this._resetSchema(model.uri);\n        }));\n        this._disposables.push(editor.onDidChangeModelLanguage(function (event) {\n            onModelRemoved(event.model);\n            onModelAdd(event.model);\n            _this._resetSchema(event.model.uri);\n        }));\n        this._disposables.push(defaults.onDidChange(function (_) {\n            editor.getModels().forEach(function (model) {\n                if (model.getLanguageId() === _this._languageId) {\n                    onModelRemoved(model);\n                    onModelAdd(model);\n                }\n            });\n        }));\n        this._disposables.push({\n            dispose: function () {\n                editor.getModels().forEach(onModelRemoved);\n                for (var key in _this._listener) {\n                    _this._listener[key].dispose();\n                }\n            }\n        });\n        editor.getModels().forEach(onModelAdd);\n    }\n    DiagnosticsAdapter.prototype.dispose = function () {\n        this._disposables.forEach(function (d) { return d && d.dispose(); });\n        this._disposables = [];\n    };\n    DiagnosticsAdapter.prototype._resetSchema = function (resource) {\n        this._worker().then(function (worker) {\n            worker.resetSchema(resource.toString());\n        });\n    };\n    DiagnosticsAdapter.prototype._doValidate = function (resource, languageId) {\n        this._worker(resource)\n            .then(function (worker) {\n            return worker.doValidation(resource.toString()).then(function (diagnostics) {\n                var markers = diagnostics.map(function (d) { return toDiagnostics(resource, d); });\n                var model = editor.getModel(resource);\n                if (model && model.getLanguageId() === languageId) {\n                    editor.setModelMarkers(model, languageId, markers);\n                }\n            });\n        })\n            .then(undefined, function (err) {\n            console.error(err);\n        });\n    };\n    return DiagnosticsAdapter;\n}());\nexport { DiagnosticsAdapter };\nfunction toSeverity(lsSeverity) {\n    switch (lsSeverity) {\n        case lsTypes.DiagnosticSeverity.Error:\n            return MarkerSeverity.Error;\n        case lsTypes.DiagnosticSeverity.Warning:\n            return MarkerSeverity.Warning;\n        case lsTypes.DiagnosticSeverity.Information:\n            return MarkerSeverity.Info;\n        case lsTypes.DiagnosticSeverity.Hint:\n            return MarkerSeverity.Hint;\n        default:\n            return MarkerSeverity.Info;\n    }\n}\nfunction toDiagnostics(resource, diag) {\n    var code = typeof diag.code === 'number' ? String(diag.code) : diag.code;\n    return {\n        severity: toSeverity(diag.severity),\n        startLineNumber: diag.range.start.line + 1,\n        startColumn: diag.range.start.character + 1,\n        endLineNumber: diag.range.end.line + 1,\n        endColumn: diag.range.end.character + 1,\n        message: diag.message,\n        code: code,\n        source: diag.source\n    };\n}\n// --- completion ------\nfunction fromPosition(position) {\n    if (!position) {\n        return void 0;\n    }\n    return { character: position.column - 1, line: position.lineNumber - 1 };\n}\nfunction fromRange(range) {\n    if (!range) {\n        return void 0;\n    }\n    return {\n        start: {\n            line: range.startLineNumber - 1,\n            character: range.startColumn - 1\n        },\n        end: { line: range.endLineNumber - 1, character: range.endColumn - 1 }\n    };\n}\nfunction toRange(range) {\n    if (!range) {\n        return void 0;\n    }\n    return new Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1);\n}\nfunction isInsertReplaceEdit(edit) {\n    return (typeof edit.insert !== 'undefined' &&\n        typeof edit.replace !== 'undefined');\n}\nfunction toCompletionItemKind(kind) {\n    var mItemKind = languages.CompletionItemKind;\n    switch (kind) {\n        case lsTypes.CompletionItemKind.Text:\n            return mItemKind.Text;\n        case lsTypes.CompletionItemKind.Method:\n            return mItemKind.Method;\n        case lsTypes.CompletionItemKind.Function:\n            return mItemKind.Function;\n        case lsTypes.CompletionItemKind.Constructor:\n            return mItemKind.Constructor;\n        case lsTypes.CompletionItemKind.Field:\n            return mItemKind.Field;\n        case lsTypes.CompletionItemKind.Variable:\n            return mItemKind.Variable;\n        case lsTypes.CompletionItemKind.Class:\n            return mItemKind.Class;\n        case lsTypes.CompletionItemKind.Interface:\n            return mItemKind.Interface;\n        case lsTypes.CompletionItemKind.Module:\n            return mItemKind.Module;\n        case lsTypes.CompletionItemKind.Property:\n            return mItemKind.Property;\n        case lsTypes.CompletionItemKind.Unit:\n            return mItemKind.Unit;\n        case lsTypes.CompletionItemKind.Value:\n            return mItemKind.Value;\n        case lsTypes.CompletionItemKind.Enum:\n            return mItemKind.Enum;\n        case lsTypes.CompletionItemKind.Keyword:\n            return mItemKind.Keyword;\n        case lsTypes.CompletionItemKind.Snippet:\n            return mItemKind.Snippet;\n        case lsTypes.CompletionItemKind.Color:\n            return mItemKind.Color;\n        case lsTypes.CompletionItemKind.File:\n            return mItemKind.File;\n        case lsTypes.CompletionItemKind.Reference:\n            return mItemKind.Reference;\n    }\n    return mItemKind.Property;\n}\nfunction fromCompletionItemKind(kind) {\n    var mItemKind = languages.CompletionItemKind;\n    switch (kind) {\n        case mItemKind.Text:\n            return lsTypes.CompletionItemKind.Text;\n        case mItemKind.Method:\n            return lsTypes.CompletionItemKind.Method;\n        case mItemKind.Function:\n            return lsTypes.CompletionItemKind.Function;\n        case mItemKind.Constructor:\n            return lsTypes.CompletionItemKind.Constructor;\n        case mItemKind.Field:\n            return lsTypes.CompletionItemKind.Field;\n        case mItemKind.Variable:\n            return lsTypes.CompletionItemKind.Variable;\n        case mItemKind.Class:\n            return lsTypes.CompletionItemKind.Class;\n        case mItemKind.Interface:\n            return lsTypes.CompletionItemKind.Interface;\n        case mItemKind.Module:\n            return lsTypes.CompletionItemKind.Module;\n        case mItemKind.Property:\n            return lsTypes.CompletionItemKind.Property;\n        case mItemKind.Unit:\n            return lsTypes.CompletionItemKind.Unit;\n        case mItemKind.Value:\n            return lsTypes.CompletionItemKind.Value;\n        case mItemKind.Enum:\n            return lsTypes.CompletionItemKind.Enum;\n        case mItemKind.Keyword:\n            return lsTypes.CompletionItemKind.Keyword;\n        case mItemKind.Snippet:\n            return lsTypes.CompletionItemKind.Snippet;\n        case mItemKind.Color:\n            return lsTypes.CompletionItemKind.Color;\n        case mItemKind.File:\n            return lsTypes.CompletionItemKind.File;\n        case mItemKind.Reference:\n            return lsTypes.CompletionItemKind.Reference;\n    }\n    return lsTypes.CompletionItemKind.Property;\n}\nfunction toTextEdit(textEdit) {\n    if (!textEdit) {\n        return void 0;\n    }\n    return {\n        range: toRange(textEdit.range),\n        text: textEdit.newText\n    };\n}\nfunction toCommand(c) {\n    return c && c.command === 'editor.action.triggerSuggest'\n        ? { id: c.command, title: c.title, arguments: c.arguments }\n        : undefined;\n}\nvar CompletionAdapter = /** @class */ (function () {\n    function CompletionAdapter(_worker) {\n        this._worker = _worker;\n    }\n    Object.defineProperty(CompletionAdapter.prototype, \"triggerCharacters\", {\n        get: function () {\n            return [' ', ':', '\"'];\n        },\n        enumerable: false,\n        configurable: true\n    });\n    CompletionAdapter.prototype.provideCompletionItems = function (model, position, context, token) {\n        var resource = model.uri;\n        return this._worker(resource)\n            .then(function (worker) {\n            return worker.doComplete(resource.toString(), fromPosition(position));\n        })\n            .then(function (info) {\n            if (!info) {\n                return;\n            }\n            var wordInfo = model.getWordUntilPosition(position);\n            var wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);\n            var items = info.items.map(function (entry) {\n                var item = {\n                    label: entry.label,\n                    insertText: entry.insertText || entry.label,\n                    sortText: entry.sortText,\n                    filterText: entry.filterText,\n                    documentation: entry.documentation,\n                    detail: entry.detail,\n                    command: toCommand(entry.command),\n                    range: wordRange,\n                    kind: toCompletionItemKind(entry.kind)\n                };\n                if (entry.textEdit) {\n                    if (isInsertReplaceEdit(entry.textEdit)) {\n                        item.range = {\n                            insert: toRange(entry.textEdit.insert),\n                            replace: toRange(entry.textEdit.replace)\n                        };\n                    }\n                    else {\n                        item.range = toRange(entry.textEdit.range);\n                    }\n                    item.insertText = entry.textEdit.newText;\n                }\n                if (entry.additionalTextEdits) {\n                    item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);\n                }\n                if (entry.insertTextFormat === lsTypes.InsertTextFormat.Snippet) {\n                    item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;\n                }\n                return item;\n            });\n            return {\n                isIncomplete: info.isIncomplete,\n                suggestions: items\n            };\n        });\n    };\n    return CompletionAdapter;\n}());\nexport { CompletionAdapter };\nfunction isMarkupContent(thing) {\n    return (thing && typeof thing === 'object' && typeof thing.kind === 'string');\n}\nfunction toMarkdownString(entry) {\n    if (typeof entry === 'string') {\n        return {\n            value: entry\n        };\n    }\n    if (isMarkupContent(entry)) {\n        if (entry.kind === 'plaintext') {\n            return {\n                value: entry.value.replace(/[\\\\`*_{}[\\]()#+\\-.!]/g, '\\\\$&')\n            };\n        }\n        return {\n            value: entry.value\n        };\n    }\n    return { value: '```' + entry.language + '\\n' + entry.value + '\\n```\\n' };\n}\nfunction toMarkedStringArray(contents) {\n    if (!contents) {\n        return void 0;\n    }\n    if (Array.isArray(contents)) {\n        return contents.map(toMarkdownString);\n    }\n    return [toMarkdownString(contents)];\n}\n// --- hover ------\nvar HoverAdapter = /** @class */ (function () {\n    function HoverAdapter(_worker) {\n        this._worker = _worker;\n    }\n    HoverAdapter.prototype.provideHover = function (model, position, token) {\n        var resource = model.uri;\n        return this._worker(resource)\n            .then(function (worker) {\n            return worker.doHover(resource.toString(), fromPosition(position));\n        })\n            .then(function (info) {\n            if (!info) {\n                return;\n            }\n            return {\n                range: toRange(info.range),\n                contents: toMarkedStringArray(info.contents)\n            };\n        });\n    };\n    return HoverAdapter;\n}());\nexport { HoverAdapter };\n// --- definition ------\nfunction toLocation(location) {\n    return {\n        uri: Uri.parse(location.uri),\n        range: toRange(location.range)\n    };\n}\n// --- document symbols ------\nfunction toSymbolKind(kind) {\n    var mKind = languages.SymbolKind;\n    switch (kind) {\n        case lsTypes.SymbolKind.File:\n            return mKind.Array;\n        case lsTypes.SymbolKind.Module:\n            return mKind.Module;\n        case lsTypes.SymbolKind.Namespace:\n            return mKind.Namespace;\n        case lsTypes.SymbolKind.Package:\n            return mKind.Package;\n        case lsTypes.SymbolKind.Class:\n            return mKind.Class;\n        case lsTypes.SymbolKind.Method:\n            return mKind.Method;\n        case lsTypes.SymbolKind.Property:\n            return mKind.Property;\n        case lsTypes.SymbolKind.Field:\n            return mKind.Field;\n        case lsTypes.SymbolKind.Constructor:\n            return mKind.Constructor;\n        case lsTypes.SymbolKind.Enum:\n            return mKind.Enum;\n        case lsTypes.SymbolKind.Interface:\n            return mKind.Interface;\n        case lsTypes.SymbolKind.Function:\n            return mKind.Function;\n        case lsTypes.SymbolKind.Variable:\n            return mKind.Variable;\n        case lsTypes.SymbolKind.Constant:\n            return mKind.Constant;\n        case lsTypes.SymbolKind.String:\n            return mKind.String;\n        case lsTypes.SymbolKind.Number:\n            return mKind.Number;\n        case lsTypes.SymbolKind.Boolean:\n            return mKind.Boolean;\n        case lsTypes.SymbolKind.Array:\n            return mKind.Array;\n    }\n    return mKind.Function;\n}\nvar DocumentSymbolAdapter = /** @class */ (function () {\n    function DocumentSymbolAdapter(_worker) {\n        this._worker = _worker;\n    }\n    DocumentSymbolAdapter.prototype.provideDocumentSymbols = function (model, token) {\n        var resource = model.uri;\n        return this._worker(resource)\n            .then(function (worker) { return worker.findDocumentSymbols(resource.toString()); })\n            .then(function (items) {\n            if (!items) {\n                return;\n            }\n            return items.map(function (item) { return ({\n                name: item.name,\n                detail: '',\n                containerName: item.containerName,\n                kind: toSymbolKind(item.kind),\n                range: toRange(item.location.range),\n                selectionRange: toRange(item.location.range),\n                tags: []\n            }); });\n        });\n    };\n    return DocumentSymbolAdapter;\n}());\nexport { DocumentSymbolAdapter };\nfunction fromFormattingOptions(options) {\n    return {\n        tabSize: options.tabSize,\n        insertSpaces: options.insertSpaces\n    };\n}\nvar DocumentFormattingEditProvider = /** @class */ (function () {\n    function DocumentFormattingEditProvider(_worker) {\n        this._worker = _worker;\n    }\n    DocumentFormattingEditProvider.prototype.provideDocumentFormattingEdits = function (model, options, token) {\n        var resource = model.uri;\n        return this._worker(resource).then(function (worker) {\n            return worker\n                .format(resource.toString(), null, fromFormattingOptions(options))\n                .then(function (edits) {\n                if (!edits || edits.length === 0) {\n                    return;\n                }\n                return edits.map(toTextEdit);\n            });\n        });\n    };\n    return DocumentFormattingEditProvider;\n}());\nexport { DocumentFormattingEditProvider };\nvar DocumentRangeFormattingEditProvider = /** @class */ (function () {\n    function DocumentRangeFormattingEditProvider(_worker) {\n        this._worker = _worker;\n    }\n    DocumentRangeFormattingEditProvider.prototype.provideDocumentRangeFormattingEdits = function (model, range, options, token) {\n        var resource = model.uri;\n        return this._worker(resource).then(function (worker) {\n            return worker\n                .format(resource.toString(), fromRange(range), fromFormattingOptions(options))\n                .then(function (edits) {\n                if (!edits || edits.length === 0) {\n                    return;\n                }\n                return edits.map(toTextEdit);\n            });\n        });\n    };\n    return DocumentRangeFormattingEditProvider;\n}());\nexport { DocumentRangeFormattingEditProvider };\nvar DocumentColorAdapter = /** @class */ (function () {\n    function DocumentColorAdapter(_worker) {\n        this._worker = _worker;\n    }\n    DocumentColorAdapter.prototype.provideDocumentColors = function (model, token) {\n        var resource = model.uri;\n        return this._worker(resource)\n            .then(function (worker) { return worker.findDocumentColors(resource.toString()); })\n            .then(function (infos) {\n            if (!infos) {\n                return;\n            }\n            return infos.map(function (item) { return ({\n                color: item.color,\n                range: toRange(item.range)\n            }); });\n        });\n    };\n    DocumentColorAdapter.prototype.provideColorPresentations = function (model, info, token) {\n        var resource = model.uri;\n        return this._worker(resource)\n            .then(function (worker) {\n            return worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range));\n        })\n            .then(function (presentations) {\n            if (!presentations) {\n                return;\n            }\n            return presentations.map(function (presentation) {\n                var item = {\n                    label: presentation.label\n                };\n                if (presentation.textEdit) {\n                    item.textEdit = toTextEdit(presentation.textEdit);\n                }\n                if (presentation.additionalTextEdits) {\n                    item.additionalTextEdits = presentation.additionalTextEdits.map(toTextEdit);\n                }\n                return item;\n            });\n        });\n    };\n    return DocumentColorAdapter;\n}());\nexport { DocumentColorAdapter };\nvar FoldingRangeAdapter = /** @class */ (function () {\n    function FoldingRangeAdapter(_worker) {\n        this._worker = _worker;\n    }\n    FoldingRangeAdapter.prototype.provideFoldingRanges = function (model, context, token) {\n        var resource = model.uri;\n        return this._worker(resource)\n            .then(function (worker) { return worker.getFoldingRanges(resource.toString(), context); })\n            .then(function (ranges) {\n            if (!ranges) {\n                return;\n            }\n            return ranges.map(function (range) {\n                var result = {\n                    start: range.startLine + 1,\n                    end: range.endLine + 1\n                };\n                if (typeof range.kind !== 'undefined') {\n                    result.kind = toFoldingRangeKind(range.kind);\n                }\n                return result;\n            });\n        });\n    };\n    return FoldingRangeAdapter;\n}());\nexport { FoldingRangeAdapter };\nfunction toFoldingRangeKind(kind) {\n    switch (kind) {\n        case lsTypes.FoldingRangeKind.Comment:\n            return languages.FoldingRangeKind.Comment;\n        case lsTypes.FoldingRangeKind.Imports:\n            return languages.FoldingRangeKind.Imports;\n        case lsTypes.FoldingRangeKind.Region:\n            return languages.FoldingRangeKind.Region;\n    }\n    return void 0;\n}\nvar SelectionRangeAdapter = /** @class */ (function () {\n    function SelectionRangeAdapter(_worker) {\n        this._worker = _worker;\n    }\n    SelectionRangeAdapter.prototype.provideSelectionRanges = function (model, positions, token) {\n        var resource = model.uri;\n        return this._worker(resource)\n            .then(function (worker) { return worker.getSelectionRanges(resource.toString(), positions.map(fromPosition)); })\n            .then(function (selectionRanges) {\n            if (!selectionRanges) {\n                return;\n            }\n            return selectionRanges.map(function (selectionRange) {\n                var result = [];\n                while (selectionRange) {\n                    result.push({ range: toRange(selectionRange.range) });\n                    selectionRange = selectionRange.parent;\n                }\n                return result;\n            });\n        });\n    };\n    return SelectionRangeAdapter;\n}());\nexport { SelectionRangeAdapter };\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport { createScanner } from './scanner.js';\nvar ParseOptions;\n(function (ParseOptions) {\n    ParseOptions.DEFAULT = {\n        allowTrailingComma: false\n    };\n})(ParseOptions || (ParseOptions = {}));\n/**\n * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.\n */\nexport function getLocation(text, position) {\n    var segments = []; // strings or numbers\n    var earlyReturnException = new Object();\n    var previousNode = undefined;\n    var previousNodeInst = {\n        value: {},\n        offset: 0,\n        length: 0,\n        type: 'object',\n        parent: undefined\n    };\n    var isAtPropertyKey = false;\n    function setPreviousNode(value, offset, length, type) {\n        previousNodeInst.value = value;\n        previousNodeInst.offset = offset;\n        previousNodeInst.length = length;\n        previousNodeInst.type = type;\n        previousNodeInst.colonOffset = undefined;\n        previousNode = previousNodeInst;\n    }\n    try {\n        visit(text, {\n            onObjectBegin: function (offset, length) {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                isAtPropertyKey = position > offset;\n                segments.push(''); // push a placeholder (will be replaced)\n            },\n            onObjectProperty: function (name, offset, length) {\n                if (position < offset) {\n                    throw earlyReturnException;\n                }\n                setPreviousNode(name, offset, length, 'property');\n                segments[segments.length - 1] = name;\n                if (position <= offset + length) {\n                    throw earlyReturnException;\n                }\n            },\n            onObjectEnd: function (offset, length) {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                segments.pop();\n            },\n            onArrayBegin: function (offset, length) {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                segments.push(0);\n            },\n            onArrayEnd: function (offset, length) {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                previousNode = undefined;\n                segments.pop();\n            },\n            onLiteralValue: function (value, offset, length) {\n                if (position < offset) {\n                    throw earlyReturnException;\n                }\n                setPreviousNode(value, offset, length, getNodeType(value));\n                if (position <= offset + length) {\n                    throw earlyReturnException;\n                }\n            },\n            onSeparator: function (sep, offset, length) {\n                if (position <= offset) {\n                    throw earlyReturnException;\n                }\n                if (sep === ':' && previousNode && previousNode.type === 'property') {\n                    previousNode.colonOffset = offset;\n                    isAtPropertyKey = false;\n                    previousNode = undefined;\n                }\n                else if (sep === ',') {\n                    var last = segments[segments.length - 1];\n                    if (typeof last === 'number') {\n                        segments[segments.length - 1] = last + 1;\n                    }\n                    else {\n                        isAtPropertyKey = true;\n                        segments[segments.length - 1] = '';\n                    }\n                    previousNode = undefined;\n                }\n            }\n        });\n    }\n    catch (e) {\n        if (e !== earlyReturnException) {\n            throw e;\n        }\n    }\n    return {\n        path: segments,\n        previousNode: previousNode,\n        isAtPropertyKey: isAtPropertyKey,\n        matches: function (pattern) {\n            var k = 0;\n            for (var i = 0; k < pattern.length && i < segments.length; i++) {\n                if (pattern[k] === segments[i] || pattern[k] === '*') {\n                    k++;\n                }\n                else if (pattern[k] !== '**') {\n                    return false;\n                }\n            }\n            return k === pattern.length;\n        }\n    };\n}\n/**\n * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n * Therefore always check the errors list to find out if the input was valid.\n */\nexport function parse(text, errors, options) {\n    if (errors === void 0) { errors = []; }\n    if (options === void 0) { options = ParseOptions.DEFAULT; }\n    var currentProperty = null;\n    var currentParent = [];\n    var previousParents = [];\n    function onValue(value) {\n        if (Array.isArray(currentParent)) {\n            currentParent.push(value);\n        }\n        else if (currentProperty !== null) {\n            currentParent[currentProperty] = value;\n        }\n    }\n    var visitor = {\n        onObjectBegin: function () {\n            var object = {};\n            onValue(object);\n            previousParents.push(currentParent);\n            currentParent = object;\n            currentProperty = null;\n        },\n        onObjectProperty: function (name) {\n            currentProperty = name;\n        },\n        onObjectEnd: function () {\n            currentParent = previousParents.pop();\n        },\n        onArrayBegin: function () {\n            var array = [];\n            onValue(array);\n            previousParents.push(currentParent);\n            currentParent = array;\n            currentProperty = null;\n        },\n        onArrayEnd: function () {\n            currentParent = previousParents.pop();\n        },\n        onLiteralValue: onValue,\n        onError: function (error, offset, length) {\n            errors.push({ error: error, offset: offset, length: length });\n        }\n    };\n    visit(text, visitor, options);\n    return currentParent[0];\n}\n/**\n * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n */\nexport function parseTree(text, errors, options) {\n    if (errors === void 0) { errors = []; }\n    if (options === void 0) { options = ParseOptions.DEFAULT; }\n    var currentParent = { type: 'array', offset: -1, length: -1, children: [], parent: undefined }; // artificial root\n    function ensurePropertyComplete(endOffset) {\n        if (currentParent.type === 'property') {\n            currentParent.length = endOffset - currentParent.offset;\n            currentParent = currentParent.parent;\n        }\n    }\n    function onValue(valueNode) {\n        currentParent.children.push(valueNode);\n        return valueNode;\n    }\n    var visitor = {\n        onObjectBegin: function (offset) {\n            currentParent = onValue({ type: 'object', offset: offset, length: -1, parent: currentParent, children: [] });\n        },\n        onObjectProperty: function (name, offset, length) {\n            currentParent = onValue({ type: 'property', offset: offset, length: -1, parent: currentParent, children: [] });\n            currentParent.children.push({ type: 'string', value: name, offset: offset, length: length, parent: currentParent });\n        },\n        onObjectEnd: function (offset, length) {\n            ensurePropertyComplete(offset + length); // in case of a missing value for a property: make sure property is complete\n            currentParent.length = offset + length - currentParent.offset;\n            currentParent = currentParent.parent;\n            ensurePropertyComplete(offset + length);\n        },\n        onArrayBegin: function (offset, length) {\n            currentParent = onValue({ type: 'array', offset: offset, length: -1, parent: currentParent, children: [] });\n        },\n        onArrayEnd: function (offset, length) {\n            currentParent.length = offset + length - currentParent.offset;\n            currentParent = currentParent.parent;\n            ensurePropertyComplete(offset + length);\n        },\n        onLiteralValue: function (value, offset, length) {\n            onValue({ type: getNodeType(value), offset: offset, length: length, parent: currentParent, value: value });\n            ensurePropertyComplete(offset + length);\n        },\n        onSeparator: function (sep, offset, length) {\n            if (currentParent.type === 'property') {\n                if (sep === ':') {\n                    currentParent.colonOffset = offset;\n                }\n                else if (sep === ',') {\n                    ensurePropertyComplete(offset);\n                }\n            }\n        },\n        onError: function (error, offset, length) {\n            errors.push({ error: error, offset: offset, length: length });\n        }\n    };\n    visit(text, visitor, options);\n    var result = currentParent.children[0];\n    if (result) {\n        delete result.parent;\n    }\n    return result;\n}\n/**\n * Finds the node at the given path in a JSON DOM.\n */\nexport function findNodeAtLocation(root, path) {\n    if (!root) {\n        return undefined;\n    }\n    var node = root;\n    for (var _i = 0, path_1 = path; _i < path_1.length; _i++) {\n        var segment = path_1[_i];\n        if (typeof segment === 'string') {\n            if (node.type !== 'object' || !Array.isArray(node.children)) {\n                return undefined;\n            }\n            var found = false;\n            for (var _a = 0, _b = node.children; _a < _b.length; _a++) {\n                var propertyNode = _b[_a];\n                if (Array.isArray(propertyNode.children) && propertyNode.children[0].value === segment) {\n                    node = propertyNode.children[1];\n                    found = true;\n                    break;\n                }\n            }\n            if (!found) {\n                return undefined;\n            }\n        }\n        else {\n            var index = segment;\n            if (node.type !== 'array' || index < 0 || !Array.isArray(node.children) || index >= node.children.length) {\n                return undefined;\n            }\n            node = node.children[index];\n        }\n    }\n    return node;\n}\n/**\n * Gets the JSON path of the given JSON DOM node\n */\nexport function getNodePath(node) {\n    if (!node.parent || !node.parent.children) {\n        return [];\n    }\n    var path = getNodePath(node.parent);\n    if (node.parent.type === 'property') {\n        var key = node.parent.children[0].value;\n        path.push(key);\n    }\n    else if (node.parent.type === 'array') {\n        var index = node.parent.children.indexOf(node);\n        if (index !== -1) {\n            path.push(index);\n        }\n    }\n    return path;\n}\n/**\n * Evaluates the JavaScript object of the given JSON DOM node\n */\nexport function getNodeValue(node) {\n    switch (node.type) {\n        case 'array':\n            return node.children.map(getNodeValue);\n        case 'object':\n            var obj = Object.create(null);\n            for (var _i = 0, _a = node.children; _i < _a.length; _i++) {\n                var prop = _a[_i];\n                var valueNode = prop.children[1];\n                if (valueNode) {\n                    obj[prop.children[0].value] = getNodeValue(valueNode);\n                }\n            }\n            return obj;\n        case 'null':\n        case 'string':\n        case 'number':\n        case 'boolean':\n            return node.value;\n        default:\n            return undefined;\n    }\n}\nexport function contains(node, offset, includeRightBound) {\n    if (includeRightBound === void 0) { includeRightBound = false; }\n    return (offset >= node.offset && offset < (node.offset + node.length)) || includeRightBound && (offset === (node.offset + node.length));\n}\n/**\n * Finds the most inner node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.\n */\nexport function findNodeAtOffset(node, offset, includeRightBound) {\n    if (includeRightBound === void 0) { includeRightBound = false; }\n    if (contains(node, offset, includeRightBound)) {\n        var children = node.children;\n        if (Array.isArray(children)) {\n            for (var i = 0; i < children.length && children[i].offset <= offset; i++) {\n                var item = findNodeAtOffset(children[i], offset, includeRightBound);\n                if (item) {\n                    return item;\n                }\n            }\n        }\n        return node;\n    }\n    return undefined;\n}\n/**\n * Parses the given text and invokes the visitor functions for each object, array and literal reached.\n */\nexport function visit(text, visitor, options) {\n    if (options === void 0) { options = ParseOptions.DEFAULT; }\n    var _scanner = createScanner(text, false);\n    function toNoArgVisit(visitFunction) {\n        return visitFunction ? function () { return visitFunction(_scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()); } : function () { return true; };\n    }\n    function toOneArgVisit(visitFunction) {\n        return visitFunction ? function (arg) { return visitFunction(arg, _scanner.getTokenOffset(), _scanner.getTokenLength(), _scanner.getTokenStartLine(), _scanner.getTokenStartCharacter()); } : function () { return true; };\n    }\n    var onObjectBegin = toNoArgVisit(visitor.onObjectBegin), onObjectProperty = toOneArgVisit(visitor.onObjectProperty), onObjectEnd = toNoArgVisit(visitor.onObjectEnd), onArrayBegin = toNoArgVisit(visitor.onArrayBegin), onArrayEnd = toNoArgVisit(visitor.onArrayEnd), onLiteralValue = toOneArgVisit(visitor.onLiteralValue), onSeparator = toOneArgVisit(visitor.onSeparator), onComment = toNoArgVisit(visitor.onComment), onError = toOneArgVisit(visitor.onError);\n    var disallowComments = options && options.disallowComments;\n    var allowTrailingComma = options && options.allowTrailingComma;\n    function scanNext() {\n        while (true) {\n            var token = _scanner.scan();\n            switch (_scanner.getTokenError()) {\n                case 4 /* InvalidUnicode */:\n                    handleError(14 /* InvalidUnicode */);\n                    break;\n                case 5 /* InvalidEscapeCharacter */:\n                    handleError(15 /* InvalidEscapeCharacter */);\n                    break;\n                case 3 /* UnexpectedEndOfNumber */:\n                    handleError(13 /* UnexpectedEndOfNumber */);\n                    break;\n                case 1 /* UnexpectedEndOfComment */:\n                    if (!disallowComments) {\n                        handleError(11 /* UnexpectedEndOfComment */);\n                    }\n                    break;\n                case 2 /* UnexpectedEndOfString */:\n                    handleError(12 /* UnexpectedEndOfString */);\n                    break;\n                case 6 /* InvalidCharacter */:\n                    handleError(16 /* InvalidCharacter */);\n                    break;\n            }\n            switch (token) {\n                case 12 /* LineCommentTrivia */:\n                case 13 /* BlockCommentTrivia */:\n                    if (disallowComments) {\n                        handleError(10 /* InvalidCommentToken */);\n                    }\n                    else {\n                        onComment();\n                    }\n                    break;\n                case 16 /* Unknown */:\n                    handleError(1 /* InvalidSymbol */);\n                    break;\n                case 15 /* Trivia */:\n                case 14 /* LineBreakTrivia */:\n                    break;\n                default:\n                    return token;\n            }\n        }\n    }\n    function handleError(error, skipUntilAfter, skipUntil) {\n        if (skipUntilAfter === void 0) { skipUntilAfter = []; }\n        if (skipUntil === void 0) { skipUntil = []; }\n        onError(error);\n        if (skipUntilAfter.length + skipUntil.length > 0) {\n            var token = _scanner.getToken();\n            while (token !== 17 /* EOF */) {\n                if (skipUntilAfter.indexOf(token) !== -1) {\n                    scanNext();\n                    break;\n                }\n                else if (skipUntil.indexOf(token) !== -1) {\n                    break;\n                }\n                token = scanNext();\n            }\n        }\n    }\n    function parseString(isValue) {\n        var value = _scanner.getTokenValue();\n        if (isValue) {\n            onLiteralValue(value);\n        }\n        else {\n            onObjectProperty(value);\n        }\n        scanNext();\n        return true;\n    }\n    function parseLiteral() {\n        switch (_scanner.getToken()) {\n            case 11 /* NumericLiteral */:\n                var tokenValue = _scanner.getTokenValue();\n                var value = Number(tokenValue);\n                if (isNaN(value)) {\n                    handleError(2 /* InvalidNumberFormat */);\n                    value = 0;\n                }\n                onLiteralValue(value);\n                break;\n            case 7 /* NullKeyword */:\n                onLiteralValue(null);\n                break;\n            case 8 /* TrueKeyword */:\n                onLiteralValue(true);\n                break;\n            case 9 /* FalseKeyword */:\n                onLiteralValue(false);\n                break;\n            default:\n                return false;\n        }\n        scanNext();\n        return true;\n    }\n    function parseProperty() {\n        if (_scanner.getToken() !== 10 /* StringLiteral */) {\n            handleError(3 /* PropertyNameExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);\n            return false;\n        }\n        parseString(false);\n        if (_scanner.getToken() === 6 /* ColonToken */) {\n            onSeparator(':');\n            scanNext(); // consume colon\n            if (!parseValue()) {\n                handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);\n            }\n        }\n        else {\n            handleError(5 /* ColonExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);\n        }\n        return true;\n    }\n    function parseObject() {\n        onObjectBegin();\n        scanNext(); // consume open brace\n        var needsComma = false;\n        while (_scanner.getToken() !== 2 /* CloseBraceToken */ && _scanner.getToken() !== 17 /* EOF */) {\n            if (_scanner.getToken() === 5 /* CommaToken */) {\n                if (!needsComma) {\n                    handleError(4 /* ValueExpected */, [], []);\n                }\n                onSeparator(',');\n                scanNext(); // consume comma\n                if (_scanner.getToken() === 2 /* CloseBraceToken */ && allowTrailingComma) {\n                    break;\n                }\n            }\n            else if (needsComma) {\n                handleError(6 /* CommaExpected */, [], []);\n            }\n            if (!parseProperty()) {\n                handleError(4 /* ValueExpected */, [], [2 /* CloseBraceToken */, 5 /* CommaToken */]);\n            }\n            needsComma = true;\n        }\n        onObjectEnd();\n        if (_scanner.getToken() !== 2 /* CloseBraceToken */) {\n            handleError(7 /* CloseBraceExpected */, [2 /* CloseBraceToken */], []);\n        }\n        else {\n            scanNext(); // consume close brace\n        }\n        return true;\n    }\n    function parseArray() {\n        onArrayBegin();\n        scanNext(); // consume open bracket\n        var needsComma = false;\n        while (_scanner.getToken() !== 4 /* CloseBracketToken */ && _scanner.getToken() !== 17 /* EOF */) {\n            if (_scanner.getToken() === 5 /* CommaToken */) {\n                if (!needsComma) {\n                    handleError(4 /* ValueExpected */, [], []);\n                }\n                onSeparator(',');\n                scanNext(); // consume comma\n                if (_scanner.getToken() === 4 /* CloseBracketToken */ && allowTrailingComma) {\n                    break;\n                }\n            }\n            else if (needsComma) {\n                handleError(6 /* CommaExpected */, [], []);\n            }\n            if (!parseValue()) {\n                handleError(4 /* ValueExpected */, [], [4 /* CloseBracketToken */, 5 /* CommaToken */]);\n            }\n            needsComma = true;\n        }\n        onArrayEnd();\n        if (_scanner.getToken() !== 4 /* CloseBracketToken */) {\n            handleError(8 /* CloseBracketExpected */, [4 /* CloseBracketToken */], []);\n        }\n        else {\n            scanNext(); // consume close bracket\n        }\n        return true;\n    }\n    function parseValue() {\n        switch (_scanner.getToken()) {\n            case 3 /* OpenBracketToken */:\n                return parseArray();\n            case 1 /* OpenBraceToken */:\n                return parseObject();\n            case 10 /* StringLiteral */:\n                return parseString(true);\n            default:\n                return parseLiteral();\n        }\n    }\n    scanNext();\n    if (_scanner.getToken() === 17 /* EOF */) {\n        if (options.allowEmptyContent) {\n            return true;\n        }\n        handleError(4 /* ValueExpected */, [], []);\n        return false;\n    }\n    if (!parseValue()) {\n        handleError(4 /* ValueExpected */, [], []);\n        return false;\n    }\n    if (_scanner.getToken() !== 17 /* EOF */) {\n        handleError(9 /* EndOfFileExpected */, [], []);\n    }\n    return true;\n}\n/**\n * Takes JSON with JavaScript-style comments and remove\n * them. Optionally replaces every none-newline character\n * of comments with a replaceCharacter\n */\nexport function stripComments(text, replaceCh) {\n    var _scanner = createScanner(text), parts = [], kind, offset = 0, pos;\n    do {\n        pos = _scanner.getPosition();\n        kind = _scanner.scan();\n        switch (kind) {\n            case 12 /* LineCommentTrivia */:\n            case 13 /* BlockCommentTrivia */:\n            case 17 /* EOF */:\n                if (offset !== pos) {\n                    parts.push(text.substring(offset, pos));\n                }\n                if (replaceCh !== undefined) {\n                    parts.push(_scanner.getTokenValue().replace(/[^\\r\\n]/g, replaceCh));\n                }\n                offset = _scanner.getPosition();\n                break;\n        }\n    } while (kind !== 17 /* EOF */);\n    return parts.join('');\n}\nexport function getNodeType(value) {\n    switch (typeof value) {\n        case 'boolean': return 'boolean';\n        case 'number': return 'number';\n        case 'string': return 'string';\n        case 'object': {\n            if (!value) {\n                return 'null';\n            }\n            else if (Array.isArray(value)) {\n                return 'array';\n            }\n            return 'object';\n        }\n        default: return 'null';\n    }\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\n/**\n * Creates a JSON scanner on the given text.\n * If ignoreTrivia is set, whitespaces or comments are ignored.\n */\nexport function createScanner(text, ignoreTrivia) {\n    if (ignoreTrivia === void 0) { ignoreTrivia = false; }\n    var len = text.length;\n    var pos = 0, value = '', tokenOffset = 0, token = 16 /* Unknown */, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0 /* None */;\n    function scanHexDigits(count, exact) {\n        var digits = 0;\n        var value = 0;\n        while (digits < count || !exact) {\n            var ch = text.charCodeAt(pos);\n            if (ch >= 48 /* _0 */ && ch <= 57 /* _9 */) {\n                value = value * 16 + ch - 48 /* _0 */;\n            }\n            else if (ch >= 65 /* A */ && ch <= 70 /* F */) {\n                value = value * 16 + ch - 65 /* A */ + 10;\n            }\n            else if (ch >= 97 /* a */ && ch <= 102 /* f */) {\n                value = value * 16 + ch - 97 /* a */ + 10;\n            }\n            else {\n                break;\n            }\n            pos++;\n            digits++;\n        }\n        if (digits < count) {\n            value = -1;\n        }\n        return value;\n    }\n    function setPosition(newPosition) {\n        pos = newPosition;\n        value = '';\n        tokenOffset = 0;\n        token = 16 /* Unknown */;\n        scanError = 0 /* None */;\n    }\n    function scanNumber() {\n        var start = pos;\n        if (text.charCodeAt(pos) === 48 /* _0 */) {\n            pos++;\n        }\n        else {\n            pos++;\n            while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n            }\n        }\n        if (pos < text.length && text.charCodeAt(pos) === 46 /* dot */) {\n            pos++;\n            if (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n                while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                    pos++;\n                }\n            }\n            else {\n                scanError = 3 /* UnexpectedEndOfNumber */;\n                return text.substring(start, pos);\n            }\n        }\n        var end = pos;\n        if (pos < text.length && (text.charCodeAt(pos) === 69 /* E */ || text.charCodeAt(pos) === 101 /* e */)) {\n            pos++;\n            if (pos < text.length && text.charCodeAt(pos) === 43 /* plus */ || text.charCodeAt(pos) === 45 /* minus */) {\n                pos++;\n            }\n            if (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                pos++;\n                while (pos < text.length && isDigit(text.charCodeAt(pos))) {\n                    pos++;\n                }\n                end = pos;\n            }\n            else {\n                scanError = 3 /* UnexpectedEndOfNumber */;\n            }\n        }\n        return text.substring(start, end);\n    }\n    function scanString() {\n        var result = '', start = pos;\n        while (true) {\n            if (pos >= len) {\n                result += text.substring(start, pos);\n                scanError = 2 /* UnexpectedEndOfString */;\n                break;\n            }\n            var ch = text.charCodeAt(pos);\n            if (ch === 34 /* doubleQuote */) {\n                result += text.substring(start, pos);\n                pos++;\n                break;\n            }\n            if (ch === 92 /* backslash */) {\n                result += text.substring(start, pos);\n                pos++;\n                if (pos >= len) {\n                    scanError = 2 /* UnexpectedEndOfString */;\n                    break;\n                }\n                var ch2 = text.charCodeAt(pos++);\n                switch (ch2) {\n                    case 34 /* doubleQuote */:\n                        result += '\\\"';\n                        break;\n                    case 92 /* backslash */:\n                        result += '\\\\';\n                        break;\n                    case 47 /* slash */:\n                        result += '/';\n                        break;\n                    case 98 /* b */:\n                        result += '\\b';\n                        break;\n                    case 102 /* f */:\n                        result += '\\f';\n                        break;\n                    case 110 /* n */:\n                        result += '\\n';\n                        break;\n                    case 114 /* r */:\n                        result += '\\r';\n                        break;\n                    case 116 /* t */:\n                        result += '\\t';\n                        break;\n                    case 117 /* u */:\n                        var ch3 = scanHexDigits(4, true);\n                        if (ch3 >= 0) {\n                            result += String.fromCharCode(ch3);\n                        }\n                        else {\n                            scanError = 4 /* InvalidUnicode */;\n                        }\n                        break;\n                    default:\n                        scanError = 5 /* InvalidEscapeCharacter */;\n                }\n                start = pos;\n                continue;\n            }\n            if (ch >= 0 && ch <= 0x1f) {\n                if (isLineBreak(ch)) {\n                    result += text.substring(start, pos);\n                    scanError = 2 /* UnexpectedEndOfString */;\n                    break;\n                }\n                else {\n                    scanError = 6 /* InvalidCharacter */;\n                    // mark as error but continue with string\n                }\n            }\n            pos++;\n        }\n        return result;\n    }\n    function scanNext() {\n        value = '';\n        scanError = 0 /* None */;\n        tokenOffset = pos;\n        lineStartOffset = lineNumber;\n        prevTokenLineStartOffset = tokenLineStartOffset;\n        if (pos >= len) {\n            // at the end\n            tokenOffset = len;\n            return token = 17 /* EOF */;\n        }\n        var code = text.charCodeAt(pos);\n        // trivia: whitespace\n        if (isWhiteSpace(code)) {\n            do {\n                pos++;\n                value += String.fromCharCode(code);\n                code = text.charCodeAt(pos);\n            } while (isWhiteSpace(code));\n            return token = 15 /* Trivia */;\n        }\n        // trivia: newlines\n        if (isLineBreak(code)) {\n            pos++;\n            value += String.fromCharCode(code);\n            if (code === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {\n                pos++;\n                value += '\\n';\n            }\n            lineNumber++;\n            tokenLineStartOffset = pos;\n            return token = 14 /* LineBreakTrivia */;\n        }\n        switch (code) {\n            // tokens: []{}:,\n            case 123 /* openBrace */:\n                pos++;\n                return token = 1 /* OpenBraceToken */;\n            case 125 /* closeBrace */:\n                pos++;\n                return token = 2 /* CloseBraceToken */;\n            case 91 /* openBracket */:\n                pos++;\n                return token = 3 /* OpenBracketToken */;\n            case 93 /* closeBracket */:\n                pos++;\n                return token = 4 /* CloseBracketToken */;\n            case 58 /* colon */:\n                pos++;\n                return token = 6 /* ColonToken */;\n            case 44 /* comma */:\n                pos++;\n                return token = 5 /* CommaToken */;\n            // strings\n            case 34 /* doubleQuote */:\n                pos++;\n                value = scanString();\n                return token = 10 /* StringLiteral */;\n            // comments\n            case 47 /* slash */:\n                var start = pos - 1;\n                // Single-line comment\n                if (text.charCodeAt(pos + 1) === 47 /* slash */) {\n                    pos += 2;\n                    while (pos < len) {\n                        if (isLineBreak(text.charCodeAt(pos))) {\n                            break;\n                        }\n                        pos++;\n                    }\n                    value = text.substring(start, pos);\n                    return token = 12 /* LineCommentTrivia */;\n                }\n                // Multi-line comment\n                if (text.charCodeAt(pos + 1) === 42 /* asterisk */) {\n                    pos += 2;\n                    var safeLength = len - 1; // For lookahead.\n                    var commentClosed = false;\n                    while (pos < safeLength) {\n                        var ch = text.charCodeAt(pos);\n                        if (ch === 42 /* asterisk */ && text.charCodeAt(pos + 1) === 47 /* slash */) {\n                            pos += 2;\n                            commentClosed = true;\n                            break;\n                        }\n                        pos++;\n                        if (isLineBreak(ch)) {\n                            if (ch === 13 /* carriageReturn */ && text.charCodeAt(pos) === 10 /* lineFeed */) {\n                                pos++;\n                            }\n                            lineNumber++;\n                            tokenLineStartOffset = pos;\n                        }\n                    }\n                    if (!commentClosed) {\n                        pos++;\n                        scanError = 1 /* UnexpectedEndOfComment */;\n                    }\n                    value = text.substring(start, pos);\n                    return token = 13 /* BlockCommentTrivia */;\n                }\n                // just a single slash\n                value += String.fromCharCode(code);\n                pos++;\n                return token = 16 /* Unknown */;\n            // numbers\n            case 45 /* minus */:\n                value += String.fromCharCode(code);\n                pos++;\n                if (pos === len || !isDigit(text.charCodeAt(pos))) {\n                    return token = 16 /* Unknown */;\n                }\n            // found a minus, followed by a number so\n            // we fall through to proceed with scanning\n            // numbers\n            case 48 /* _0 */:\n            case 49 /* _1 */:\n            case 50 /* _2 */:\n            case 51 /* _3 */:\n            case 52 /* _4 */:\n            case 53 /* _5 */:\n            case 54 /* _6 */:\n            case 55 /* _7 */:\n            case 56 /* _8 */:\n            case 57 /* _9 */:\n                value += scanNumber();\n                return token = 11 /* NumericLiteral */;\n            // literals and unknown symbols\n            default:\n                // is a literal? Read the full word.\n                while (pos < len && isUnknownContentCharacter(code)) {\n                    pos++;\n                    code = text.charCodeAt(pos);\n                }\n                if (tokenOffset !== pos) {\n                    value = text.substring(tokenOffset, pos);\n                    // keywords: true, false, null\n                    switch (value) {\n                        case 'true': return token = 8 /* TrueKeyword */;\n                        case 'false': return token = 9 /* FalseKeyword */;\n                        case 'null': return token = 7 /* NullKeyword */;\n                    }\n                    return token = 16 /* Unknown */;\n                }\n                // some\n                value += String.fromCharCode(code);\n                pos++;\n                return token = 16 /* Unknown */;\n        }\n    }\n    function isUnknownContentCharacter(code) {\n        if (isWhiteSpace(code) || isLineBreak(code)) {\n            return false;\n        }\n        switch (code) {\n            case 125 /* closeBrace */:\n            case 93 /* closeBracket */:\n            case 123 /* openBrace */:\n            case 91 /* openBracket */:\n            case 34 /* doubleQuote */:\n            case 58 /* colon */:\n            case 44 /* comma */:\n            case 47 /* slash */:\n                return false;\n        }\n        return true;\n    }\n    function scanNextNonTrivia() {\n        var result;\n        do {\n            result = scanNext();\n        } while (result >= 12 /* LineCommentTrivia */ && result <= 15 /* Trivia */);\n        return result;\n    }\n    return {\n        setPosition: setPosition,\n        getPosition: function () { return pos; },\n        scan: ignoreTrivia ? scanNextNonTrivia : scanNext,\n        getToken: function () { return token; },\n        getTokenValue: function () { return value; },\n        getTokenOffset: function () { return tokenOffset; },\n        getTokenLength: function () { return pos - tokenOffset; },\n        getTokenStartLine: function () { return lineStartOffset; },\n        getTokenStartCharacter: function () { return tokenOffset - prevTokenLineStartOffset; },\n        getTokenError: function () { return scanError; },\n    };\n}\nfunction isWhiteSpace(ch) {\n    return ch === 32 /* space */ || ch === 9 /* tab */ || ch === 11 /* verticalTab */ || ch === 12 /* formFeed */ ||\n        ch === 160 /* nonBreakingSpace */ || ch === 5760 /* ogham */ || ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ ||\n        ch === 8239 /* narrowNoBreakSpace */ || ch === 8287 /* mathematicalSpace */ || ch === 12288 /* ideographicSpace */ || ch === 65279 /* byteOrderMark */;\n}\nfunction isLineBreak(ch) {\n    return ch === 10 /* lineFeed */ || ch === 13 /* carriageReturn */ || ch === 8232 /* lineSeparator */ || ch === 8233 /* paragraphSeparator */;\n}\nfunction isDigit(ch) {\n    return ch >= 48 /* _0 */ && ch <= 57 /* _9 */;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\n'use strict';\nimport * as formatter from './impl/format.js';\nimport * as edit from './impl/edit.js';\nimport * as scanner from './impl/scanner.js';\nimport * as parser from './impl/parser.js';\n/**\n * Creates a JSON scanner on the given text.\n * If ignoreTrivia is set, whitespaces or comments are ignored.\n */\nexport var createScanner = scanner.createScanner;\n/**\n * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index.\n */\nexport var getLocation = parser.getLocation;\n/**\n * Parses the given text and returns the object the JSON content represents. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n * Therefore, always check the errors list to find out if the input was valid.\n */\nexport var parse = parser.parse;\n/**\n * Parses the given text and returns a tree representation the JSON content. On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.\n */\nexport var parseTree = parser.parseTree;\n/**\n * Finds the node at the given path in a JSON DOM.\n */\nexport var findNodeAtLocation = parser.findNodeAtLocation;\n/**\n * Finds the innermost node at the given offset. If includeRightBound is set, also finds nodes that end at the given offset.\n */\nexport var findNodeAtOffset = parser.findNodeAtOffset;\n/**\n * Gets the JSON path of the given JSON DOM node\n */\nexport var getNodePath = parser.getNodePath;\n/**\n * Evaluates the JavaScript object of the given JSON DOM node\n */\nexport var getNodeValue = parser.getNodeValue;\n/**\n * Parses the given text and invokes the visitor functions for each object, array and literal reached.\n */\nexport var visit = parser.visit;\n/**\n * Takes JSON with JavaScript-style comments and remove\n * them. Optionally replaces every none-newline character\n * of comments with a replaceCharacter\n */\nexport var stripComments = parser.stripComments;\nexport function printParseErrorCode(code) {\n    switch (code) {\n        case 1 /* InvalidSymbol */: return 'InvalidSymbol';\n        case 2 /* InvalidNumberFormat */: return 'InvalidNumberFormat';\n        case 3 /* PropertyNameExpected */: return 'PropertyNameExpected';\n        case 4 /* ValueExpected */: return 'ValueExpected';\n        case 5 /* ColonExpected */: return 'ColonExpected';\n        case 6 /* CommaExpected */: return 'CommaExpected';\n        case 7 /* CloseBraceExpected */: return 'CloseBraceExpected';\n        case 8 /* CloseBracketExpected */: return 'CloseBracketExpected';\n        case 9 /* EndOfFileExpected */: return 'EndOfFileExpected';\n        case 10 /* InvalidCommentToken */: return 'InvalidCommentToken';\n        case 11 /* UnexpectedEndOfComment */: return 'UnexpectedEndOfComment';\n        case 12 /* UnexpectedEndOfString */: return 'UnexpectedEndOfString';\n        case 13 /* UnexpectedEndOfNumber */: return 'UnexpectedEndOfNumber';\n        case 14 /* InvalidUnicode */: return 'InvalidUnicode';\n        case 15 /* InvalidEscapeCharacter */: return 'InvalidEscapeCharacter';\n        case 16 /* InvalidCharacter */: return 'InvalidCharacter';\n    }\n    return '<unknown ParseErrorCode>';\n}\n/**\n * Computes the edits needed to format a JSON document.\n *\n * @param documentText The input text\n * @param range The range to format or `undefined` to format the full content\n * @param options The formatting options\n * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or\n * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of\n * text in the original document. However, multiple edits can have\n * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.\n * To apply edits to an input, you can use `applyEdits`.\n */\nexport function format(documentText, range, options) {\n    return formatter.format(documentText, range, options);\n}\n/**\n * Computes the edits needed to modify a value in the JSON document.\n *\n * @param documentText The input text\n * @param path The path of the value to change. The path represents either to the document root, a property or an array item.\n * If the path points to an non-existing property or item, it will be created.\n * @param value The new value for the specified property or item. If the value is undefined,\n * the property or item will be removed.\n * @param options Options\n * @returns A list of edit operations describing the formatting changes to the original document. Edits can be either inserts, replacements or\n * removals of text segments. All offsets refer to the original state of the document. No two edits must change or remove the same range of\n * text in the original document. However, multiple edits can have\n * the same offset, for example multiple inserts, or an insert followed by a remove or replace. The order in the array defines which edit is applied first.\n * To apply edits to an input, you can use `applyEdits`.\n */\nexport function modify(text, path, value, options) {\n    return edit.setProperty(text, path, value, options);\n}\n/**\n * Applies edits to a input string.\n */\nexport function applyEdits(text, edits) {\n    for (var i = edits.length - 1; i >= 0; i--) {\n        text = edit.applyEdit(text, edits[i]);\n    }\n    return text;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport * as json from './_deps/jsonc-parser/main.js';\nexport function createTokenizationSupport(supportComments) {\n    return {\n        getInitialState: function () { return new JSONState(null, null, false, null); },\n        tokenize: function (line, state, offsetDelta, stopAtOffset) {\n            return tokenize(supportComments, line, state, offsetDelta, stopAtOffset);\n        }\n    };\n}\nexport var TOKEN_DELIM_OBJECT = 'delimiter.bracket.json';\nexport var TOKEN_DELIM_ARRAY = 'delimiter.array.json';\nexport var TOKEN_DELIM_COLON = 'delimiter.colon.json';\nexport var TOKEN_DELIM_COMMA = 'delimiter.comma.json';\nexport var TOKEN_VALUE_BOOLEAN = 'keyword.json';\nexport var TOKEN_VALUE_NULL = 'keyword.json';\nexport var TOKEN_VALUE_STRING = 'string.value.json';\nexport var TOKEN_VALUE_NUMBER = 'number.json';\nexport var TOKEN_PROPERTY_NAME = 'string.key.json';\nexport var TOKEN_COMMENT_BLOCK = 'comment.block.json';\nexport var TOKEN_COMMENT_LINE = 'comment.line.json';\nvar ParentsStack = /** @class */ (function () {\n    function ParentsStack(parent, type) {\n        this.parent = parent;\n        this.type = type;\n    }\n    ParentsStack.pop = function (parents) {\n        if (parents) {\n            return parents.parent;\n        }\n        return null;\n    };\n    ParentsStack.push = function (parents, type) {\n        return new ParentsStack(parents, type);\n    };\n    ParentsStack.equals = function (a, b) {\n        if (!a && !b) {\n            return true;\n        }\n        if (!a || !b) {\n            return false;\n        }\n        while (a && b) {\n            if (a === b) {\n                return true;\n            }\n            if (a.type !== b.type) {\n                return false;\n            }\n            a = a.parent;\n            b = b.parent;\n        }\n        return true;\n    };\n    return ParentsStack;\n}());\nvar JSONState = /** @class */ (function () {\n    function JSONState(state, scanError, lastWasColon, parents) {\n        this._state = state;\n        this.scanError = scanError;\n        this.lastWasColon = lastWasColon;\n        this.parents = parents;\n    }\n    JSONState.prototype.clone = function () {\n        return new JSONState(this._state, this.scanError, this.lastWasColon, this.parents);\n    };\n    JSONState.prototype.equals = function (other) {\n        if (other === this) {\n            return true;\n        }\n        if (!other || !(other instanceof JSONState)) {\n            return false;\n        }\n        return (this.scanError === other.scanError &&\n            this.lastWasColon === other.lastWasColon &&\n            ParentsStack.equals(this.parents, other.parents));\n    };\n    JSONState.prototype.getStateData = function () {\n        return this._state;\n    };\n    JSONState.prototype.setStateData = function (state) {\n        this._state = state;\n    };\n    return JSONState;\n}());\nfunction tokenize(comments, line, state, offsetDelta, stopAtOffset) {\n    if (offsetDelta === void 0) { offsetDelta = 0; }\n    // handle multiline strings and block comments\n    var numberOfInsertedCharacters = 0;\n    var adjustOffset = false;\n    switch (state.scanError) {\n        case 2 /* UnexpectedEndOfString */:\n            line = '\"' + line;\n            numberOfInsertedCharacters = 1;\n            break;\n        case 1 /* UnexpectedEndOfComment */:\n            line = '/*' + line;\n            numberOfInsertedCharacters = 2;\n            break;\n    }\n    var scanner = json.createScanner(line);\n    var lastWasColon = state.lastWasColon;\n    var parents = state.parents;\n    var ret = {\n        tokens: [],\n        endState: state.clone()\n    };\n    while (true) {\n        var offset = offsetDelta + scanner.getPosition();\n        var type = '';\n        var kind = scanner.scan();\n        if (kind === 17 /* EOF */) {\n            break;\n        }\n        // Check that the scanner has advanced\n        if (offset === offsetDelta + scanner.getPosition()) {\n            throw new Error('Scanner did not advance, next 3 characters are: ' + line.substr(scanner.getPosition(), 3));\n        }\n        // In case we inserted /* or \" character, we need to\n        // adjust the offset of all tokens (except the first)\n        if (adjustOffset) {\n            offset -= numberOfInsertedCharacters;\n        }\n        adjustOffset = numberOfInsertedCharacters > 0;\n        // brackets and type\n        switch (kind) {\n            case 1 /* OpenBraceToken */:\n                parents = ParentsStack.push(parents, 0 /* Object */);\n                type = TOKEN_DELIM_OBJECT;\n                lastWasColon = false;\n                break;\n            case 2 /* CloseBraceToken */:\n                parents = ParentsStack.pop(parents);\n                type = TOKEN_DELIM_OBJECT;\n                lastWasColon = false;\n                break;\n            case 3 /* OpenBracketToken */:\n                parents = ParentsStack.push(parents, 1 /* Array */);\n                type = TOKEN_DELIM_ARRAY;\n                lastWasColon = false;\n                break;\n            case 4 /* CloseBracketToken */:\n                parents = ParentsStack.pop(parents);\n                type = TOKEN_DELIM_ARRAY;\n                lastWasColon = false;\n                break;\n            case 6 /* ColonToken */:\n                type = TOKEN_DELIM_COLON;\n                lastWasColon = true;\n                break;\n            case 5 /* CommaToken */:\n                type = TOKEN_DELIM_COMMA;\n                lastWasColon = false;\n                break;\n            case 8 /* TrueKeyword */:\n            case 9 /* FalseKeyword */:\n                type = TOKEN_VALUE_BOOLEAN;\n                lastWasColon = false;\n                break;\n            case 7 /* NullKeyword */:\n                type = TOKEN_VALUE_NULL;\n                lastWasColon = false;\n                break;\n            case 10 /* StringLiteral */:\n                var currentParent = parents ? parents.type : 0 /* Object */;\n                var inArray = currentParent === 1 /* Array */;\n                type = lastWasColon || inArray ? TOKEN_VALUE_STRING : TOKEN_PROPERTY_NAME;\n                lastWasColon = false;\n                break;\n            case 11 /* NumericLiteral */:\n                type = TOKEN_VALUE_NUMBER;\n                lastWasColon = false;\n                break;\n        }\n        // comments, iff enabled\n        if (comments) {\n            switch (kind) {\n                case 12 /* LineCommentTrivia */:\n                    type = TOKEN_COMMENT_LINE;\n                    break;\n                case 13 /* BlockCommentTrivia */:\n                    type = TOKEN_COMMENT_BLOCK;\n                    break;\n            }\n        }\n        ret.endState = new JSONState(state.getStateData(), scanner.getTokenError(), lastWasColon, parents);\n        ret.tokens.push({\n            startIndex: offset,\n            scopes: type\n        });\n    }\n    return ret;\n}\n","/*---------------------------------------------------------------------------------------------\n *  Copyright (c) Microsoft Corporation. All rights reserved.\n *  Licensed under the MIT License. See License.txt in the project root for license information.\n *--------------------------------------------------------------------------------------------*/\nimport { WorkerManager } from './workerManager.js';\nimport * as languageFeatures from './languageFeatures.js';\nimport { createTokenizationSupport } from './tokenization.js';\nimport { languages } from './fillers/monaco-editor-core.js';\nexport function setupMode(defaults) {\n    var disposables = [];\n    var providers = [];\n    var client = new WorkerManager(defaults);\n    disposables.push(client);\n    var worker = function () {\n        var uris = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            uris[_i] = arguments[_i];\n        }\n        return client.getLanguageServiceWorker.apply(client, uris);\n    };\n    function registerProviders() {\n        var languageId = defaults.languageId, modeConfiguration = defaults.modeConfiguration;\n        disposeAll(providers);\n        if (modeConfiguration.documentFormattingEdits) {\n            providers.push(languages.registerDocumentFormattingEditProvider(languageId, new languageFeatures.DocumentFormattingEditProvider(worker)));\n        }\n        if (modeConfiguration.documentRangeFormattingEdits) {\n            providers.push(languages.registerDocumentRangeFormattingEditProvider(languageId, new languageFeatures.DocumentRangeFormattingEditProvider(worker)));\n        }\n        if (modeConfiguration.completionItems) {\n            providers.push(languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker)));\n        }\n        if (modeConfiguration.hovers) {\n            providers.push(languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker)));\n        }\n        if (modeConfiguration.documentSymbols) {\n            providers.push(languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker)));\n        }\n        if (modeConfiguration.tokens) {\n            providers.push(languages.setTokensProvider(languageId, createTokenizationSupport(true)));\n        }\n        if (modeConfiguration.colors) {\n            providers.push(languages.registerColorProvider(languageId, new languageFeatures.DocumentColorAdapter(worker)));\n        }\n        if (modeConfiguration.foldingRanges) {\n            providers.push(languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker)));\n        }\n        if (modeConfiguration.diagnostics) {\n            providers.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults));\n        }\n        if (modeConfiguration.selectionRanges) {\n            providers.push(languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker)));\n        }\n    }\n    registerProviders();\n    disposables.push(languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration));\n    var modeConfiguration = defaults.modeConfiguration;\n    defaults.onDidChange(function (newDefaults) {\n        if (newDefaults.modeConfiguration !== modeConfiguration) {\n            modeConfiguration = newDefaults.modeConfiguration;\n            registerProviders();\n        }\n    });\n    disposables.push(asDisposable(providers));\n    return asDisposable(disposables);\n}\nfunction asDisposable(disposables) {\n    return { dispose: function () { return disposeAll(disposables); } };\n}\nfunction disposeAll(disposables) {\n    while (disposables.length) {\n        disposables.pop().dispose();\n    }\n}\nvar richEditConfiguration = {\n    wordPattern: /(-?\\d*\\.\\d\\w*)|([^\\[\\{\\]\\}\\:\\\"\\,\\s]+)/g,\n    comments: {\n        lineComment: '//',\n        blockComment: ['/*', '*/']\n    },\n    brackets: [\n        ['{', '}'],\n        ['[', ']']\n    ],\n    autoClosingPairs: [\n        { open: '{', close: '}', notIn: ['string'] },\n        { open: '[', close: ']', notIn: ['string'] },\n        { open: '\"', close: '\"', notIn: ['string'] }\n    ]\n};\n"],"sourceRoot":""}