Updates dockerfile

node_modules/yaml-language-server/lib/umd/languageservice/jsonASTTypes.d.ts

@@ -0,0 +1,48 @@
+import { Node, Pair } from 'yaml';
+export declare type YamlNode = Node | Pair;
+export declare type ASTNode = ObjectASTNode | PropertyASTNode | ArrayASTNode | StringASTNode | NumberASTNode | BooleanASTNode | NullASTNode;
+export interface BaseASTNode {
+    readonly type: 'object' | 'array' | 'property' | 'string' | 'number' | 'boolean' | 'null';
+    readonly parent?: ASTNode;
+    readonly offset: number;
+    readonly length: number;
+    readonly children?: ASTNode[];
+    readonly value?: string | boolean | number | null;
+    readonly internalNode: YamlNode;
+    location: string;
+    getNodeFromOffsetEndInclusive(offset: number): ASTNode;
+}
+export interface ObjectASTNode extends BaseASTNode {
+    readonly type: 'object';
+    readonly properties: PropertyASTNode[];
+    readonly children: ASTNode[];
+}
+export interface PropertyASTNode extends BaseASTNode {
+    readonly type: 'property';
+    readonly keyNode: StringASTNode;
+    readonly valueNode?: ASTNode;
+    readonly colonOffset?: number;
+    readonly children: ASTNode[];
+}
+export interface ArrayASTNode extends BaseASTNode {
+    readonly type: 'array';
+    readonly items: ASTNode[];
+    readonly children: ASTNode[];
+}
+export interface StringASTNode extends BaseASTNode {
+    readonly type: 'string';
+    readonly value: string;
+}
+export interface NumberASTNode extends BaseASTNode {
+    readonly type: 'number';
+    readonly value: number;
+    readonly isInteger: boolean;
+}
+export interface BooleanASTNode extends BaseASTNode {
+    readonly type: 'boolean';
+    readonly value: boolean;
+}
+export interface NullASTNode extends BaseASTNode {
+    readonly type: 'null';
+    readonly value: null;
+}

node_modules/yaml-language-server/lib/umd/languageservice/jsonASTTypes.js

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=jsonASTTypes.js.map

node_modules/yaml-language-server/lib/umd/languageservice/jsonASTTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonASTTypes.js","sourceRoot":"","sources":["../../../src/languageservice/jsonASTTypes.ts"],"names":[],"mappings":"AAAA;;;gGAGgG"}

node_modules/yaml-language-server/lib/umd/languageservice/jsonSchema.d.ts

@@ -0,0 +1,79 @@
+import { CompletionItemKind } from 'vscode-json-languageservice';
+import { SchemaVersions } from './yamlTypes';
+export declare type JSONSchemaRef = JSONSchema | boolean;
+export interface JSONSchema {
+    id?: string;
+    $id?: string;
+    $schema?: string;
+    url?: string;
+    type?: string | string[];
+    title?: string;
+    closestTitle?: string;
+    versions?: SchemaVersions;
+    default?: any;
+    definitions?: {
+        [name: string]: JSONSchema;
+    };
+    description?: string;
+    properties?: JSONSchemaMap;
+    patternProperties?: JSONSchemaMap;
+    additionalProperties?: boolean | JSONSchemaRef;
+    minProperties?: number;
+    maxProperties?: number;
+    dependencies?: JSONSchemaMap | {
+        [prop: string]: string[];
+    };
+    items?: JSONSchemaRef | JSONSchemaRef[];
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    additionalItems?: boolean | JSONSchemaRef;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean | number;
+    exclusiveMaximum?: boolean | number;
+    multipleOf?: number;
+    required?: string[];
+    $ref?: string;
+    _$ref?: string;
+    anyOf?: JSONSchemaRef[];
+    allOf?: JSONSchemaRef[];
+    oneOf?: JSONSchemaRef[];
+    not?: JSONSchemaRef;
+    enum?: any[];
+    format?: string;
+    const?: any;
+    contains?: JSONSchemaRef;
+    propertyNames?: JSONSchemaRef;
+    examples?: any[];
+    $comment?: string;
+    if?: JSONSchemaRef;
+    then?: JSONSchemaRef;
+    else?: JSONSchemaRef;
+    defaultSnippets?: {
+        label?: string;
+        description?: string;
+        markdownDescription?: string;
+        type?: string;
+        suggestionKind?: CompletionItemKind;
+        sortText?: string;
+        body?: any;
+        bodyText?: string;
+    }[];
+    errorMessage?: string;
+    patternErrorMessage?: string;
+    deprecationMessage?: string;
+    enumDescriptions?: string[];
+    markdownEnumDescriptions?: string[];
+    markdownDescription?: string;
+    doNotSuggest?: boolean;
+    allowComments?: boolean;
+    schemaSequence?: JSONSchema[];
+    filePatternAssociation?: string;
+}
+export interface JSONSchemaMap {
+    [name: string]: JSONSchemaRef;
+}

node_modules/yaml-language-server/lib/umd/languageservice/jsonSchema.js

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=jsonSchema.js.map

node_modules/yaml-language-server/lib/umd/languageservice/jsonSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonSchema.js","sourceRoot":"","sources":["../../../src/languageservice/jsonSchema.ts"],"names":[],"mappings":"AAAA;;;gGAGgG"}

node_modules/yaml-language-server/lib/umd/languageservice/parser/ast-converter.d.ts

@@ -0,0 +1,6 @@
+import { Document, LineCounter } from 'yaml';
+import { ASTNode, YamlNode } from '../jsonASTTypes';
+declare type NodeRange = [number, number, number];
+export declare function convertAST(parent: ASTNode, node: YamlNode, doc: Document, lineCounter: LineCounter): ASTNode | undefined;
+export declare function toOffsetLength(range: NodeRange): [number, number];
+export {};

node_modules/yaml-language-server/lib/umd/languageservice/parser/ast-converter.js

@@ -0,0 +1,183 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "yaml", "./jsonParser07"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.toOffsetLength = exports.convertAST = void 0;
+    const yaml_1 = require("yaml");
+    const jsonParser07_1 = require("./jsonParser07");
+    const maxRefCount = 1000;
+    let refDepth = 0;
+    const seenAlias = new Set();
+    function convertAST(parent, node, doc, lineCounter) {
+        if (!parent) {
+            // first invocation
+            refDepth = 0;
+        }
+        if (!node) {
+            return null;
+        }
+        if ((0, yaml_1.isMap)(node)) {
+            return convertMap(node, parent, doc, lineCounter);
+        }
+        if ((0, yaml_1.isPair)(node)) {
+            return convertPair(node, parent, doc, lineCounter);
+        }
+        if ((0, yaml_1.isSeq)(node)) {
+            return convertSeq(node, parent, doc, lineCounter);
+        }
+        if ((0, yaml_1.isScalar)(node)) {
+            return convertScalar(node, parent);
+        }
+        if ((0, yaml_1.isAlias)(node) && !seenAlias.has(node) && refDepth < maxRefCount) {
+            seenAlias.add(node);
+            const converted = convertAlias(node, parent, doc, lineCounter);
+            seenAlias.delete(node);
+            return converted;
+        }
+        else {
+            return;
+        }
+    }
+    exports.convertAST = convertAST;
+    function convertMap(node, parent, doc, lineCounter) {
+        let range;
+        if (node.flow && !node.range) {
+            range = collectFlowMapRange(node);
+        }
+        else {
+            range = node.range;
+        }
+        const result = new jsonParser07_1.ObjectASTNodeImpl(parent, node, ...toFixedOffsetLength(range, lineCounter));
+        for (const it of node.items) {
+            if ((0, yaml_1.isPair)(it)) {
+                result.properties.push(convertAST(result, it, doc, lineCounter));
+            }
+        }
+        return result;
+    }
+    function convertPair(node, parent, doc, lineCounter) {
+        const keyNode = node.key;
+        const valueNode = node.value;
+        const rangeStart = keyNode.range[0];
+        let rangeEnd = keyNode.range[1];
+        let nodeEnd = keyNode.range[2];
+        if (valueNode) {
+            rangeEnd = valueNode.range[1];
+            nodeEnd = valueNode.range[2];
+        }
+        // Pair does not return a range using the key/value ranges to fake one.
+        const result = new jsonParser07_1.PropertyASTNodeImpl(parent, node, ...toFixedOffsetLength([rangeStart, rangeEnd, nodeEnd], lineCounter));
+        if ((0, yaml_1.isAlias)(keyNode)) {
+            const keyAlias = new jsonParser07_1.StringASTNodeImpl(parent, keyNode, ...toOffsetLength(keyNode.range));
+            keyAlias.value = keyNode.source;
+            result.keyNode = keyAlias;
+        }
+        else {
+            result.keyNode = convertAST(result, keyNode, doc, lineCounter);
+        }
+        result.valueNode = convertAST(result, valueNode, doc, lineCounter);
+        return result;
+    }
+    function convertSeq(node, parent, doc, lineCounter) {
+        const result = new jsonParser07_1.ArrayASTNodeImpl(parent, node, ...toOffsetLength(node.range));
+        for (const it of node.items) {
+            if ((0, yaml_1.isNode)(it)) {
+                const convertedNode = convertAST(result, it, doc, lineCounter);
+                // due to recursion protection, convertAST may return undefined
+                if (convertedNode) {
+                    result.children.push(convertedNode);
+                }
+            }
+        }
+        return result;
+    }
+    function convertScalar(node, parent) {
+        if (node.value === null) {
+            return new jsonParser07_1.NullASTNodeImpl(parent, node, ...toOffsetLength(node.range));
+        }
+        switch (typeof node.value) {
+            case 'string': {
+                const result = new jsonParser07_1.StringASTNodeImpl(parent, node, ...toOffsetLength(node.range));
+                result.value = node.value;
+                return result;
+            }
+            case 'boolean':
+                return new jsonParser07_1.BooleanASTNodeImpl(parent, node, node.value, ...toOffsetLength(node.range));
+            case 'number': {
+                const result = new jsonParser07_1.NumberASTNodeImpl(parent, node, ...toOffsetLength(node.range));
+                result.value = node.value;
+                result.isInteger = Number.isInteger(result.value);
+                return result;
+            }
+            default: {
+                // fail safe converting, we need to return some node anyway
+                const result = new jsonParser07_1.StringASTNodeImpl(parent, node, ...toOffsetLength(node.range));
+                result.value = node.source;
+                return result;
+            }
+        }
+    }
+    function convertAlias(node, parent, doc, lineCounter) {
+        refDepth++;
+        const resolvedNode = node.resolve(doc);
+        if (resolvedNode) {
+            return convertAST(parent, resolvedNode, doc, lineCounter);
+        }
+        else {
+            const resultNode = new jsonParser07_1.StringASTNodeImpl(parent, node, ...toOffsetLength(node.range));
+            resultNode.value = node.source;
+            return resultNode;
+        }
+    }
+    function toOffsetLength(range) {
+        return [range[0], range[1] - range[0]];
+    }
+    exports.toOffsetLength = toOffsetLength;
+    /**
+     * Convert offsets to offset+length with fix length to not include '\n' character in some cases
+     * @param range the yaml ast range
+     * @param lineCounter the line counter
+     * @returns the offset and length
+     */
+    function toFixedOffsetLength(range, lineCounter) {
+        const start = lineCounter.linePos(range[0]);
+        const end = lineCounter.linePos(range[1]);
+        const result = [range[0], range[1] - range[0]];
+        // -1 as range may include '\n'
+        if (start.line !== end.line && (lineCounter.lineStarts.length !== end.line || end.col === 1)) {
+            result[1]--;
+        }
+        return result;
+    }
+    function collectFlowMapRange(node) {
+        let start = Number.MAX_SAFE_INTEGER;
+        let end = 0;
+        for (const it of node.items) {
+            if ((0, yaml_1.isPair)(it)) {
+                if ((0, yaml_1.isNode)(it.key)) {
+                    if (it.key.range && it.key.range[0] <= start) {
+                        start = it.key.range[0];
+                    }
+                }
+                if ((0, yaml_1.isNode)(it.value)) {
+                    if (it.value.range && it.value.range[2] >= end) {
+                        end = it.value.range[2];
+                    }
+                }
+            }
+        }
+        return [start, end, end];
+    }
+});
+//# sourceMappingURL=ast-converter.js.map

node_modules/yaml-language-server/lib/umd/languageservice/parser/custom-tag-provider.d.ts

@@ -0,0 +1,7 @@
+import { Tags } from 'yaml';
+/**
+ * Converts the tags from settings and adds known tags such as !include
+ * and returns Tags that can be used by the parser.
+ * @param customTags Tags for parser
+ */
+export declare function getCustomTags(customTags: string[]): Tags;

node_modules/yaml-language-server/lib/umd/languageservice/parser/custom-tag-provider.js

@@ -0,0 +1,72 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "yaml", "../utils/arrUtils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getCustomTags = void 0;
+    const yaml_1 = require("yaml");
+    const arrUtils_1 = require("../utils/arrUtils");
+    class CommonTagImpl {
+        constructor(tag, type) {
+            this.tag = tag;
+            this.type = type;
+        }
+        get collection() {
+            if (this.type === 'mapping') {
+                return 'map';
+            }
+            if (this.type === 'sequence') {
+                return 'seq';
+            }
+            return undefined;
+        }
+        resolve(value) {
+            if ((0, yaml_1.isMap)(value) && this.type === 'mapping') {
+                return value;
+            }
+            if ((0, yaml_1.isSeq)(value) && this.type === 'sequence') {
+                return value;
+            }
+            if (typeof value === 'string' && this.type === 'scalar') {
+                return value;
+            }
+        }
+    }
+    class IncludeTag {
+        constructor() {
+            this.tag = '!include';
+            this.type = 'scalar';
+        }
+        resolve(value, onError) {
+            if (value && value.length > 0 && value.trim()) {
+                return value;
+            }
+            onError('!include without value');
+        }
+    }
+    /**
+     * Converts the tags from settings and adds known tags such as !include
+     * and returns Tags that can be used by the parser.
+     * @param customTags Tags for parser
+     */
+    function getCustomTags(customTags) {
+        const tags = [];
+        const filteredTags = (0, arrUtils_1.filterInvalidCustomTags)(customTags);
+        for (const tag of filteredTags) {
+            const typeInfo = tag.split(' ');
+            const tagName = typeInfo[0];
+            const tagType = (typeInfo[1] && typeInfo[1].toLowerCase()) || 'scalar';
+            tags.push(new CommonTagImpl(tagName, tagType));
+        }
+        tags.push(new IncludeTag());
+        return tags;
+    }
+    exports.getCustomTags = getCustomTags;
+});
+//# sourceMappingURL=custom-tag-provider.js.map

node_modules/yaml-language-server/lib/umd/languageservice/parser/custom-tag-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-tag-provider.js","sourceRoot":"","sources":["../../../../src/languageservice/parser/custom-tag-provider.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,+BAA4D;IAC5D,gDAA4D;IAE5D,MAAM,aAAa;QAIjB,YAAY,GAAW,EAAE,IAAY;YACnC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;YACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACnB,CAAC;QACD,IAAI,UAAU;YACZ,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE;gBAC3B,OAAO,KAAK,CAAC;aACd;YACD,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE;gBAC5B,OAAO,KAAK,CAAC;aACd;YACD,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,CAAC,KAAiC;YACvC,IAAI,IAAA,YAAK,EAAC,KAAK,CAAC,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE;gBAC3C,OAAO,KAAK,CAAC;aACd;YACD,IAAI,IAAA,YAAK,EAAC,KAAK,CAAC,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE;gBAC5C,OAAO,KAAK,CAAC;aACd;YACD,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE;gBACvD,OAAO,KAAK,CAAC;aACd;QACH,CAAC;KACF;IAED,MAAM,UAAU;QAAhB;YACkB,QAAG,GAAG,UAAU,CAAC;YACjB,SAAI,GAAG,QAAQ,CAAC;QAUlC,CAAC;QANC,OAAO,CAAC,KAAa,EAAE,OAAkC;YACvD,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE;gBAC7C,OAAO,KAAK,CAAC;aACd;YACD,OAAO,CAAC,wBAAwB,CAAC,CAAC;QACpC,CAAC;KACF;IAED;;;;OAIG;IACH,SAAgB,aAAa,CAAC,UAAoB;QAChD,MAAM,IAAI,GAAG,EAAE,CAAC;QAChB,MAAM,YAAY,GAAG,IAAA,kCAAuB,EAAC,UAAU,CAAC,CAAC;QACzD,KAAK,MAAM,GAAG,IAAI,YAAY,EAAE;YAC9B,MAAM,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAChC,MAAM,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;YAC5B,MAAM,OAAO,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,IAAI,QAAQ,CAAC;YACvE,IAAI,CAAC,IAAI,CAAC,IAAI,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;SAChD;QACD,IAAI,CAAC,IAAI,CAAC,IAAI,UAAU,EAAE,CAAC,CAAC;QAC5B,OAAO,IAAI,CAAC;IACd,CAAC;IAXD,sCAWC"}

node_modules/yaml-language-server/lib/umd/languageservice/parser/isKubernetes.d.ts

@@ -0,0 +1,4 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import * as Parser from './jsonParser07';
+export declare function setKubernetesParserOption(jsonDocuments: Parser.JSONDocument[], option: boolean): void;
+export declare function isKubernetesAssociatedDocument(textDocument: TextDocument, paths: string[]): boolean;

node_modules/yaml-language-server/lib/umd/languageservice/parser/isKubernetes.js

@@ -0,0 +1,32 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../services/yamlSchemaService"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isKubernetesAssociatedDocument = exports.setKubernetesParserOption = void 0;
+    const yamlSchemaService_1 = require("../services/yamlSchemaService");
+    function setKubernetesParserOption(jsonDocuments, option) {
+        for (const jsonDoc of jsonDocuments) {
+            jsonDoc.isKubernetes = option;
+        }
+    }
+    exports.setKubernetesParserOption = setKubernetesParserOption;
+    function isKubernetesAssociatedDocument(textDocument, paths) {
+        for (const path in paths) {
+            const globPath = paths[path];
+            const fpa = new yamlSchemaService_1.FilePatternAssociation(globPath);
+            if (fpa.matchesPattern(textDocument.uri)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    exports.isKubernetesAssociatedDocument = isKubernetesAssociatedDocument;
+});
+//# sourceMappingURL=isKubernetes.js.map

node_modules/yaml-language-server/lib/umd/languageservice/parser/isKubernetes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isKubernetes.js","sourceRoot":"","sources":["../../../../src/languageservice/parser/isKubernetes.ts"],"names":[],"mappings":";;;;;;;;;;;;IAKA,qEAAuE;IAGvE,SAAgB,yBAAyB,CAAC,aAAoC,EAAE,MAAe;QAC7F,KAAK,MAAM,OAAO,IAAI,aAAa,EAAE;YACnC,OAAO,CAAC,YAAY,GAAG,MAAM,CAAC;SAC/B;IACH,CAAC;IAJD,8DAIC;IAED,SAAgB,8BAA8B,CAAC,YAA0B,EAAE,KAAe;QACxF,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;YACxB,MAAM,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;YAC7B,MAAM,GAAG,GAAG,IAAI,0CAAsB,CAAC,QAAQ,CAAC,CAAC;YAEjD,IAAI,GAAG,CAAC,cAAc,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE;gBACxC,OAAO,IAAI,CAAC;aACb;SACF;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAVD,wEAUC"}

node_modules/yaml-language-server/lib/umd/languageservice/parser/jsonParser07.d.ts

@@ -0,0 +1,185 @@
+import { JSONSchema, JSONSchemaRef } from '../jsonSchema';
+import { ASTNode, ObjectASTNode, ArrayASTNode, BooleanASTNode, NumberASTNode, StringASTNode, NullASTNode, PropertyASTNode, YamlNode } from '../jsonASTTypes';
+import { ErrorCode } from 'vscode-json-languageservice';
+import { Diagnostic, DiagnosticSeverity, Range } from 'vscode-languageserver-types';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Node, Pair } from 'yaml';
+export interface IRange {
+    offset: number;
+    length: number;
+}
+export declare const formats: {
+    'color-hex': {
+        errorMessage: string;
+        pattern: RegExp;
+    };
+    'date-time': {
+        errorMessage: string;
+        pattern: RegExp;
+    };
+    date: {
+        errorMessage: string;
+        pattern: RegExp;
+    };
+    time: {
+        errorMessage: string;
+        pattern: RegExp;
+    };
+    email: {
+        errorMessage: string;
+        pattern: RegExp;
+    };
+    ipv4: {
+        errorMessage: string;
+        pattern: RegExp;
+    };
+    ipv6: {
+        errorMessage: string;
+        pattern: RegExp;
+    };
+};
+export declare const YAML_SOURCE = "YAML";
+export declare enum ProblemType {
+    missingRequiredPropWarning = "missingRequiredPropWarning",
+    typeMismatchWarning = "typeMismatchWarning",
+    constWarning = "constWarning"
+}
+export declare const ProblemTypeMessages: Record<ProblemType, string>;
+export interface IProblem {
+    location: IRange;
+    severity: DiagnosticSeverity;
+    code?: ErrorCode;
+    message: string;
+    source?: string;
+    problemType?: ProblemType;
+    problemArgs?: string[];
+    schemaUri?: string[];
+    data?: Record<string, unknown>;
+}
+export declare abstract class ASTNodeImpl {
+    abstract readonly type: 'object' | 'property' | 'array' | 'number' | 'boolean' | 'null' | 'string';
+    offset: number;
+    length: number;
+    readonly parent: ASTNode;
+    location: string;
+    readonly internalNode: YamlNode;
+    constructor(parent: ASTNode, internalNode: YamlNode, offset: number, length?: number);
+    getNodeFromOffsetEndInclusive(offset: number): ASTNode;
+    get children(): ASTNode[];
+    toString(): string;
+}
+export declare class NullASTNodeImpl extends ASTNodeImpl implements NullASTNode {
+    type: 'null';
+    value: any;
+    constructor(parent: ASTNode, internalNode: Node, offset: number, length?: number);
+}
+export declare class BooleanASTNodeImpl extends ASTNodeImpl implements BooleanASTNode {
+    type: 'boolean';
+    value: boolean;
+    constructor(parent: ASTNode, internalNode: Node, boolValue: boolean, offset: number, length?: number);
+}
+export declare class ArrayASTNodeImpl extends ASTNodeImpl implements ArrayASTNode {
+    type: 'array';
+    items: ASTNode[];
+    constructor(parent: ASTNode, internalNode: Node, offset: number, length?: number);
+    get children(): ASTNode[];
+}
+export declare class NumberASTNodeImpl extends ASTNodeImpl implements NumberASTNode {
+    type: 'number';
+    isInteger: boolean;
+    value: number;
+    constructor(parent: ASTNode, internalNode: Node, offset: number, length?: number);
+}
+export declare class StringASTNodeImpl extends ASTNodeImpl implements StringASTNode {
+    type: 'string';
+    value: string;
+    constructor(parent: ASTNode, internalNode: Node, offset: number, length?: number);
+}
+export declare class PropertyASTNodeImpl extends ASTNodeImpl implements PropertyASTNode {
+    type: 'property';
+    keyNode: StringASTNode;
+    valueNode: ASTNode;
+    colonOffset: number;
+    constructor(parent: ObjectASTNode, internalNode: Pair, offset: number, length?: number);
+    get children(): ASTNode[];
+}
+export declare class ObjectASTNodeImpl extends ASTNodeImpl implements ObjectASTNode {
+    type: 'object';
+    properties: PropertyASTNode[];
+    constructor(parent: ASTNode, internalNode: Node, offset: number, length?: number);
+    get children(): ASTNode[];
+}
+export declare function asSchema(schema: JSONSchemaRef): JSONSchema | undefined;
+export interface JSONDocumentConfig {
+    collectComments?: boolean;
+}
+export interface IApplicableSchema {
+    node: ASTNode;
+    inverted?: boolean;
+    schema: JSONSchema;
+}
+export declare enum EnumMatch {
+    Key = 0,
+    Enum = 1
+}
+export interface ISchemaCollector {
+    schemas: IApplicableSchema[];
+    add(schema: IApplicableSchema): void;
+    merge(other: ISchemaCollector): void;
+    include(node: ASTNode): boolean;
+    newSub(): ISchemaCollector;
+}
+export declare class ValidationResult {
+    problems: IProblem[];
+    propertiesMatches: number;
+    propertiesValueMatches: number;
+    primaryValueMatches: number;
+    enumValueMatch: boolean;
+    enumValues: any[];
+    constructor(isKubernetes: boolean);
+    hasProblems(): boolean;
+    mergeAll(validationResults: ValidationResult[]): void;
+    merge(validationResult: ValidationResult): void;
+    mergeEnumValues(validationResult: ValidationResult): void;
+    /**
+     * Merge multiple warnings with same problemType together
+     * @param subValidationResult another possible result
+     */
+    mergeWarningGeneric(subValidationResult: ValidationResult, problemTypesToMerge: ProblemType[]): void;
+    mergePropertyMatch(propertyValidationResult: ValidationResult): void;
+    private mergeSources;
+    compareGeneric(other: ValidationResult): number;
+    compareKubernetes(other: ValidationResult): number;
+}
+export declare function newJSONDocument(root: ASTNode, diagnostics?: Diagnostic[]): JSONDocument;
+export declare function getNodeValue(node: ASTNode): any;
+export declare function contains(node: ASTNode, offset: number, includeRightBound?: boolean): boolean;
+export declare function findNodeAtOffset(node: ASTNode, offset: number, includeRightBound: boolean): ASTNode;
+export declare class JSONDocument {
+    readonly root: ASTNode;
+    readonly syntaxErrors: Diagnostic[];
+    readonly comments: Range[];
+    isKubernetes: boolean;
+    disableAdditionalProperties: boolean;
+    uri: string;
+    constructor(root: ASTNode, syntaxErrors?: Diagnostic[], comments?: Range[]);
+    getNodeFromOffset(offset: number, includeRightBound?: boolean): ASTNode | undefined;
+    getNodeFromOffsetEndInclusive(offset: number): ASTNode;
+    visit(visitor: (node: ASTNode) => boolean): void;
+    validate(textDocument: TextDocument, schema: JSONSchema): Diagnostic[];
+    /**
+     * This method returns the list of applicable schemas
+     *
+     * currently used @param didCallFromAutoComplete flag to differentiate the method call, when it is from auto complete
+     * then user still types something and skip the validation for timebeing untill completed.
+     * On https://github.com/redhat-developer/yaml-language-server/pull/719 the auto completes need to populate the list of enum string which matches to the enum
+     * and on https://github.com/redhat-developer/vscode-yaml/issues/803 the validation should throw the error based on the enum string.
+     *
+     * @param schema schema
+     * @param focusOffset  offsetValue
+     * @param exclude excluded Node
+     * @param didCallFromAutoComplete true if method called from AutoComplete
+     * @returns array of applicable schemas
+     */
+    getMatchingSchemas(schema: JSONSchema, focusOffset?: number, exclude?: ASTNode, didCallFromAutoComplete?: boolean): IApplicableSchema[];
+}

node_modules/yaml-language-server/lib/umd/languageservice/parser/scalar-type.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parse a boolean according to the specification
+ *
+ * Return:
+ *  true if its a true value
+ *  false if its a false value
+ */
+export declare function parseYamlBoolean(input: string): boolean;

node_modules/yaml-language-server/lib/umd/languageservice/parser/scalar-type.js

@@ -0,0 +1,31 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parseYamlBoolean = void 0;
+    /**
+     * Parse a boolean according to the specification
+     *
+     * Return:
+     *  true if its a true value
+     *  false if its a false value
+     */
+    function parseYamlBoolean(input) {
+        if (['true', 'True', 'TRUE', 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON'].lastIndexOf(input) >= 0) {
+            return true;
+        }
+        else if (['false', 'False', 'FALSE', 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'].lastIndexOf(input) >= 0) {
+            return false;
+        }
+        throw `Invalid boolean "${input}"`;
+    }
+    exports.parseYamlBoolean = parseYamlBoolean;
+});
+//# sourceMappingURL=scalar-type.js.map

node_modules/yaml-language-server/lib/umd/languageservice/parser/scalar-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalar-type.js","sourceRoot":"","sources":["../../../../src/languageservice/parser/scalar-type.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA;;;;;;OAMG;IACH,SAAgB,gBAAgB,CAAC,KAAa;QAC5C,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;YACrG,OAAO,IAAI,CAAC;SACb;aAAM,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;YAC/G,OAAO,KAAK,CAAC;SACd;QACD,MAAM,oBAAoB,KAAK,GAAG,CAAC;IACrC,CAAC;IAPD,4CAOC"}

node_modules/yaml-language-server/lib/umd/languageservice/parser/yaml-documents.d.ts

@@ -0,0 +1,71 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { JSONDocument } from './jsonParser07';
+import { Document, LineCounter } from 'yaml';
+import { ASTNode, YamlNode } from '../jsonASTTypes';
+import { ParserOptions } from './yamlParser07';
+import { YAMLDocDiagnostic } from '../utils/parseUtils';
+import { TextBuffer } from '../utils/textBuffer';
+import { Token } from 'yaml/dist/parse/cst';
+/**
+ * These documents are collected into a final YAMLDocument
+ * and passed to the `parseYAML` caller.
+ */
+export declare class SingleYAMLDocument extends JSONDocument {
+    private lineCounter;
+    private _internalDocument;
+    root: ASTNode;
+    currentDocIndex: number;
+    private _lineComments;
+    constructor(lineCounter?: LineCounter);
+    /**
+     * Create a deep copy of this document
+     */
+    clone(): SingleYAMLDocument;
+    private collectLineComments;
+    /**
+     * Updates the internal AST tree of the object
+     * from the internal node. This is call whenever the
+     * internalDocument is set but also can be called to
+     * reflect any changes on the underlying document
+     * without setting the internalDocument explicitly.
+     */
+    updateFromInternalDocument(): void;
+    set internalDocument(document: Document);
+    get internalDocument(): Document;
+    get lineComments(): string[];
+    set lineComments(val: string[]);
+    get errors(): YAMLDocDiagnostic[];
+    get warnings(): YAMLDocDiagnostic[];
+    getNodeFromPosition(positionOffset: number, textBuffer: TextBuffer, configuredIndentation?: number): [YamlNode | undefined, boolean];
+    findClosestNode(offset: number, textBuffer: TextBuffer, configuredIndentation?: number): YamlNode;
+    private getProperParentByIndentation;
+    getParent(node: YamlNode): YamlNode | undefined;
+}
+/**
+ * Contains the SingleYAMLDocuments, to be passed
+ * to the `parseYAML` caller.
+ */
+export declare class YAMLDocument {
+    documents: SingleYAMLDocument[];
+    tokens: Token[];
+    private errors;
+    private warnings;
+    constructor(documents: SingleYAMLDocument[], tokens: Token[]);
+}
+export declare class YamlDocuments {
+    private cache;
+    /**
+     * Get cached YAMLDocument
+     * @param document TextDocument to parse
+     * @param parserOptions YAML parserOptions
+     * @param addRootObject if true and document is empty add empty object {} to force schema usage
+     * @returns the YAMLDocument
+     */
+    getYamlDocument(document: TextDocument, parserOptions?: ParserOptions, addRootObject?: boolean): YAMLDocument;
+    /**
+     * For test purpose only!
+     */
+    clear(): void;
+    private ensureCache;
+}
+export declare const yamlDocumentsCache: YamlDocuments;

node_modules/yaml-language-server/lib/umd/languageservice/parser/yaml-documents.js

@@ -0,0 +1,274 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./jsonParser07", "yaml", "./yamlParser07", "vscode-json-languageservice", "./ast-converter", "../utils/arrUtils", "../utils/astUtils", "../utils/strings"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.yamlDocumentsCache = exports.YamlDocuments = exports.YAMLDocument = exports.SingleYAMLDocument = void 0;
+    const jsonParser07_1 = require("./jsonParser07");
+    const yaml_1 = require("yaml");
+    const yamlParser07_1 = require("./yamlParser07");
+    const vscode_json_languageservice_1 = require("vscode-json-languageservice");
+    const ast_converter_1 = require("./ast-converter");
+    const arrUtils_1 = require("../utils/arrUtils");
+    const astUtils_1 = require("../utils/astUtils");
+    const strings_1 = require("../utils/strings");
+    /**
+     * These documents are collected into a final YAMLDocument
+     * and passed to the `parseYAML` caller.
+     */
+    class SingleYAMLDocument extends jsonParser07_1.JSONDocument {
+        constructor(lineCounter) {
+            super(null, []);
+            this.lineCounter = lineCounter;
+        }
+        /**
+         * Create a deep copy of this document
+         */
+        clone() {
+            const copy = new SingleYAMLDocument(this.lineCounter);
+            copy.isKubernetes = this.isKubernetes;
+            copy.disableAdditionalProperties = this.disableAdditionalProperties;
+            copy.uri = this.uri;
+            copy.currentDocIndex = this.currentDocIndex;
+            copy._lineComments = this.lineComments.slice();
+            // this will re-create root node
+            copy.internalDocument = this._internalDocument.clone();
+            return copy;
+        }
+        collectLineComments() {
+            this._lineComments = [];
+            if (this._internalDocument.commentBefore) {
+                const comments = this._internalDocument.commentBefore.split('\n');
+                comments.forEach((comment) => this._lineComments.push(`#${comment}`));
+            }
+            (0, yaml_1.visit)(this.internalDocument, (_key, node) => {
+                if (node?.commentBefore) {
+                    const comments = node?.commentBefore.split('\n');
+                    comments.forEach((comment) => this._lineComments.push(`#${comment}`));
+                }
+                if (node?.comment) {
+                    this._lineComments.push(`#${node.comment}`);
+                }
+            });
+            if (this._internalDocument.comment) {
+                this._lineComments.push(`#${this._internalDocument.comment}`);
+            }
+        }
+        /**
+         * Updates the internal AST tree of the object
+         * from the internal node. This is call whenever the
+         * internalDocument is set but also can be called to
+         * reflect any changes on the underlying document
+         * without setting the internalDocument explicitly.
+         */
+        updateFromInternalDocument() {
+            this.root = (0, ast_converter_1.convertAST)(null, this._internalDocument.contents, this._internalDocument, this.lineCounter);
+        }
+        set internalDocument(document) {
+            this._internalDocument = document;
+            this.updateFromInternalDocument();
+        }
+        get internalDocument() {
+            return this._internalDocument;
+        }
+        get lineComments() {
+            if (!this._lineComments) {
+                this.collectLineComments();
+            }
+            return this._lineComments;
+        }
+        set lineComments(val) {
+            this._lineComments = val;
+        }
+        get errors() {
+            return this.internalDocument.errors.map(YAMLErrorToYamlDocDiagnostics);
+        }
+        get warnings() {
+            return this.internalDocument.warnings.map(YAMLErrorToYamlDocDiagnostics);
+        }
+        getNodeFromPosition(positionOffset, textBuffer, configuredIndentation) {
+            const position = textBuffer.getPosition(positionOffset);
+            const lineContent = textBuffer.getLineContent(position.line);
+            if (lineContent.trim().length === 0) {
+                return [this.findClosestNode(positionOffset, textBuffer, configuredIndentation), true];
+            }
+            const textAfterPosition = lineContent.substring(position.character);
+            const spacesAfterPositionMatch = textAfterPosition.match(/^([ ]+)\n?$/);
+            const areOnlySpacesAfterPosition = !!spacesAfterPositionMatch;
+            const countOfSpacesAfterPosition = spacesAfterPositionMatch?.[1].length;
+            let closestNode;
+            (0, yaml_1.visit)(this.internalDocument, (key, node) => {
+                if (!node) {
+                    return;
+                }
+                const range = node.range;
+                if (!range) {
+                    return;
+                }
+                const isNullNodeOnTheLine = () => areOnlySpacesAfterPosition &&
+                    positionOffset + countOfSpacesAfterPosition === range[2] &&
+                    (0, yaml_1.isScalar)(node) &&
+                    node.value === null;
+                if ((range[0] <= positionOffset && range[1] >= positionOffset) || isNullNodeOnTheLine()) {
+                    closestNode = node;
+                }
+                else {
+                    return yaml_1.visit.SKIP;
+                }
+            });
+            return [closestNode, false];
+        }
+        findClosestNode(offset, textBuffer, configuredIndentation) {
+            let offsetDiff = this.internalDocument.range[2];
+            let maxOffset = this.internalDocument.range[0];
+            let closestNode;
+            (0, yaml_1.visit)(this.internalDocument, (key, node) => {
+                if (!node) {
+                    return;
+                }
+                const range = node.range;
+                if (!range) {
+                    return;
+                }
+                const diff = range[1] - offset;
+                if (maxOffset <= range[0] && diff <= 0 && Math.abs(diff) <= offsetDiff) {
+                    offsetDiff = Math.abs(diff);
+                    maxOffset = range[0];
+                    closestNode = node;
+                }
+            });
+            const position = textBuffer.getPosition(offset);
+            const lineContent = textBuffer.getLineContent(position.line);
+            const indentation = (0, strings_1.getIndentation)(lineContent, position.character);
+            if ((0, yaml_1.isScalar)(closestNode) && closestNode.value === null) {
+                return closestNode;
+            }
+            if (indentation === position.character) {
+                closestNode = this.getProperParentByIndentation(indentation, closestNode, textBuffer, '', configuredIndentation);
+            }
+            return closestNode;
+        }
+        getProperParentByIndentation(indentation, node, textBuffer, currentLine, configuredIndentation, rootParent) {
+            if (!node) {
+                return this.internalDocument.contents;
+            }
+            configuredIndentation = !configuredIndentation ? 2 : configuredIndentation;
+            if ((0, yaml_1.isNode)(node) && node.range) {
+                const position = textBuffer.getPosition(node.range[0]);
+                const lineContent = textBuffer.getLineContent(position.line);
+                currentLine = currentLine === '' ? lineContent.trim() : currentLine;
+                if (currentLine.startsWith('-') && indentation === configuredIndentation && currentLine === lineContent.trim()) {
+                    position.character += indentation;
+                }
+                if (position.character > indentation && position.character > 0) {
+                    const parent = this.getParent(node);
+                    if (parent) {
+                        return this.getProperParentByIndentation(indentation, parent, textBuffer, currentLine, configuredIndentation, rootParent);
+                    }
+                }
+                else if (position.character < indentation) {
+                    const parent = this.getParent(node);
+                    if ((0, yaml_1.isPair)(parent) && (0, yaml_1.isNode)(parent.value)) {
+                        return parent.value;
+                    }
+                    else if ((0, yaml_1.isPair)(rootParent) && (0, yaml_1.isNode)(rootParent.value)) {
+                        return rootParent.value;
+                    }
+                }
+                else {
+                    return node;
+                }
+            }
+            else if ((0, yaml_1.isPair)(node)) {
+                rootParent = node;
+                const parent = this.getParent(node);
+                return this.getProperParentByIndentation(indentation, parent, textBuffer, currentLine, configuredIndentation, rootParent);
+            }
+            return node;
+        }
+        getParent(node) {
+            return (0, astUtils_1.getParent)(this.internalDocument, node);
+        }
+    }
+    exports.SingleYAMLDocument = SingleYAMLDocument;
+    /**
+     * Contains the SingleYAMLDocuments, to be passed
+     * to the `parseYAML` caller.
+     */
+    class YAMLDocument {
+        constructor(documents, tokens) {
+            this.documents = documents;
+            this.tokens = tokens;
+            this.errors = [];
+            this.warnings = [];
+        }
+    }
+    exports.YAMLDocument = YAMLDocument;
+    class YamlDocuments {
+        constructor() {
+            // a mapping of URIs to cached documents
+            this.cache = new Map();
+        }
+        /**
+         * Get cached YAMLDocument
+         * @param document TextDocument to parse
+         * @param parserOptions YAML parserOptions
+         * @param addRootObject if true and document is empty add empty object {} to force schema usage
+         * @returns the YAMLDocument
+         */
+        getYamlDocument(document, parserOptions, addRootObject = false) {
+            this.ensureCache(document, parserOptions ?? yamlParser07_1.defaultOptions, addRootObject);
+            return this.cache.get(document.uri).document;
+        }
+        /**
+         * For test purpose only!
+         */
+        clear() {
+            this.cache.clear();
+        }
+        ensureCache(document, parserOptions, addRootObject) {
+            const key = document.uri;
+            if (!this.cache.has(key)) {
+                this.cache.set(key, { version: -1, document: new YAMLDocument([], []), parserOptions: yamlParser07_1.defaultOptions });
+            }
+            const cacheEntry = this.cache.get(key);
+            if (cacheEntry.version !== document.version ||
+                (parserOptions.customTags && !(0, arrUtils_1.isArrayEqual)(cacheEntry.parserOptions.customTags, parserOptions.customTags))) {
+                let text = document.getText();
+                // if text is contains only whitespace wrap all text in object to force schema selection
+                if (addRootObject && !/\S/.test(text)) {
+                    text = `{${text}}`;
+                }
+                const doc = (0, yamlParser07_1.parse)(text, parserOptions, document);
+                cacheEntry.document = doc;
+                cacheEntry.version = document.version;
+                cacheEntry.parserOptions = parserOptions;
+            }
+        }
+    }
+    exports.YamlDocuments = YamlDocuments;
+    exports.yamlDocumentsCache = new YamlDocuments();
+    function YAMLErrorToYamlDocDiagnostics(error) {
+        return {
+            message: error.message,
+            location: {
+                start: error.pos[0],
+                end: error.pos[1],
+                toLineEnd: true,
+            },
+            severity: 1,
+            code: vscode_json_languageservice_1.ErrorCode.Undefined,
+        };
+    }
+});
+//# sourceMappingURL=yaml-documents.js.map

node_modules/yaml-language-server/lib/umd/languageservice/parser/yamlParser07.d.ts

@@ -0,0 +1,15 @@
+import { YAMLDocument, SingleYAMLDocument } from './yaml-documents';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export { YAMLDocument, SingleYAMLDocument };
+export declare type YamlVersion = '1.1' | '1.2';
+export interface ParserOptions {
+    customTags: string[];
+    yamlVersion: YamlVersion;
+}
+export declare const defaultOptions: ParserOptions;
+/**
+ * `yaml-ast-parser-custom-tags` parses the AST and
+ * returns YAML AST nodes, which are then formatted
+ * for consumption via the language server.
+ */
+export declare function parse(text: string, parserOptions?: ParserOptions, document?: TextDocument): YAMLDocument;

node_modules/yaml-language-server/lib/umd/languageservice/parser/yamlParser07.js

@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Copyright (c) Adam Voss. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "yaml", "./yaml-documents", "./custom-tag-provider", "../utils/textBuffer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parse = exports.defaultOptions = exports.SingleYAMLDocument = exports.YAMLDocument = void 0;
+    const yaml_1 = require("yaml");
+    const yaml_documents_1 = require("./yaml-documents");
+    Object.defineProperty(exports, "YAMLDocument", { enumerable: true, get: function () { return yaml_documents_1.YAMLDocument; } });
+    Object.defineProperty(exports, "SingleYAMLDocument", { enumerable: true, get: function () { return yaml_documents_1.SingleYAMLDocument; } });
+    const custom_tag_provider_1 = require("./custom-tag-provider");
+    const textBuffer_1 = require("../utils/textBuffer");
+    exports.defaultOptions = {
+        customTags: [],
+        yamlVersion: '1.2',
+    };
+    /**
+     * `yaml-ast-parser-custom-tags` parses the AST and
+     * returns YAML AST nodes, which are then formatted
+     * for consumption via the language server.
+     */
+    function parse(text, parserOptions = exports.defaultOptions, document) {
+        const options = {
+            strict: false,
+            customTags: (0, custom_tag_provider_1.getCustomTags)(parserOptions.customTags),
+            version: parserOptions.yamlVersion ?? exports.defaultOptions.yamlVersion,
+            keepSourceTokens: true,
+        };
+        const composer = new yaml_1.Composer(options);
+        const lineCounter = new yaml_1.LineCounter();
+        let isLastLineEmpty = false;
+        if (document) {
+            const textBuffer = new textBuffer_1.TextBuffer(document);
+            const position = textBuffer.getPosition(text.length);
+            const lineContent = textBuffer.getLineContent(position.line);
+            isLastLineEmpty = lineContent.trim().length === 0;
+        }
+        const parser = isLastLineEmpty ? new yaml_1.Parser() : new yaml_1.Parser(lineCounter.addNewLine);
+        const tokens = parser.parse(text);
+        const tokensArr = Array.from(tokens);
+        const docs = composer.compose(tokensArr, true, text.length);
+        // Generate the SingleYAMLDocs from the AST nodes
+        const yamlDocs = Array.from(docs, (doc) => parsedDocToSingleYAMLDocument(doc, lineCounter));
+        // Consolidate the SingleYAMLDocs
+        return new yaml_documents_1.YAMLDocument(yamlDocs, tokensArr);
+    }
+    exports.parse = parse;
+    function parsedDocToSingleYAMLDocument(parsedDoc, lineCounter) {
+        const syd = new yaml_documents_1.SingleYAMLDocument(lineCounter);
+        syd.internalDocument = parsedDoc;
+        return syd;
+    }
+});
+//# sourceMappingURL=yamlParser07.js.map

node_modules/yaml-language-server/lib/umd/languageservice/parser/yamlParser07.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlParser07.js","sourceRoot":"","sources":["../../../../src/languageservice/parser/yamlParser07.ts"],"names":[],"mappings":"AAAA;;;;gGAIgG;;;;;;;;;;;;;IAEhG,+BAA6G;IAC7G,qDAAoE;IAK3D,6FALA,6BAAY,OAKA;IAAE,mGALA,mCAAkB,OAKA;IAJzC,+DAAsD;IAEtD,oDAAiD;IASpC,QAAA,cAAc,GAAkB;QAC3C,UAAU,EAAE,EAAE;QACd,WAAW,EAAE,KAAK;KACnB,CAAC;IACF;;;;OAIG;IACH,SAAgB,KAAK,CAAC,IAAY,EAAE,gBAA+B,sBAAc,EAAE,QAAuB;QACxG,MAAM,OAAO,GAAmD;YAC9D,MAAM,EAAE,KAAK;YACb,UAAU,EAAE,IAAA,mCAAa,EAAC,aAAa,CAAC,UAAU,CAAC;YACnD,OAAO,EAAE,aAAa,CAAC,WAAW,IAAI,sBAAc,CAAC,WAAW;YAChE,gBAAgB,EAAE,IAAI;SACvB,CAAC;QACF,MAAM,QAAQ,GAAG,IAAI,eAAQ,CAAC,OAAO,CAAC,CAAC;QACvC,MAAM,WAAW,GAAG,IAAI,kBAAW,EAAE,CAAC;QACtC,IAAI,eAAe,GAAG,KAAK,CAAC;QAC5B,IAAI,QAAQ,EAAE;YACZ,MAAM,UAAU,GAAG,IAAI,uBAAU,CAAC,QAAQ,CAAC,CAAC;YAC5C,MAAM,QAAQ,GAAG,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrD,MAAM,WAAW,GAAG,UAAU,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC7D,eAAe,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAC;SACnD;QACD,MAAM,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,IAAI,aAAM,EAAE,CAAC,CAAC,CAAC,IAAI,aAAM,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;QACnF,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAClC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrC,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;QAC5D,iDAAiD;QACjD,MAAM,QAAQ,GAAyB,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,6BAA6B,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC;QAElH,iCAAiC;QACjC,OAAO,IAAI,6BAAY,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IAC/C,CAAC;IAzBD,sBAyBC;IAED,SAAS,6BAA6B,CAAC,SAAmB,EAAE,WAAwB;QAClF,MAAM,GAAG,GAAG,IAAI,mCAAkB,CAAC,WAAW,CAAC,CAAC;QAChD,GAAG,CAAC,gBAAgB,GAAG,SAAS,CAAC;QACjC,OAAO,GAAG,CAAC;IACb,CAAC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/documentSymbols.d.ts

@@ -0,0 +1,12 @@
+import { SymbolInformation, DocumentSymbol } from 'vscode-languageserver-types';
+import { YAMLSchemaService } from './yamlSchemaService';
+import { DocumentSymbolsContext } from 'vscode-json-languageservice/lib/umd/jsonLanguageTypes';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Telemetry } from '../telemetry';
+export declare class YAMLDocumentSymbols {
+    private readonly telemetry?;
+    private jsonDocumentSymbols;
+    constructor(schemaService: YAMLSchemaService, telemetry?: Telemetry);
+    findDocumentSymbols(document: TextDocument, context?: DocumentSymbolsContext): SymbolInformation[];
+    findHierarchicalDocumentSymbols(document: TextDocument, context?: DocumentSymbolsContext): DocumentSymbol[];
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/documentSymbols.js

@@ -0,0 +1,82 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-json-languageservice/lib/umd/services/jsonDocumentSymbols", "../parser/yaml-documents", "yaml", "../utils/objects"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.YAMLDocumentSymbols = void 0;
+    const jsonDocumentSymbols_1 = require("vscode-json-languageservice/lib/umd/services/jsonDocumentSymbols");
+    const yaml_documents_1 = require("../parser/yaml-documents");
+    const yaml_1 = require("yaml");
+    const objects_1 = require("../utils/objects");
+    class YAMLDocumentSymbols {
+        constructor(schemaService, telemetry) {
+            this.telemetry = telemetry;
+            this.jsonDocumentSymbols = new jsonDocumentSymbols_1.JSONDocumentSymbols(schemaService);
+            // override 'getKeyLabel' to handle complex mapping
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.jsonDocumentSymbols.getKeyLabel = (property) => {
+                const keyNode = property.keyNode.internalNode;
+                let name = '';
+                if ((0, yaml_1.isMap)(keyNode)) {
+                    name = '{}';
+                }
+                else if ((0, yaml_1.isSeq)(keyNode)) {
+                    name = '[]';
+                }
+                else {
+                    name = keyNode.source;
+                }
+                return name;
+            };
+        }
+        findDocumentSymbols(document, context = { resultLimit: Number.MAX_VALUE }) {
+            let results = [];
+            try {
+                const doc = yaml_documents_1.yamlDocumentsCache.getYamlDocument(document);
+                if (!doc || doc['documents'].length === 0) {
+                    return null;
+                }
+                for (const yamlDoc of doc['documents']) {
+                    if (yamlDoc.root) {
+                        results = results.concat(this.jsonDocumentSymbols.findDocumentSymbols(document, yamlDoc, context));
+                    }
+                }
+            }
+            catch (err) {
+                this.telemetry?.sendError('yaml.documentSymbols.error', { error: (0, objects_1.convertErrorToTelemetryMsg)(err) });
+            }
+            return results;
+        }
+        findHierarchicalDocumentSymbols(document, context = { resultLimit: Number.MAX_VALUE }) {
+            let results = [];
+            try {
+                const doc = yaml_documents_1.yamlDocumentsCache.getYamlDocument(document);
+                if (!doc || doc['documents'].length === 0) {
+                    return null;
+                }
+                for (const yamlDoc of doc['documents']) {
+                    if (yamlDoc.root) {
+                        results = results.concat(this.jsonDocumentSymbols.findDocumentSymbols2(document, yamlDoc, context));
+                    }
+                }
+            }
+            catch (err) {
+                this.telemetry?.sendError('yaml.hierarchicalDocumentSymbols.error', { error: (0, objects_1.convertErrorToTelemetryMsg)(err) });
+            }
+            return results;
+        }
+    }
+    exports.YAMLDocumentSymbols = YAMLDocumentSymbols;
+});
+//# sourceMappingURL=documentSymbols.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/documentSymbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentSymbols.js","sourceRoot":"","sources":["../../../../src/languageservice/services/documentSymbols.ts"],"names":[],"mappings":"AAAA;;;;gGAIgG;;;;;;;;;;;;;IAIhG,0GAAuG;IAGvG,6DAA8D;IAE9D,+BAA0C;IAC1C,8CAA8D;IAE9D,MAAa,mBAAmB;QAG9B,YAAY,aAAgC,EAAmB,SAAqB;YAArB,cAAS,GAAT,SAAS,CAAY;YAClF,IAAI,CAAC,mBAAmB,GAAG,IAAI,yCAAmB,CAAC,aAAa,CAAC,CAAC;YAElE,mDAAmD;YACnD,8DAA8D;YAC9D,IAAI,CAAC,mBAAmB,CAAC,WAAW,GAAG,CAAC,QAAa,EAAE,EAAE;gBACvD,MAAM,OAAO,GAAS,QAAQ,CAAC,OAAO,CAAC,YAAY,CAAC;gBACpD,IAAI,IAAI,GAAG,EAAE,CAAC;gBACd,IAAI,IAAA,YAAK,EAAC,OAAO,CAAC,EAAE;oBAClB,IAAI,GAAG,IAAI,CAAC;iBACb;qBAAM,IAAI,IAAA,YAAK,EAAC,OAAO,CAAC,EAAE;oBACzB,IAAI,GAAG,IAAI,CAAC;iBACb;qBAAM;oBACL,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;iBACvB;gBACD,OAAO,IAAI,CAAC;YACd,CAAC,CAAC;QACJ,CAAC;QAEM,mBAAmB,CACxB,QAAsB,EACtB,UAAkC,EAAE,WAAW,EAAE,MAAM,CAAC,SAAS,EAAE;YAEnE,IAAI,OAAO,GAAG,EAAE,CAAC;YACjB,IAAI;gBACF,MAAM,GAAG,GAAG,mCAAkB,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;gBACzD,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;oBACzC,OAAO,IAAI,CAAC;iBACb;gBAED,KAAK,MAAM,OAAO,IAAI,GAAG,CAAC,WAAW,CAAC,EAAE;oBACtC,IAAI,OAAO,CAAC,IAAI,EAAE;wBAChB,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;qBACpG;iBACF;aACF;YAAC,OAAO,GAAG,EAAE;gBACZ,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,4BAA4B,EAAE,EAAE,KAAK,EAAE,IAAA,oCAA0B,EAAC,GAAG,CAAC,EAAE,CAAC,CAAC;aACrG;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;QAEM,+BAA+B,CACpC,QAAsB,EACtB,UAAkC,EAAE,WAAW,EAAE,MAAM,CAAC,SAAS,EAAE;YAEnE,IAAI,OAAO,GAAG,EAAE,CAAC;YACjB,IAAI;gBACF,MAAM,GAAG,GAAG,mCAAkB,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;gBACzD,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,WAAW,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;oBACzC,OAAO,IAAI,CAAC;iBACb;gBAED,KAAK,MAAM,OAAO,IAAI,GAAG,CAAC,WAAW,CAAC,EAAE;oBACtC,IAAI,OAAO,CAAC,IAAI,EAAE;wBAChB,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;qBACrG;iBACF;aACF;YAAC,OAAO,GAAG,EAAE;gBACZ,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,wCAAwC,EAAE,EAAE,KAAK,EAAE,IAAA,oCAA0B,EAAC,GAAG,CAAC,EAAE,CAAC,CAAC;aACjH;YAED,OAAO,OAAO,CAAC;QACjB,CAAC;KACF;IAlED,kDAkEC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/modelineUtil.d.ts

@@ -0,0 +1,9 @@
+import { SingleYAMLDocument } from '../parser/yamlParser07';
+import { JSONDocument } from '../parser/jsonParser07';
+/**
+ * Retrieve schema if declared as modeline.
+ * Public for testing purpose, not part of the API.
+ * @param doc
+ */
+export declare function getSchemaFromModeline(doc: SingleYAMLDocument | JSONDocument): string;
+export declare function isModeline(lineText: string): boolean;

node_modules/yaml-language-server/lib/umd/languageservice/services/modelineUtil.js

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../parser/yamlParser07"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isModeline = exports.getSchemaFromModeline = void 0;
+    const yamlParser07_1 = require("../parser/yamlParser07");
+    /**
+     * Retrieve schema if declared as modeline.
+     * Public for testing purpose, not part of the API.
+     * @param doc
+     */
+    function getSchemaFromModeline(doc) {
+        if (doc instanceof yamlParser07_1.SingleYAMLDocument) {
+            const yamlLanguageServerModeline = doc.lineComments.find((lineComment) => {
+                return isModeline(lineComment);
+            });
+            if (yamlLanguageServerModeline != undefined) {
+                const schemaMatchs = yamlLanguageServerModeline.match(/\$schema=\S+/g);
+                if (schemaMatchs !== null && schemaMatchs.length >= 1) {
+                    if (schemaMatchs.length >= 2) {
+                        console.log('Several $schema attributes have been found on the yaml-language-server modeline. The first one will be picked.');
+                    }
+                    return schemaMatchs[0].substring('$schema='.length);
+                }
+            }
+        }
+        return undefined;
+    }
+    exports.getSchemaFromModeline = getSchemaFromModeline;
+    function isModeline(lineText) {
+        const matchModeline = lineText.match(/^#\s+yaml-language-server\s*:/g);
+        return matchModeline !== null && matchModeline.length === 1;
+    }
+    exports.isModeline = isModeline;
+});
+//# sourceMappingURL=modelineUtil.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/modelineUtil.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modelineUtil.js","sourceRoot":"","sources":["../../../../src/languageservice/services/modelineUtil.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAEhG,yDAA4D;IAG5D;;;;OAIG;IACH,SAAgB,qBAAqB,CAAC,GAAsC;QAC1E,IAAI,GAAG,YAAY,iCAAkB,EAAE;YACrC,MAAM,0BAA0B,GAAG,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE;gBACvE,OAAO,UAAU,CAAC,WAAW,CAAC,CAAC;YACjC,CAAC,CAAC,CAAC;YACH,IAAI,0BAA0B,IAAI,SAAS,EAAE;gBAC3C,MAAM,YAAY,GAAG,0BAA0B,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;gBACvE,IAAI,YAAY,KAAK,IAAI,IAAI,YAAY,CAAC,MAAM,IAAI,CAAC,EAAE;oBACrD,IAAI,YAAY,CAAC,MAAM,IAAI,CAAC,EAAE;wBAC5B,OAAO,CAAC,GAAG,CACT,gHAAgH,CACjH,CAAC;qBACH;oBACD,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;iBACrD;aACF;SACF;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAlBD,sDAkBC;IAED,SAAgB,UAAU,CAAC,QAAgB;QACzC,MAAM,aAAa,GAAG,QAAQ,CAAC,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACvE,OAAO,aAAa,KAAK,IAAI,IAAI,aAAa,CAAC,MAAM,KAAK,CAAC,CAAC;IAC9D,CAAC;IAHD,gCAGC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/schemaRequestHandler.d.ts

@@ -0,0 +1,12 @@
+import { URI } from 'vscode-uri';
+import { Connection, WorkspaceFolder } from 'vscode-languageserver';
+import { WorkspaceContextService } from '../yamlLanguageService';
+export interface FileSystem {
+    readFile(fsPath: string, encoding?: string): Promise<string>;
+}
+/**
+ * Handles schema content requests given the schema URI
+ * @param uri can be a local file, vscode request, http(s) request or a custom request
+ */
+export declare const schemaRequestHandler: (connection: Connection, uri: string, workspaceFolders: WorkspaceFolder[], workspaceRoot: URI, useVSCodeContentRequest: boolean, fs: FileSystem) => Promise<string>;
+export declare const workspaceContext: WorkspaceContextService;

node_modules/yaml-language-server/lib/umd/languageservice/services/schemaRequestHandler.js

@@ -0,0 +1,76 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-uri", "request-light", "url", "../../requestTypes", "../utils/paths"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.workspaceContext = exports.schemaRequestHandler = void 0;
+    const vscode_uri_1 = require("vscode-uri");
+    const request_light_1 = require("request-light");
+    const URL = require("url");
+    const requestTypes_1 = require("../../requestTypes");
+    const paths_1 = require("../utils/paths");
+    /**
+     * Handles schema content requests given the schema URI
+     * @param uri can be a local file, vscode request, http(s) request or a custom request
+     */
+    const schemaRequestHandler = (connection, uri, workspaceFolders, workspaceRoot, useVSCodeContentRequest, fs) => {
+        if (!uri) {
+            return Promise.reject('No schema specified');
+        }
+        // If the requested schema URI is a relative file path
+        // Convert it into a proper absolute path URI
+        if ((0, paths_1.isRelativePath)(uri)) {
+            uri = (0, paths_1.relativeToAbsolutePath)(workspaceFolders, workspaceRoot, uri);
+        }
+        let scheme = vscode_uri_1.URI.parse(uri).scheme.toLowerCase();
+        // test if uri is windows path, ie starts with 'c:\'
+        if (/^[a-z]:[\\/]/i.test(uri)) {
+            const winUri = vscode_uri_1.URI.file(uri);
+            scheme = winUri.scheme.toLowerCase();
+            uri = winUri.toString();
+        }
+        // If the requested schema is a local file, read and return the file contents
+        if (scheme === 'file') {
+            const fsPath = vscode_uri_1.URI.parse(uri).fsPath;
+            return fs.readFile(fsPath, 'UTF-8').catch(() => {
+                // If there was an error reading the file, return empty error message
+                // Otherwise return the file contents as a string
+                return '';
+            });
+        }
+        // HTTP(S) requests are sent and the response result is either the schema content or an error
+        if (scheme === 'http' || scheme === 'https') {
+            // If we are running inside of VSCode we need to make a content request. This content request
+            // will make it so that schemas behind VPN's will resolve correctly
+            if (useVSCodeContentRequest) {
+                return connection.sendRequest(requestTypes_1.VSCodeContentRequest.type, uri).then((responseText) => {
+                    return responseText;
+                }, (error) => {
+                    return Promise.reject(error.message);
+                });
+            }
+            // Send the HTTP(S) schema content request and return the result
+            const headers = { 'Accept-Encoding': 'gzip, deflate' };
+            return (0, request_light_1.xhr)({ url: uri, followRedirects: 5, headers }).then((response) => {
+                return response.responseText;
+            }, (error) => {
+                return Promise.reject(error.responseText || (0, request_light_1.getErrorStatusDescription)(error.status) || error.toString());
+            });
+        }
+        // Neither local file nor vscode, nor HTTP(S) schema request, so send it off as a custom request
+        return connection.sendRequest(requestTypes_1.CustomSchemaContentRequest.type, uri);
+    };
+    exports.schemaRequestHandler = schemaRequestHandler;
+    exports.workspaceContext = {
+        resolveRelativePath: (relativePath, resource) => {
+            return URL.resolve(resource, relativePath);
+        },
+    };
+});
+//# sourceMappingURL=schemaRequestHandler.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/schemaRequestHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaRequestHandler.js","sourceRoot":"","sources":["../../../../src/languageservice/services/schemaRequestHandler.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,2CAAiC;IAEjC,iDAA4E;IAC5E,2BAA2B;IAC3B,qDAAsF;IACtF,0CAAwE;IAOxE;;;OAGG;IACI,MAAM,oBAAoB,GAAG,CAClC,UAAsB,EACtB,GAAW,EACX,gBAAmC,EACnC,aAAkB,EAClB,uBAAgC,EAChC,EAAc,EACG,EAAE;QACnB,IAAI,CAAC,GAAG,EAAE;YACR,OAAO,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;SAC9C;QAED,sDAAsD;QACtD,6CAA6C;QAC7C,IAAI,IAAA,sBAAc,EAAC,GAAG,CAAC,EAAE;YACvB,GAAG,GAAG,IAAA,8BAAsB,EAAC,gBAAgB,EAAE,aAAa,EAAE,GAAG,CAAC,CAAC;SACpE;QAED,IAAI,MAAM,GAAG,gBAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;QAEjD,oDAAoD;QACpD,IAAI,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;YAC7B,MAAM,MAAM,GAAG,gBAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC7B,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;YACrC,GAAG,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;SACzB;QAED,6EAA6E;QAC7E,IAAI,MAAM,KAAK,MAAM,EAAE;YACrB,MAAM,MAAM,GAAG,gBAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;YAErC,OAAO,EAAE,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;gBAC7C,qEAAqE;gBACrE,iDAAiD;gBACjD,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC,CAAC;SACJ;QAED,6FAA6F;QAC7F,IAAI,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,OAAO,EAAE;YAC3C,6FAA6F;YAC7F,mEAAmE;YACnE,IAAI,uBAAuB,EAAE;gBAC3B,OAAO,UAAU,CAAC,WAAW,CAAC,mCAAoB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,IAAI,CAChE,CAAC,YAAY,EAAE,EAAE;oBACf,OAAO,YAAY,CAAC;gBACtB,CAAC,EACD,CAAC,KAAK,EAAE,EAAE;oBACR,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBACvC,CAAC,CACiB,CAAC;aACtB;YAED,gEAAgE;YAChE,MAAM,OAAO,GAAG,EAAE,iBAAiB,EAAE,eAAe,EAAE,CAAC;YACvD,OAAO,IAAA,mBAAG,EAAC,EAAE,GAAG,EAAE,GAAG,EAAE,eAAe,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,IAAI,CACxD,CAAC,QAAQ,EAAE,EAAE;gBACX,OAAO,QAAQ,CAAC,YAAY,CAAC;YAC/B,CAAC,EACD,CAAC,KAAkB,EAAE,EAAE;gBACrB,OAAO,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,YAAY,IAAI,IAAA,yCAAyB,EAAC,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;YAC3G,CAAC,CACF,CAAC;SACH;QAED,gGAAgG;QAChG,OAAO,UAAU,CAAC,WAAW,CAAC,yCAA0B,CAAC,IAAI,EAAE,GAAG,CAAoB,CAAC;IACzF,CAAC,CAAC;IAnEW,QAAA,oBAAoB,wBAmE/B;IAEW,QAAA,gBAAgB,GAA4B;QACvD,mBAAmB,EAAE,CAAC,YAAoB,EAAE,QAAgB,EAAE,EAAE;YAC9D,OAAO,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAC7C,CAAC;KACF,CAAC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/map-key-order.d.ts

@@ -0,0 +1,7 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Diagnostic } from 'vscode-languageserver-types';
+import { SingleYAMLDocument } from '../../parser/yaml-documents';
+import { AdditionalValidator } from './types';
+export declare class MapKeyOrderValidator implements AdditionalValidator {
+    validate(document: TextDocument, yamlDoc: SingleYAMLDocument): Diagnostic[];
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/map-key-order.js

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "yaml"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MapKeyOrderValidator = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const yaml_1 = require("yaml");
+    class MapKeyOrderValidator {
+        validate(document, yamlDoc) {
+            const result = [];
+            (0, yaml_1.visit)(yamlDoc.internalDocument, (key, node) => {
+                if ((0, yaml_1.isMap)(node)) {
+                    for (let i = 1; i < node.items.length; i++) {
+                        if (compare(node.items[i - 1], node.items[i]) > 0) {
+                            const range = createRange(document, node.items[i - 1]);
+                            result.push(vscode_languageserver_types_1.Diagnostic.create(range, `Wrong ordering of key "${node.items[i - 1].key}" in mapping`, vscode_languageserver_types_1.DiagnosticSeverity.Error, 'mapKeyOrder'));
+                        }
+                    }
+                }
+            });
+            return result;
+        }
+    }
+    exports.MapKeyOrderValidator = MapKeyOrderValidator;
+    function createRange(document, node) {
+        const start = node?.srcToken.start[0]?.offset ?? node?.srcToken?.key.offset ?? node?.srcToken?.sep[0]?.offset;
+        const end = node?.srcToken?.value.offset ||
+            node?.srcToken?.sep[0]?.offset ||
+            node?.srcToken?.key.offset ||
+            node?.srcToken.start[node.srcToken.start.length - 1]?.offset;
+        return vscode_languageserver_types_1.Range.create(document.positionAt(start), document.positionAt(end));
+    }
+    function compare(thiz, that) {
+        const thatKey = String(that.key);
+        const thisKey = String(thiz.key);
+        return thisKey.localeCompare(thatKey);
+    }
+});
+//# sourceMappingURL=map-key-order.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/map-key-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-key-order.js","sourceRoot":"","sources":["../../../../../src/languageservice/services/validation/map-key-order.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAGhG,6EAAoF;IAGpF,+BAA0C;IAE1C,MAAa,oBAAoB;QAC/B,QAAQ,CAAC,QAAsB,EAAE,OAA2B;YAC1D,MAAM,MAAM,GAAG,EAAE,CAAC;YAElB,IAAA,YAAK,EAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;gBAC5C,IAAI,IAAA,YAAK,EAAC,IAAI,CAAC,EAAE;oBACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;wBAC1C,IAAI,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE;4BACjD,MAAM,KAAK,GAAG,WAAW,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;4BACvD,MAAM,CAAC,IAAI,CACT,wCAAU,CAAC,MAAM,CACf,KAAK,EACL,0BAA0B,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,cAAc,EAC7D,gDAAkB,CAAC,KAAK,EACxB,aAAa,CACd,CACF,CAAC;yBACH;qBACF;iBACF;YACH,CAAC,CAAC,CAAC;YAEH,OAAO,MAAM,CAAC;QAChB,CAAC;KACF;IAxBD,oDAwBC;IAED,SAAS,WAAW,CAAC,QAAsB,EAAE,IAAU;QACrD,MAAM,KAAK,GAAG,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM,IAAI,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAC9G,MAAM,GAAG,GACP,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC,MAAM;YAC5B,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM;YAC9B,IAAI,EAAE,QAAQ,EAAE,GAAG,CAAC,MAAM;YAC1B,IAAI,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC;QAC/D,OAAO,mCAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5E,CAAC;IAED,SAAS,OAAO,CAAC,IAAU,EAAE,IAAU;QACrC,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjC,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACjC,OAAO,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/types.d.ts

@@ -0,0 +1,6 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Diagnostic } from 'vscode-languageserver-types';
+import { SingleYAMLDocument } from '../../parser/yaml-documents';
+export interface AdditionalValidator {
+    validate(document: TextDocument, yamlDoc: SingleYAMLDocument): Diagnostic[];
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/types.js

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=types.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../src/languageservice/services/validation/types.ts"],"names":[],"mappings":"AAAA;;;gGAGgG"}

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/unused-anchors.d.ts

@@ -0,0 +1,8 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Diagnostic } from 'vscode-languageserver-types';
+import { SingleYAMLDocument } from '../../parser/yaml-documents';
+import { AdditionalValidator } from './types';
+export declare class UnusedAnchorsValidator implements AdditionalValidator {
+    validate(document: TextDocument, yamlDoc: SingleYAMLDocument): Diagnostic[];
+    private getAnchorNode;
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/unused-anchors.js

@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "yaml", "../../../languageservice/utils/astUtils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.UnusedAnchorsValidator = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const yaml_1 = require("yaml");
+    const astUtils_1 = require("../../../languageservice/utils/astUtils");
+    class UnusedAnchorsValidator {
+        validate(document, yamlDoc) {
+            const result = [];
+            const anchors = new Set();
+            const usedAnchors = new Set();
+            const anchorParent = new Map();
+            (0, yaml_1.visit)(yamlDoc.internalDocument, (key, node, path) => {
+                if (!(0, yaml_1.isNode)(node)) {
+                    return;
+                }
+                if (((0, yaml_1.isCollection)(node) || (0, yaml_1.isScalar)(node)) && node.anchor) {
+                    anchors.add(node);
+                    anchorParent.set(node, path[path.length - 1]);
+                }
+                if ((0, yaml_1.isAlias)(node)) {
+                    usedAnchors.add(node.resolve(yamlDoc.internalDocument));
+                }
+            });
+            for (const anchor of anchors) {
+                if (!usedAnchors.has(anchor)) {
+                    const aToken = this.getAnchorNode(anchorParent.get(anchor), anchor);
+                    if (aToken) {
+                        const range = vscode_languageserver_types_1.Range.create(document.positionAt(aToken.offset), document.positionAt(aToken.offset + aToken.source.length));
+                        const warningDiagnostic = vscode_languageserver_types_1.Diagnostic.create(range, `Unused anchor "${aToken.source}"`, vscode_languageserver_types_1.DiagnosticSeverity.Hint, 0);
+                        warningDiagnostic.tags = [vscode_languageserver_types_1.DiagnosticTag.Unnecessary];
+                        result.push(warningDiagnostic);
+                    }
+                }
+            }
+            return result;
+        }
+        getAnchorNode(parentNode, node) {
+            if (parentNode && parentNode.srcToken) {
+                const token = parentNode.srcToken;
+                if ((0, astUtils_1.isCollectionItem)(token)) {
+                    return getAnchorFromCollectionItem(token);
+                }
+                else if (yaml_1.CST.isCollection(token)) {
+                    for (const t of token.items) {
+                        if (node.srcToken !== t.value)
+                            continue;
+                        const anchor = getAnchorFromCollectionItem(t);
+                        if (anchor) {
+                            return anchor;
+                        }
+                    }
+                }
+            }
+            return undefined;
+        }
+    }
+    exports.UnusedAnchorsValidator = UnusedAnchorsValidator;
+    function getAnchorFromCollectionItem(token) {
+        for (const t of token.start) {
+            if (t.type === 'anchor') {
+                return t;
+            }
+        }
+        if (token.sep && Array.isArray(token.sep)) {
+            for (const t of token.sep) {
+                if (t.type === 'anchor') {
+                    return t;
+                }
+            }
+        }
+    }
+});
+//# sourceMappingURL=unused-anchors.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/unused-anchors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unused-anchors.js","sourceRoot":"","sources":["../../../../../src/languageservice/services/validation/unused-anchors.ts"],"names":[],"mappings":"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"}

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/yaml-style.d.ts

@@ -0,0 +1,12 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Diagnostic } from 'vscode-languageserver-types';
+import { SingleYAMLDocument } from '../../parser/yaml-documents';
+import { LanguageSettings } from '../../yamlLanguageService';
+import { AdditionalValidator } from './types';
+export declare class YAMLStyleValidator implements AdditionalValidator {
+    private forbidSequence;
+    private forbidMapping;
+    constructor(settings: LanguageSettings);
+    validate(document: TextDocument, yamlDoc: SingleYAMLDocument): Diagnostic[];
+    private getRangeOf;
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/yaml-style.js

@@ -0,0 +1,38 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "yaml"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.YAMLStyleValidator = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const yaml_1 = require("yaml");
+    class YAMLStyleValidator {
+        constructor(settings) {
+            this.forbidMapping = settings.flowMapping === 'forbid';
+            this.forbidSequence = settings.flowSequence === 'forbid';
+        }
+        validate(document, yamlDoc) {
+            const result = [];
+            (0, yaml_1.visit)(yamlDoc.internalDocument, (key, node) => {
+                if (this.forbidMapping && (0, yaml_1.isMap)(node) && node.srcToken?.type === 'flow-collection') {
+                    result.push(vscode_languageserver_types_1.Diagnostic.create(this.getRangeOf(document, node.srcToken), 'Flow style mapping is forbidden', vscode_languageserver_types_1.DiagnosticSeverity.Error, 'flowMap'));
+                }
+                if (this.forbidSequence && (0, yaml_1.isSeq)(node) && node.srcToken?.type === 'flow-collection') {
+                    result.push(vscode_languageserver_types_1.Diagnostic.create(this.getRangeOf(document, node.srcToken), 'Flow style sequence is forbidden', vscode_languageserver_types_1.DiagnosticSeverity.Error, 'flowSeq'));
+                }
+            });
+            return result;
+        }
+        getRangeOf(document, node) {
+            return vscode_languageserver_types_1.Range.create(document.positionAt(node.start.offset), document.positionAt(node.end.pop().offset));
+        }
+    }
+    exports.YAMLStyleValidator = YAMLStyleValidator;
+});
+//# sourceMappingURL=yaml-style.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/validation/yaml-style.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml-style.js","sourceRoot":"","sources":["../../../../../src/languageservice/services/validation/yaml-style.ts"],"names":[],"mappings":";;;;;;;;;;;;IACA,6EAAoF;IACpF,+BAA2C;IAM3C,MAAa,kBAAkB;QAI7B,YAAY,QAA0B;YACpC,IAAI,CAAC,aAAa,GAAG,QAAQ,CAAC,WAAW,KAAK,QAAQ,CAAC;YACvD,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,YAAY,KAAK,QAAQ,CAAC;QAC3D,CAAC;QACD,QAAQ,CAAC,QAAsB,EAAE,OAA2B;YAC1D,MAAM,MAAM,GAAG,EAAE,CAAC;YAClB,IAAA,YAAK,EAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;gBAC5C,IAAI,IAAI,CAAC,aAAa,IAAI,IAAA,YAAK,EAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,IAAI,KAAK,iBAAiB,EAAE;oBAClF,MAAM,CAAC,IAAI,CACT,wCAAU,CAAC,MAAM,CACf,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,EACxC,iCAAiC,EACjC,gDAAkB,CAAC,KAAK,EACxB,SAAS,CACV,CACF,CAAC;iBACH;gBACD,IAAI,IAAI,CAAC,cAAc,IAAI,IAAA,YAAK,EAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,IAAI,KAAK,iBAAiB,EAAE;oBACnF,MAAM,CAAC,IAAI,CACT,wCAAU,CAAC,MAAM,CACf,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,EACxC,kCAAkC,EAClC,gDAAkB,CAAC,KAAK,EACxB,SAAS,CACV,CACF,CAAC;iBACH;YACH,CAAC,CAAC,CAAC;YACH,OAAO,MAAM,CAAC;QAChB,CAAC;QAEO,UAAU,CAAC,QAAsB,EAAE,IAAoB;YAC7D,OAAO,mCAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;QAC1G,CAAC;KACF;IAtCD,gDAsCC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlCodeActions.d.ts

@@ -0,0 +1,17 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { CodeAction } from 'vscode-languageserver-types';
+import { ClientCapabilities, CodeActionParams } from 'vscode-languageserver-protocol';
+import { LanguageSettings } from '../yamlLanguageService';
+export declare class YamlCodeActions {
+    private readonly clientCapabilities;
+    private indentation;
+    constructor(clientCapabilities: ClientCapabilities);
+    configure(settings: LanguageSettings): void;
+    getCodeAction(document: TextDocument, params: CodeActionParams): CodeAction[] | undefined;
+    private getJumpToSchemaActions;
+    private getTabToSpaceConverting;
+    private getUnusedAnchorsDelete;
+    private getConvertToBooleanActions;
+    private getConvertToBlockStyleActions;
+    private getKeyOrderActions;
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlCodeActions.js

@@ -0,0 +1,267 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "../../commands", "path", "../utils/textBuffer", "../parser/jsonParser07", "../utils/strings", "../utils/arrUtils", "yaml", "../parser/yaml-documents", "../utils/flow-style-rewriter", "lodash"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.YamlCodeActions = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const commands_1 = require("../../commands");
+    const path = require("path");
+    const textBuffer_1 = require("../utils/textBuffer");
+    const jsonParser07_1 = require("../parser/jsonParser07");
+    const strings_1 = require("../utils/strings");
+    const arrUtils_1 = require("../utils/arrUtils");
+    const yaml_1 = require("yaml");
+    const yaml_documents_1 = require("../parser/yaml-documents");
+    const flow_style_rewriter_1 = require("../utils/flow-style-rewriter");
+    const _ = require("lodash");
+    class YamlCodeActions {
+        constructor(clientCapabilities) {
+            this.clientCapabilities = clientCapabilities;
+            this.indentation = '  ';
+        }
+        configure(settings) {
+            this.indentation = settings.indentation;
+        }
+        getCodeAction(document, params) {
+            if (!params.context.diagnostics) {
+                return;
+            }
+            const result = [];
+            result.push(...this.getConvertToBooleanActions(params.context.diagnostics, document));
+            result.push(...this.getJumpToSchemaActions(params.context.diagnostics));
+            result.push(...this.getTabToSpaceConverting(params.context.diagnostics, document));
+            result.push(...this.getUnusedAnchorsDelete(params.context.diagnostics, document));
+            result.push(...this.getConvertToBlockStyleActions(params.context.diagnostics, document));
+            result.push(...this.getKeyOrderActions(params.context.diagnostics, document));
+            return result;
+        }
+        getJumpToSchemaActions(diagnostics) {
+            const isOpenTextDocumentEnabled = this.clientCapabilities?.window?.showDocument?.support ?? false;
+            if (!isOpenTextDocumentEnabled) {
+                return [];
+            }
+            const schemaUriToDiagnostic = new Map();
+            for (const diagnostic of diagnostics) {
+                const schemaUri = diagnostic.data?.schemaUri || [];
+                for (const schemaUriStr of schemaUri) {
+                    if (schemaUriStr) {
+                        if (!schemaUriToDiagnostic.has(schemaUriStr)) {
+                            schemaUriToDiagnostic.set(schemaUriStr, []);
+                        }
+                        schemaUriToDiagnostic.get(schemaUriStr).push(diagnostic);
+                    }
+                }
+            }
+            const result = [];
+            for (const schemaUri of schemaUriToDiagnostic.keys()) {
+                const action = vscode_languageserver_types_1.CodeAction.create(`Jump to schema location (${path.basename(schemaUri)})`, vscode_languageserver_types_1.Command.create('JumpToSchema', commands_1.YamlCommands.JUMP_TO_SCHEMA, schemaUri));
+                action.diagnostics = schemaUriToDiagnostic.get(schemaUri);
+                result.push(action);
+            }
+            return result;
+        }
+        getTabToSpaceConverting(diagnostics, document) {
+            const result = [];
+            const textBuff = new textBuffer_1.TextBuffer(document);
+            const processedLine = [];
+            for (const diag of diagnostics) {
+                if (diag.message === 'Using tabs can lead to unpredictable results') {
+                    if (processedLine.includes(diag.range.start.line)) {
+                        continue;
+                    }
+                    const lineContent = textBuff.getLineContent(diag.range.start.line);
+                    let replacedTabs = 0;
+                    let newText = '';
+                    for (let i = diag.range.start.character; i <= diag.range.end.character; i++) {
+                        const char = lineContent.charAt(i);
+                        if (char !== '\t') {
+                            break;
+                        }
+                        replacedTabs++;
+                        newText += this.indentation;
+                    }
+                    processedLine.push(diag.range.start.line);
+                    let resultRange = diag.range;
+                    if (replacedTabs !== diag.range.end.character - diag.range.start.character) {
+                        resultRange = vscode_languageserver_types_1.Range.create(diag.range.start, vscode_languageserver_types_1.Position.create(diag.range.end.line, diag.range.start.character + replacedTabs));
+                    }
+                    result.push(vscode_languageserver_types_1.CodeAction.create('Convert Tab to Spaces', createWorkspaceEdit(document.uri, [vscode_languageserver_types_1.TextEdit.replace(resultRange, newText)]), vscode_languageserver_types_1.CodeActionKind.QuickFix));
+                }
+            }
+            if (result.length !== 0) {
+                const replaceEdits = [];
+                for (let i = 0; i <= textBuff.getLineCount(); i++) {
+                    const lineContent = textBuff.getLineContent(i);
+                    let replacedTabs = 0;
+                    let newText = '';
+                    for (let j = 0; j < lineContent.length; j++) {
+                        const char = lineContent.charAt(j);
+                        if (char !== ' ' && char !== '\t') {
+                            if (replacedTabs !== 0) {
+                                replaceEdits.push(vscode_languageserver_types_1.TextEdit.replace(vscode_languageserver_types_1.Range.create(i, j - replacedTabs, i, j), newText));
+                                replacedTabs = 0;
+                                newText = '';
+                            }
+                            break;
+                        }
+                        if (char === ' ' && replacedTabs !== 0) {
+                            replaceEdits.push(vscode_languageserver_types_1.TextEdit.replace(vscode_languageserver_types_1.Range.create(i, j - replacedTabs, i, j), newText));
+                            replacedTabs = 0;
+                            newText = '';
+                            continue;
+                        }
+                        if (char === '\t') {
+                            newText += this.indentation;
+                            replacedTabs++;
+                        }
+                    }
+                    // line contains only tabs
+                    if (replacedTabs !== 0) {
+                        replaceEdits.push(vscode_languageserver_types_1.TextEdit.replace(vscode_languageserver_types_1.Range.create(i, 0, i, textBuff.getLineLength(i)), newText));
+                    }
+                }
+                if (replaceEdits.length > 0) {
+                    result.push(vscode_languageserver_types_1.CodeAction.create('Convert all Tabs to Spaces', createWorkspaceEdit(document.uri, replaceEdits), vscode_languageserver_types_1.CodeActionKind.QuickFix));
+                }
+            }
+            return result;
+        }
+        getUnusedAnchorsDelete(diagnostics, document) {
+            const result = [];
+            const buffer = new textBuffer_1.TextBuffer(document);
+            for (const diag of diagnostics) {
+                if (diag.message.startsWith('Unused anchor') && diag.source === jsonParser07_1.YAML_SOURCE) {
+                    const range = vscode_languageserver_types_1.Range.create(diag.range.start, diag.range.end);
+                    const actual = buffer.getText(range);
+                    const lineContent = buffer.getLineContent(range.end.line);
+                    const lastWhitespaceChar = (0, strings_1.getFirstNonWhitespaceCharacterAfterOffset)(lineContent, range.end.character);
+                    range.end.character = lastWhitespaceChar;
+                    const action = vscode_languageserver_types_1.CodeAction.create(`Delete unused anchor: ${actual}`, createWorkspaceEdit(document.uri, [vscode_languageserver_types_1.TextEdit.del(range)]), vscode_languageserver_types_1.CodeActionKind.QuickFix);
+                    action.diagnostics = [diag];
+                    result.push(action);
+                }
+            }
+            return result;
+        }
+        getConvertToBooleanActions(diagnostics, document) {
+            const results = [];
+            for (const diagnostic of diagnostics) {
+                if (diagnostic.message === 'Incorrect type. Expected "boolean".') {
+                    const value = document.getText(diagnostic.range).toLocaleLowerCase();
+                    if (value === '"true"' || value === '"false"' || value === "'true'" || value === "'false'") {
+                        const newValue = value.includes('true') ? 'true' : 'false';
+                        results.push(vscode_languageserver_types_1.CodeAction.create('Convert to boolean', createWorkspaceEdit(document.uri, [vscode_languageserver_types_1.TextEdit.replace(diagnostic.range, newValue)]), vscode_languageserver_types_1.CodeActionKind.QuickFix));
+                    }
+                }
+            }
+            return results;
+        }
+        getConvertToBlockStyleActions(diagnostics, document) {
+            const results = [];
+            for (const diagnostic of diagnostics) {
+                if (diagnostic.code === 'flowMap' || diagnostic.code === 'flowSeq') {
+                    const node = getNodeforDiagnostic(document, diagnostic);
+                    if ((0, yaml_1.isMap)(node.internalNode) || (0, yaml_1.isSeq)(node.internalNode)) {
+                        const blockTypeDescription = (0, yaml_1.isMap)(node.internalNode) ? 'map' : 'sequence';
+                        const rewriter = new flow_style_rewriter_1.FlowStyleRewriter(this.indentation);
+                        results.push(vscode_languageserver_types_1.CodeAction.create(`Convert to block style ${blockTypeDescription}`, createWorkspaceEdit(document.uri, [vscode_languageserver_types_1.TextEdit.replace(diagnostic.range, rewriter.write(node))]), vscode_languageserver_types_1.CodeActionKind.QuickFix));
+                    }
+                }
+            }
+            return results;
+        }
+        getKeyOrderActions(diagnostics, document) {
+            const results = [];
+            for (const diagnostic of diagnostics) {
+                if (diagnostic?.code === 'mapKeyOrder') {
+                    let node = getNodeforDiagnostic(document, diagnostic);
+                    while (node && node.type !== 'object') {
+                        node = node.parent;
+                    }
+                    if (node && (0, yaml_1.isMap)(node.internalNode)) {
+                        const sorted = _.cloneDeep(node.internalNode);
+                        if ((sorted.srcToken.type === 'block-map' || sorted.srcToken.type === 'flow-collection') &&
+                            (node.internalNode.srcToken.type === 'block-map' || node.internalNode.srcToken.type === 'flow-collection')) {
+                            sorted.srcToken.items.sort((a, b) => {
+                                if (a.key && b.key && yaml_1.CST.isScalar(a.key) && yaml_1.CST.isScalar(b.key)) {
+                                    return a.key.source.localeCompare(b.key.source);
+                                }
+                                if (!a.key && b.key) {
+                                    return -1;
+                                }
+                                if (a.key && !b.key) {
+                                    return 1;
+                                }
+                                if (!a.key && !b.key) {
+                                    return 0;
+                                }
+                            });
+                            for (let i = 0; i < sorted.srcToken.items.length; i++) {
+                                const item = sorted.srcToken.items[i];
+                                const uItem = node.internalNode.srcToken.items[i];
+                                item.start = uItem.start;
+                                if (item.value?.type === 'alias' ||
+                                    item.value?.type === 'scalar' ||
+                                    item.value?.type === 'single-quoted-scalar' ||
+                                    item.value?.type === 'double-quoted-scalar') {
+                                    const newLineIndex = item.value?.end?.findIndex((p) => p.type === 'newline') ?? -1;
+                                    let newLineToken = null;
+                                    if (uItem.value?.type === 'block-scalar') {
+                                        newLineToken = uItem.value?.props?.find((p) => p.type === 'newline');
+                                    }
+                                    else if (yaml_1.CST.isScalar(uItem.value)) {
+                                        newLineToken = uItem.value?.end?.find((p) => p.type === 'newline');
+                                    }
+                                    if (newLineToken && newLineIndex < 0) {
+                                        item.value.end = item.value.end ?? [];
+                                        item.value.end.push(newLineToken);
+                                    }
+                                    if (!newLineToken && newLineIndex > -1) {
+                                        item.value.end.splice(newLineIndex, 1);
+                                    }
+                                }
+                                else if (item.value?.type === 'block-scalar') {
+                                    const nwline = item.value.props.find((p) => p.type === 'newline');
+                                    if (!nwline) {
+                                        item.value.props.push({ type: 'newline', indent: 0, offset: item.value.offset, source: '\n' });
+                                    }
+                                }
+                            }
+                        }
+                        const replaceRange = vscode_languageserver_types_1.Range.create(document.positionAt(node.offset), document.positionAt(node.offset + node.length));
+                        results.push(vscode_languageserver_types_1.CodeAction.create('Fix key order for this map', createWorkspaceEdit(document.uri, [vscode_languageserver_types_1.TextEdit.replace(replaceRange, yaml_1.CST.stringify(sorted.srcToken))]), vscode_languageserver_types_1.CodeActionKind.QuickFix));
+                    }
+                }
+            }
+            return results;
+        }
+    }
+    exports.YamlCodeActions = YamlCodeActions;
+    function getNodeforDiagnostic(document, diagnostic) {
+        const yamlDocuments = yaml_documents_1.yamlDocumentsCache.getYamlDocument(document);
+        const startOffset = document.offsetAt(diagnostic.range.start);
+        const yamlDoc = (0, arrUtils_1.matchOffsetToDocument)(startOffset, yamlDocuments);
+        const node = yamlDoc.getNodeFromOffset(startOffset);
+        return node;
+    }
+    function createWorkspaceEdit(uri, edits) {
+        const changes = {};
+        changes[uri] = edits;
+        const edit = {
+            changes,
+        };
+        return edit;
+    }
+});
+//# sourceMappingURL=yamlCodeActions.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlCodeLens.d.ts

@@ -0,0 +1,11 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { CodeLens } from 'vscode-languageserver-types';
+import { YAMLSchemaService } from './yamlSchemaService';
+import { Telemetry } from '../telemetry';
+export declare class YamlCodeLens {
+    private schemaService;
+    private readonly telemetry?;
+    constructor(schemaService: YAMLSchemaService, telemetry?: Telemetry);
+    getCodeLens(document: TextDocument): Promise<CodeLens[]>;
+    resolveCodeLens(param: CodeLens): PromiseLike<CodeLens> | CodeLens;
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlCodeLens.js

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "../../commands", "../parser/yaml-documents", "../utils/schemaUrls", "../utils/objects", "../utils/schemaUtils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.YamlCodeLens = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const commands_1 = require("../../commands");
+    const yaml_documents_1 = require("../parser/yaml-documents");
+    const schemaUrls_1 = require("../utils/schemaUrls");
+    const objects_1 = require("../utils/objects");
+    const schemaUtils_1 = require("../utils/schemaUtils");
+    class YamlCodeLens {
+        constructor(schemaService, telemetry) {
+            this.schemaService = schemaService;
+            this.telemetry = telemetry;
+        }
+        async getCodeLens(document) {
+            const result = [];
+            try {
+                const yamlDocument = yaml_documents_1.yamlDocumentsCache.getYamlDocument(document);
+                let schemaUrls = new Map();
+                for (const currentYAMLDoc of yamlDocument.documents) {
+                    const schema = await this.schemaService.getSchemaForResource(document.uri, currentYAMLDoc);
+                    if (schema?.schema) {
+                        // merge schemas from all docs to avoid duplicates
+                        schemaUrls = new Map([...(0, schemaUrls_1.getSchemaUrls)(schema?.schema), ...schemaUrls]);
+                    }
+                }
+                for (const urlToSchema of schemaUrls) {
+                    const lens = vscode_languageserver_types_1.CodeLens.create(vscode_languageserver_types_1.Range.create(0, 0, 0, 0));
+                    lens.command = {
+                        title: (0, schemaUtils_1.getSchemaTitle)(urlToSchema[1], urlToSchema[0]),
+                        command: commands_1.YamlCommands.JUMP_TO_SCHEMA,
+                        arguments: [urlToSchema[0]],
+                    };
+                    result.push(lens);
+                }
+            }
+            catch (err) {
+                this.telemetry?.sendError('yaml.codeLens.error', { error: (0, objects_1.convertErrorToTelemetryMsg)(err) });
+            }
+            return result;
+        }
+        resolveCodeLens(param) {
+            return param;
+        }
+    }
+    exports.YamlCodeLens = YamlCodeLens;
+});
+//# sourceMappingURL=yamlCodeLens.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlCodeLens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlCodeLens.js","sourceRoot":"","sources":["../../../../src/languageservice/services/yamlCodeLens.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAGhG,6EAA8D;IAC9D,6CAA8C;IAC9C,6DAA8D;IAI9D,oDAAoD;IACpD,8CAA8D;IAC9D,sDAAsD;IAEtD,MAAa,YAAY;QACvB,YAAoB,aAAgC,EAAmB,SAAqB;YAAxE,kBAAa,GAAb,aAAa,CAAmB;YAAmB,cAAS,GAAT,SAAS,CAAY;QAAG,CAAC;QAEhG,KAAK,CAAC,WAAW,CAAC,QAAsB;YACtC,MAAM,MAAM,GAAG,EAAE,CAAC;YAClB,IAAI;gBACF,MAAM,YAAY,GAAG,mCAAkB,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;gBAClE,IAAI,UAAU,GAAG,IAAI,GAAG,EAAsB,CAAC;gBAC/C,KAAK,MAAM,cAAc,IAAI,YAAY,CAAC,SAAS,EAAE;oBACnD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,QAAQ,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;oBAC3F,IAAI,MAAM,EAAE,MAAM,EAAE;wBAClB,kDAAkD;wBAClD,UAAU,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,IAAA,0BAAa,EAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC;qBACzE;iBACF;gBACD,KAAK,MAAM,WAAW,IAAI,UAAU,EAAE;oBACpC,MAAM,IAAI,GAAG,sCAAQ,CAAC,MAAM,CAAC,mCAAK,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;oBACvD,IAAI,CAAC,OAAO,GAAG;wBACb,KAAK,EAAE,IAAA,4BAAc,EAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;wBACrD,OAAO,EAAE,uBAAY,CAAC,cAAc;wBACpC,SAAS,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;qBAC5B,CAAC;oBACF,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;iBACnB;aACF;YAAC,OAAO,GAAG,EAAE;gBACZ,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,qBAAqB,EAAE,EAAE,KAAK,EAAE,IAAA,oCAA0B,EAAC,GAAG,CAAC,EAAE,CAAC,CAAC;aAC9F;YAED,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,eAAe,CAAC,KAAe;YAC7B,OAAO,KAAK,CAAC;QACf,CAAC;KACF;IAjCD,oCAiCC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlCommands.d.ts

@@ -0,0 +1,3 @@
+import { Connection } from 'vscode-languageserver';
+import { CommandExecutor } from '../../languageserver/commandExecutor';
+export declare function registerCommands(commandExecutor: CommandExecutor, connection: Connection): void;

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlCommands.js

@@ -0,0 +1,48 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../commands", "vscode-uri"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.registerCommands = void 0;
+    const commands_1 = require("../../commands");
+    const vscode_uri_1 = require("vscode-uri");
+    function registerCommands(commandExecutor, connection) {
+        commandExecutor.registerCommand(commands_1.YamlCommands.JUMP_TO_SCHEMA, async (uri) => {
+            if (!uri) {
+                return;
+            }
+            // if uri points to local file of its a windows path
+            if (!uri.startsWith('file') && !/^[a-z]:[\\/]/i.test(uri)) {
+                const origUri = vscode_uri_1.URI.parse(uri);
+                const customUri = vscode_uri_1.URI.from({
+                    scheme: 'json-schema',
+                    authority: origUri.authority,
+                    path: origUri.path.endsWith('.json') ? origUri.path : origUri.path + '.json',
+                    fragment: uri,
+                });
+                uri = customUri.toString();
+            }
+            // test if uri is windows path, ie starts with 'c:\' and convert to URI
+            if (/^[a-z]:[\\/]/i.test(uri)) {
+                const winUri = vscode_uri_1.URI.file(uri);
+                uri = winUri.toString();
+            }
+            const result = await connection.window.showDocument({ uri: uri, external: false, takeFocus: true });
+            if (!result) {
+                connection.window.showErrorMessage(`Cannot open ${uri}`);
+            }
+        });
+    }
+    exports.registerCommands = registerCommands;
+});
+//# sourceMappingURL=yamlCommands.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlCommands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlCommands.js","sourceRoot":"","sources":["../../../../src/languageservice/services/yamlCommands.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAGhG,6CAA8C;IAE9C,2CAAiC;IAEjC,SAAgB,gBAAgB,CAAC,eAAgC,EAAE,UAAsB;QACvF,eAAe,CAAC,eAAe,CAAC,uBAAY,CAAC,cAAc,EAAE,KAAK,EAAE,GAAW,EAAE,EAAE;YACjF,IAAI,CAAC,GAAG,EAAE;gBACR,OAAO;aACR;YACD,oDAAoD;YACpD,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;gBACzD,MAAM,OAAO,GAAG,gBAAG,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC/B,MAAM,SAAS,GAAG,gBAAG,CAAC,IAAI,CAAC;oBACzB,MAAM,EAAE,aAAa;oBACrB,SAAS,EAAE,OAAO,CAAC,SAAS;oBAC5B,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,GAAG,OAAO;oBAC5E,QAAQ,EAAE,GAAG;iBACd,CAAC,CAAC;gBACH,GAAG,GAAG,SAAS,CAAC,QAAQ,EAAE,CAAC;aAC5B;YAED,uEAAuE;YACvE,IAAI,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;gBAC7B,MAAM,MAAM,GAAG,gBAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC7B,GAAG,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAC;aACzB;YAED,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YACpG,IAAI,CAAC,MAAM,EAAE;gBACX,UAAU,CAAC,MAAM,CAAC,gBAAgB,CAAC,eAAe,GAAG,EAAE,CAAC,CAAC;aAC1D;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IA5BD,4CA4BC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlCompletion.d.ts

@@ -0,0 +1,68 @@
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { ClientCapabilities } from 'vscode-languageserver';
+import { CompletionItem as CompletionItemBase, CompletionList, Position } from 'vscode-languageserver-types';
+import { Telemetry } from '../telemetry';
+import { YamlDocuments } from '../parser/yaml-documents';
+import { LanguageSettings } from '../yamlLanguageService';
+import { YAMLSchemaService } from './yamlSchemaService';
+import { JSONSchema } from '../jsonSchema';
+interface ParentCompletionItemOptions {
+    schema: JSONSchema;
+    indent?: string;
+    insertTexts?: string[];
+}
+interface CompletionItem extends CompletionItemBase {
+    parent?: ParentCompletionItemOptions;
+}
+export declare class YamlCompletion {
+    private schemaService;
+    private clientCapabilities;
+    private yamlDocument;
+    private readonly telemetry?;
+    private customTags;
+    private completionEnabled;
+    private configuredIndentation;
+    private yamlVersion;
+    private indentation;
+    private arrayPrefixIndentation;
+    private supportsMarkdown;
+    private disableDefaultProperties;
+    private parentSkeletonSelectedFirst;
+    constructor(schemaService: YAMLSchemaService, clientCapabilities: ClientCapabilities, yamlDocument: YamlDocuments, telemetry?: Telemetry);
+    configure(languageSettings: LanguageSettings): void;
+    doComplete(document: TextDocument, position: Position, isKubernetes?: boolean, doComplete?: boolean): Promise<CompletionList>;
+    updateCompletionText(completionItem: CompletionItem, text: string): void;
+    mergeSimpleInsertTexts(label: string, existingText: string, addingText: string, oneOfSchema: boolean): string | undefined;
+    getValuesFromInsertText(insertText: string): string[];
+    private finalizeParentCompletion;
+    private createTempObjNode;
+    private addPropertyCompletions;
+    private getValueCompletions;
+    private addArrayItemValueCompletion;
+    private getInsertTextForProperty;
+    private getInsertTextForObject;
+    private getInsertTextForArray;
+    private getInsertTextForGuessedValue;
+    private getInsertTextForPlainText;
+    private getInsertTextForValue;
+    private getInsertTemplateForValue;
+    private addSchemaValueCompletions;
+    private collectTypes;
+    private addDefaultValueCompletions;
+    private addEnumValueCompletions;
+    private getLabelForValue;
+    private collectDefaultSnippets;
+    private getInsertTextForSnippetValue;
+    private addBooleanValueCompletion;
+    private addNullValueCompletion;
+    private getLabelForSnippetValue;
+    private getCustomTagValueCompletions;
+    private addCustomTagValueCompletion;
+    private getDocumentationWithMarkdownText;
+    private getSuggestionKind;
+    private getCurrentWord;
+    private fromMarkup;
+    private doesSupportMarkdown;
+    private findItemAtOffset;
+}
+export {};

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlDefinition.d.ts

@@ -0,0 +1,9 @@
+import { DefinitionParams } from 'vscode-languageserver-protocol';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { DefinitionLink } from 'vscode-languageserver-types';
+import { Telemetry } from '../telemetry';
+export declare class YamlDefinition {
+    private readonly telemetry?;
+    constructor(telemetry?: Telemetry);
+    getDefinition(document: TextDocument, params: DefinitionParams): DefinitionLink[] | undefined;
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlDefinition.js

@@ -0,0 +1,52 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "yaml", "../parser/yaml-documents", "../utils/arrUtils", "../utils/objects", "../utils/textBuffer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.YamlDefinition = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const yaml_1 = require("yaml");
+    const yaml_documents_1 = require("../parser/yaml-documents");
+    const arrUtils_1 = require("../utils/arrUtils");
+    const objects_1 = require("../utils/objects");
+    const textBuffer_1 = require("../utils/textBuffer");
+    class YamlDefinition {
+        constructor(telemetry) {
+            this.telemetry = telemetry;
+        }
+        getDefinition(document, params) {
+            try {
+                const yamlDocument = yaml_documents_1.yamlDocumentsCache.getYamlDocument(document);
+                const offset = document.offsetAt(params.position);
+                const currentDoc = (0, arrUtils_1.matchOffsetToDocument)(offset, yamlDocument);
+                if (currentDoc) {
+                    const [node] = currentDoc.getNodeFromPosition(offset, new textBuffer_1.TextBuffer(document));
+                    if (node && (0, yaml_1.isAlias)(node)) {
+                        const defNode = node.resolve(currentDoc.internalDocument);
+                        if (defNode && defNode.range) {
+                            const targetRange = vscode_languageserver_types_1.Range.create(document.positionAt(defNode.range[0]), document.positionAt(defNode.range[2]));
+                            const selectionRange = vscode_languageserver_types_1.Range.create(document.positionAt(defNode.range[0]), document.positionAt(defNode.range[1]));
+                            return [vscode_languageserver_types_1.LocationLink.create(document.uri, targetRange, selectionRange)];
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                this.telemetry?.sendError('yaml.definition.error', { error: (0, objects_1.convertErrorToTelemetryMsg)(err) });
+            }
+            return undefined;
+        }
+    }
+    exports.YamlDefinition = YamlDefinition;
+});
+//# sourceMappingURL=yamlDefinition.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlDefinition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlDefinition.js","sourceRoot":"","sources":["../../../../src/languageservice/services/yamlDefinition.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAIhG,6EAAkF;IAClF,+BAA+B;IAE/B,6DAA8D;IAC9D,gDAA0D;IAC1D,8CAA8D;IAC9D,oDAAiD;IAEjD,MAAa,cAAc;QACzB,YAA6B,SAAqB;YAArB,cAAS,GAAT,SAAS,CAAY;QAAG,CAAC;QAEtD,aAAa,CAAC,QAAsB,EAAE,MAAwB;YAC5D,IAAI;gBACF,MAAM,YAAY,GAAG,mCAAkB,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;gBAClE,MAAM,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gBAClD,MAAM,UAAU,GAAG,IAAA,gCAAqB,EAAC,MAAM,EAAE,YAAY,CAAC,CAAC;gBAC/D,IAAI,UAAU,EAAE;oBACd,MAAM,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,mBAAmB,CAAC,MAAM,EAAE,IAAI,uBAAU,CAAC,QAAQ,CAAC,CAAC,CAAC;oBAChF,IAAI,IAAI,IAAI,IAAA,cAAO,EAAC,IAAI,CAAC,EAAE;wBACzB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC;wBAC1D,IAAI,OAAO,IAAI,OAAO,CAAC,KAAK,EAAE;4BAC5B,MAAM,WAAW,GAAG,mCAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;4BAC/G,MAAM,cAAc,GAAG,mCAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;4BAClH,OAAO,CAAC,0CAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,cAAc,CAAC,CAAC,CAAC;yBACzE;qBACF;iBACF;aACF;YAAC,OAAO,GAAG,EAAE;gBACZ,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,uBAAuB,EAAE,EAAE,KAAK,EAAE,IAAA,oCAA0B,EAAC,GAAG,CAAC,EAAE,CAAC,CAAC;aAChG;YAED,OAAO,SAAS,CAAC;QACnB,CAAC;KACF;IAzBD,wCAyBC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlFolding.d.ts

@@ -0,0 +1,4 @@
+import { FoldingRange } from 'vscode-languageserver-types';
+import { FoldingRangesContext } from '../yamlTypes';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export declare function getFoldingRanges(document: TextDocument, context: FoldingRangesContext): FoldingRange[] | undefined;

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlFolding.js

@@ -0,0 +1,76 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "../parser/yaml-documents"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getFoldingRanges = void 0;
+    /*---------------------------------------------------------------------------------------------
+     *  Copyright (c) Red Hat, Inc. All rights reserved.
+     *  Licensed under the MIT License. See License.txt in the project root for license information.
+     *--------------------------------------------------------------------------------------------*/
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const yaml_documents_1 = require("../parser/yaml-documents");
+    function getFoldingRanges(document, context) {
+        if (!document) {
+            return;
+        }
+        const result = [];
+        const doc = yaml_documents_1.yamlDocumentsCache.getYamlDocument(document);
+        for (const ymlDoc of doc.documents) {
+            if (doc.documents.length > 1) {
+                result.push(createNormalizedFolding(document, ymlDoc.root));
+            }
+            ymlDoc.visit((node) => {
+                if (node.type === 'object' && node.parent?.type === 'array') {
+                    result.push(createNormalizedFolding(document, node));
+                }
+                if (node.type === 'property' && node.valueNode) {
+                    switch (node.valueNode.type) {
+                        case 'array':
+                        case 'object':
+                            result.push(createNormalizedFolding(document, node));
+                            break;
+                        case 'string': {
+                            // check if it is a multi-line string
+                            const nodePosn = document.positionAt(node.offset);
+                            const valuePosn = document.positionAt(node.valueNode.offset + node.valueNode.length);
+                            if (nodePosn.line !== valuePosn.line) {
+                                result.push(createNormalizedFolding(document, node));
+                            }
+                            break;
+                        }
+                        default:
+                            return true;
+                    }
+                }
+                return true;
+            });
+        }
+        const rangeLimit = context && context.rangeLimit;
+        if (typeof rangeLimit !== 'number' || result.length <= rangeLimit) {
+            return result;
+        }
+        if (context && context.onRangeLimitExceeded) {
+            context.onRangeLimitExceeded(document.uri);
+        }
+        return result.slice(0, context.rangeLimit);
+    }
+    exports.getFoldingRanges = getFoldingRanges;
+    function createNormalizedFolding(document, node) {
+        const startPos = document.positionAt(node.offset);
+        let endPos = document.positionAt(node.offset + node.length);
+        const textFragment = document.getText(vscode_languageserver_types_1.Range.create(startPos, endPos));
+        const newLength = textFragment.length - textFragment.trimRight().length;
+        if (newLength > 0) {
+            endPos = document.positionAt(node.offset + node.length - newLength);
+        }
+        return vscode_languageserver_types_1.FoldingRange.create(startPos.line, endPos.line, startPos.character, endPos.character);
+    }
+});
+//# sourceMappingURL=yamlFolding.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlFolding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlFolding.js","sourceRoot":"","sources":["../../../../src/languageservice/services/yamlFolding.ts"],"names":[],"mappings":"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"}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlFormatter.d.ts

@@ -0,0 +1,8 @@
+import { TextEdit, FormattingOptions } from 'vscode-languageserver-types';
+import { CustomFormatterOptions, LanguageSettings } from '../yamlLanguageService';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export declare class YAMLFormatter {
+    private formatterEnabled;
+    configure(shouldFormat: LanguageSettings): void;
+    format(document: TextDocument, options?: Partial<FormattingOptions> & CustomFormatterOptions): TextEdit[];
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlFormatter.js

@@ -0,0 +1,58 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Copyright (c) Adam Voss. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "prettier", "prettier/parser-yaml"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.YAMLFormatter = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const prettier = require("prettier");
+    const parser = require("prettier/parser-yaml");
+    class YAMLFormatter {
+        constructor() {
+            this.formatterEnabled = true;
+        }
+        configure(shouldFormat) {
+            if (shouldFormat) {
+                this.formatterEnabled = shouldFormat.format;
+            }
+        }
+        format(document, options = {}) {
+            if (!this.formatterEnabled) {
+                return [];
+            }
+            try {
+                const text = document.getText();
+                const prettierOptions = {
+                    parser: 'yaml',
+                    plugins: [parser],
+                    // --- FormattingOptions ---
+                    tabWidth: options.tabWidth || options.tabSize,
+                    // --- CustomFormatterOptions ---
+                    singleQuote: options.singleQuote,
+                    bracketSpacing: options.bracketSpacing,
+                    // 'preserve' is the default for Options.proseWrap. See also server.ts
+                    proseWrap: 'always' === options.proseWrap ? 'always' : 'never' === options.proseWrap ? 'never' : 'preserve',
+                    printWidth: options.printWidth,
+                };
+                const formatted = prettier.format(text, prettierOptions);
+                return [vscode_languageserver_types_1.TextEdit.replace(vscode_languageserver_types_1.Range.create(vscode_languageserver_types_1.Position.create(0, 0), document.positionAt(text.length)), formatted)];
+            }
+            catch (error) {
+                return [];
+            }
+        }
+    }
+    exports.YAMLFormatter = YAMLFormatter;
+});
+//# sourceMappingURL=yamlFormatter.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlFormatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlFormatter.js","sourceRoot":"","sources":["../../../../src/languageservice/services/yamlFormatter.ts"],"names":[],"mappings":"AAAA;;;;gGAIgG;;;;;;;;;;;;;IAEhG,6EAA2F;IAE3F,qCAAqC;IAErC,+CAA+C;IAG/C,MAAa,aAAa;QAA1B;YACU,qBAAgB,GAAG,IAAI,CAAC;QAsClC,CAAC;QApCQ,SAAS,CAAC,YAA8B;YAC7C,IAAI,YAAY,EAAE;gBAChB,IAAI,CAAC,gBAAgB,GAAG,YAAY,CAAC,MAAM,CAAC;aAC7C;QACH,CAAC;QAEM,MAAM,CAAC,QAAsB,EAAE,UAA+D,EAAE;YACrG,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;gBAC1B,OAAO,EAAE,CAAC;aACX;YAED,IAAI;gBACF,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAC;gBAEhC,MAAM,eAAe,GAAY;oBAC/B,MAAM,EAAE,MAAM;oBACd,OAAO,EAAE,CAAC,MAAM,CAAC;oBAEjB,4BAA4B;oBAC5B,QAAQ,EAAG,OAAO,CAAC,QAAmB,IAAI,OAAO,CAAC,OAAO;oBAEzD,iCAAiC;oBACjC,WAAW,EAAE,OAAO,CAAC,WAAW;oBAChC,cAAc,EAAE,OAAO,CAAC,cAAc;oBACtC,sEAAsE;oBACtE,SAAS,EAAE,QAAQ,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU;oBAC3G,UAAU,EAAE,OAAO,CAAC,UAAU;iBAC/B,CAAC;gBAEF,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;gBAEzD,OAAO,CAAC,sCAAQ,CAAC,OAAO,CAAC,mCAAK,CAAC,MAAM,CAAC,sCAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;aAC7G;YAAC,OAAO,KAAK,EAAE;gBACd,OAAO,EAAE,CAAC;aACX;QACH,CAAC;KACF;IAvCD,sCAuCC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlHover.d.ts

@@ -0,0 +1,16 @@
+import { Hover, Position } from 'vscode-languageserver-types';
+import { LanguageSettings } from '../yamlLanguageService';
+import { YAMLSchemaService } from './yamlSchemaService';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Telemetry } from '../telemetry';
+export declare class YAMLHover {
+    private readonly telemetry?;
+    private shouldHover;
+    private indentation;
+    private schemaService;
+    constructor(schemaService: YAMLSchemaService, telemetry?: Telemetry);
+    configure(languageSettings: LanguageSettings): void;
+    doHover(document: TextDocument, position: Position, isKubernetes?: boolean): Promise<Hover | null>;
+    private getHover;
+    private toMarkdown;
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlHover.js

@@ -0,0 +1,251 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "../utils/arrUtils", "../parser/isKubernetes", "../parser/yaml-documents", "vscode-uri", "path", "../utils/objects", "yaml"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.YAMLHover = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const arrUtils_1 = require("../utils/arrUtils");
+    const isKubernetes_1 = require("../parser/isKubernetes");
+    const yaml_documents_1 = require("../parser/yaml-documents");
+    const vscode_uri_1 = require("vscode-uri");
+    const path = require("path");
+    const objects_1 = require("../utils/objects");
+    const yaml_1 = require("yaml");
+    class YAMLHover {
+        constructor(schemaService, telemetry) {
+            this.telemetry = telemetry;
+            this.shouldHover = true;
+            this.schemaService = schemaService;
+        }
+        configure(languageSettings) {
+            if (languageSettings) {
+                this.shouldHover = languageSettings.hover;
+                this.indentation = languageSettings.indentation;
+            }
+        }
+        doHover(document, position, isKubernetes = false) {
+            try {
+                if (!this.shouldHover || !document) {
+                    return Promise.resolve(undefined);
+                }
+                const doc = yaml_documents_1.yamlDocumentsCache.getYamlDocument(document);
+                const offset = document.offsetAt(position);
+                const currentDoc = (0, arrUtils_1.matchOffsetToDocument)(offset, doc);
+                if (currentDoc === null) {
+                    return Promise.resolve(undefined);
+                }
+                (0, isKubernetes_1.setKubernetesParserOption)(doc.documents, isKubernetes);
+                const currentDocIndex = doc.documents.indexOf(currentDoc);
+                currentDoc.currentDocIndex = currentDocIndex;
+                return this.getHover(document, position, currentDoc);
+            }
+            catch (error) {
+                this.telemetry?.sendError('yaml.hover.error', { error: (0, objects_1.convertErrorToTelemetryMsg)(error) });
+            }
+        }
+        // method copied from https://github.com/microsoft/vscode-json-languageservice/blob/2ea5ad3d2ffbbe40dea11cfe764a502becf113ce/src/services/jsonHover.ts#L23
+        getHover(document, position, doc) {
+            const offset = document.offsetAt(position);
+            let node = doc.getNodeFromOffset(offset);
+            if (!node ||
+                ((node.type === 'object' || node.type === 'array') && offset > node.offset + 1 && offset < node.offset + node.length - 1)) {
+                return Promise.resolve(null);
+            }
+            const hoverRangeNode = node;
+            // use the property description when hovering over an object key
+            if (node.type === 'string') {
+                const parent = node.parent;
+                if (parent && parent.type === 'property' && parent.keyNode === node) {
+                    node = parent.valueNode;
+                    if (!node) {
+                        return Promise.resolve(null);
+                    }
+                }
+            }
+            const hoverRange = vscode_languageserver_types_1.Range.create(document.positionAt(hoverRangeNode.offset), document.positionAt(hoverRangeNode.offset + hoverRangeNode.length));
+            const createHover = (contents) => {
+                const markupContent = {
+                    kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+                    value: contents,
+                };
+                const result = {
+                    contents: markupContent,
+                    range: hoverRange,
+                };
+                return result;
+            };
+            const removePipe = (value) => {
+                return value.replace(/\|\|\s*$/, '');
+            };
+            return this.schemaService.getSchemaForResource(document.uri, doc).then((schema) => {
+                if (schema && node && !schema.errors.length) {
+                    const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
+                    let title = undefined;
+                    let markdownDescription = undefined;
+                    let markdownEnumDescriptions = [];
+                    const markdownExamples = [];
+                    const markdownEnums = [];
+                    matchingSchemas.every((s) => {
+                        if ((s.node === node || (node.type === 'property' && node.valueNode === s.node)) && !s.inverted && s.schema) {
+                            title = title || s.schema.title || s.schema.closestTitle;
+                            markdownDescription = markdownDescription || s.schema.markdownDescription || this.toMarkdown(s.schema.description);
+                            if (s.schema.enum) {
+                                if (s.schema.markdownEnumDescriptions) {
+                                    markdownEnumDescriptions = s.schema.markdownEnumDescriptions;
+                                }
+                                else if (s.schema.enumDescriptions) {
+                                    markdownEnumDescriptions = s.schema.enumDescriptions.map(this.toMarkdown, this);
+                                }
+                                else {
+                                    markdownEnumDescriptions = [];
+                                }
+                                s.schema.enum.forEach((enumValue, idx) => {
+                                    if (typeof enumValue !== 'string') {
+                                        enumValue = JSON.stringify(enumValue);
+                                    }
+                                    markdownEnums.push({
+                                        value: enumValue,
+                                        description: markdownEnumDescriptions[idx],
+                                    });
+                                });
+                            }
+                            if (s.schema.anyOf && isAllSchemasMatched(node, matchingSchemas, s.schema)) {
+                                //if append title and description of all matched schemas on hover
+                                title = '';
+                                markdownDescription = '';
+                                s.schema.anyOf.forEach((childSchema, index) => {
+                                    title += childSchema.title || s.schema.closestTitle || '';
+                                    markdownDescription += childSchema.markdownDescription || this.toMarkdown(childSchema.description) || '';
+                                    if (index !== s.schema.anyOf.length - 1) {
+                                        title += ' || ';
+                                        markdownDescription += ' || ';
+                                    }
+                                });
+                                title = removePipe(title);
+                                markdownDescription = removePipe(markdownDescription);
+                            }
+                            if (s.schema.examples) {
+                                s.schema.examples.forEach((example) => {
+                                    markdownExamples.push((0, yaml_1.stringify)(example, null, 2));
+                                });
+                            }
+                        }
+                        return true;
+                    });
+                    let result = '';
+                    if (title) {
+                        result = '#### ' + this.toMarkdown(title);
+                    }
+                    if (markdownDescription) {
+                        result = ensureLineBreak(result);
+                        result += markdownDescription;
+                    }
+                    if (markdownEnums.length !== 0) {
+                        result = ensureLineBreak(result);
+                        result += 'Allowed Values:\n\n';
+                        markdownEnums.forEach((me) => {
+                            if (me.description) {
+                                result += `* \`${toMarkdownCodeBlock(me.value)}\`: ${me.description}\n`;
+                            }
+                            else {
+                                result += `* \`${toMarkdownCodeBlock(me.value)}\`\n`;
+                            }
+                        });
+                    }
+                    if (markdownExamples.length !== 0) {
+                        markdownExamples.forEach((example) => {
+                            result = ensureLineBreak(result);
+                            result += 'Example:\n\n';
+                            result += `\`\`\`yaml\n${example}\`\`\`\n`;
+                        });
+                    }
+                    if (result.length > 0 && schema.schema.url) {
+                        result = ensureLineBreak(result);
+                        result += `Source: [${getSchemaName(schema.schema)}](${schema.schema.url})`;
+                    }
+                    return createHover(result);
+                }
+                return null;
+            });
+        }
+        // copied from https://github.com/microsoft/vscode-json-languageservice/blob/2ea5ad3d2ffbbe40dea11cfe764a502becf113ce/src/services/jsonHover.ts#L112
+        toMarkdown(plain) {
+            if (plain) {
+                let escaped = plain.replace(/([^\n\r])(\r?\n)([^\n\r])/gm, '$1\n\n$3'); // single new lines to \n\n (Markdown paragraph)
+                escaped = escaped.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&'); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
+                if (this.indentation !== undefined) {
+                    // escape indentation whitespace to prevent it from being converted to markdown code blocks.
+                    const indentationMatchRegex = new RegExp(` {${this.indentation.length}}`, 'g');
+                    escaped = escaped.replace(indentationMatchRegex, '&emsp;');
+                }
+                return escaped;
+            }
+            return undefined;
+        }
+    }
+    exports.YAMLHover = YAMLHover;
+    function ensureLineBreak(content) {
+        if (content.length === 0) {
+            return content;
+        }
+        if (!content.endsWith('\n')) {
+            content += '\n';
+        }
+        return content + '\n';
+    }
+    function getSchemaName(schema) {
+        let result = 'JSON Schema';
+        const urlString = schema.url;
+        if (urlString) {
+            const url = vscode_uri_1.URI.parse(urlString);
+            result = path.basename(url.fsPath);
+        }
+        else if (schema.title) {
+            result = schema.title;
+        }
+        return result;
+    }
+    // copied from https://github.com/microsoft/vscode-json-languageservice/blob/2ea5ad3d2ffbbe40dea11cfe764a502becf113ce/src/services/jsonHover.ts#L122
+    function toMarkdownCodeBlock(content) {
+        // see https://daringfireball.net/projects/markdown/syntax#precode
+        if (content.indexOf('`') !== -1) {
+            return '`` ' + content + ' ``';
+        }
+        return content;
+    }
+    /**
+     * check all the schemas which is inside anyOf presented or not in matching schema.
+     * @param node node
+     * @param matchingSchemas all matching schema
+     * @param schema scheam which is having anyOf
+     * @returns true if all the schemas which inside anyOf presents in matching schema
+     */
+    function isAllSchemasMatched(node, matchingSchemas, schema) {
+        let count = 0;
+        for (const matchSchema of matchingSchemas) {
+            if (node === matchSchema.node && matchSchema.schema !== schema) {
+                schema.anyOf.forEach((childSchema) => {
+                    if (matchSchema.schema.title === childSchema.title &&
+                        matchSchema.schema.description === childSchema.description &&
+                        matchSchema.schema.properties === childSchema.properties) {
+                        count++;
+                    }
+                });
+            }
+        }
+        return count === schema.anyOf.length;
+    }
+});
+//# sourceMappingURL=yamlHover.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlLinks.d.ts

@@ -0,0 +1,8 @@
+import { DocumentLink } from 'vscode-languageserver-types';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Telemetry } from '../telemetry';
+export declare class YamlLinks {
+    private readonly telemetry?;
+    constructor(telemetry?: Telemetry);
+    findLinks(document: TextDocument): Promise<DocumentLink[]>;
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlLinks.js

@@ -0,0 +1,42 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-json-languageservice/lib/umd/services/jsonLinks", "../parser/yaml-documents", "../utils/objects"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.YamlLinks = void 0;
+    /*---------------------------------------------------------------------------------------------
+     *  Copyright (c) Red Hat, Inc. All rights reserved.
+     *  Licensed under the MIT License. See License.txt in the project root for license information.
+     *--------------------------------------------------------------------------------------------*/
+    const jsonLinks_1 = require("vscode-json-languageservice/lib/umd/services/jsonLinks");
+    const yaml_documents_1 = require("../parser/yaml-documents");
+    const objects_1 = require("../utils/objects");
+    class YamlLinks {
+        constructor(telemetry) {
+            this.telemetry = telemetry;
+        }
+        findLinks(document) {
+            try {
+                const doc = yaml_documents_1.yamlDocumentsCache.getYamlDocument(document);
+                // Find links across all YAML Documents then report them back once finished
+                const linkPromises = [];
+                for (const yamlDoc of doc.documents) {
+                    linkPromises.push((0, jsonLinks_1.findLinks)(document, yamlDoc));
+                }
+                // Wait for all the promises to return and then flatten them into one DocumentLink array
+                return Promise.all(linkPromises).then((yamlLinkArray) => [].concat(...yamlLinkArray));
+            }
+            catch (err) {
+                this.telemetry?.sendError('yaml.documentLink.error', { error: (0, objects_1.convertErrorToTelemetryMsg)(err) });
+            }
+        }
+    }
+    exports.YamlLinks = YamlLinks;
+});
+//# sourceMappingURL=yamlLinks.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlLinks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlLinks.js","sourceRoot":"","sources":["../../../../src/languageservice/services/yamlLinks.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA;;;oGAGgG;IAChG,sFAAoG;IAIpG,6DAA8D;IAC9D,8CAA8D;IAE9D,MAAa,SAAS;QACpB,YAA6B,SAAqB;YAArB,cAAS,GAAT,SAAS,CAAY;QAAG,CAAC;QAEtD,SAAS,CAAC,QAAsB;YAC9B,IAAI;gBACF,MAAM,GAAG,GAAG,mCAAkB,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;gBACzD,2EAA2E;gBAC3E,MAAM,YAAY,GAAG,EAAE,CAAC;gBACxB,KAAK,MAAM,OAAO,IAAI,GAAG,CAAC,SAAS,EAAE;oBACnC,YAAY,CAAC,IAAI,CAAC,IAAA,qBAAa,EAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;iBACrD;gBACD,wFAAwF;gBACxF,OAAO,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC;aACvF;YAAC,OAAO,GAAG,EAAE;gBACZ,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,yBAAyB,EAAE,EAAE,KAAK,EAAE,IAAA,oCAA0B,EAAC,GAAG,CAAC,EAAE,CAAC,CAAC;aAClG;QACH,CAAC;KACF;IAjBD,8BAiBC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlOnTypeFormatting.d.ts

@@ -0,0 +1,4 @@
+import { DocumentOnTypeFormattingParams } from 'vscode-languageserver';
+import { TextEdit } from 'vscode-languageserver-types';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export declare function doDocumentOnTypeFormatting(document: TextDocument, params: DocumentOnTypeFormattingParams): TextEdit[] | undefined;

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlOnTypeFormatting.js

@@ -0,0 +1,57 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "../utils/textBuffer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.doDocumentOnTypeFormatting = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const textBuffer_1 = require("../utils/textBuffer");
+    function doDocumentOnTypeFormatting(document, params) {
+        const { position } = params;
+        const tb = new textBuffer_1.TextBuffer(document);
+        if (params.ch === '\n') {
+            const previousLine = tb.getLineContent(position.line - 1);
+            if (previousLine.trimRight().endsWith(':')) {
+                const currentLine = tb.getLineContent(position.line);
+                const subLine = currentLine.substring(position.character, currentLine.length);
+                const isInArray = previousLine.indexOf(' - ') !== -1;
+                if (subLine.trimRight().length === 0) {
+                    const indentationFix = position.character - (previousLine.length - previousLine.trimLeft().length);
+                    if (indentationFix === params.options.tabSize && !isInArray) {
+                        return; // skip if line already has proper formatting
+                    }
+                    const result = [];
+                    if (currentLine.length > 0) {
+                        result.push(vscode_languageserver_types_1.TextEdit.del(vscode_languageserver_types_1.Range.create(position, vscode_languageserver_types_1.Position.create(position.line, currentLine.length - 1))));
+                    }
+                    result.push(vscode_languageserver_types_1.TextEdit.insert(position, ' '.repeat(params.options.tabSize + (isInArray ? 2 - indentationFix : 0))));
+                    return result;
+                }
+                if (isInArray) {
+                    return [vscode_languageserver_types_1.TextEdit.insert(position, ' '.repeat(params.options.tabSize))];
+                }
+            }
+            if (previousLine.trimRight().endsWith('|')) {
+                return [vscode_languageserver_types_1.TextEdit.insert(position, ' '.repeat(params.options.tabSize))];
+            }
+            if (previousLine.includes(' - ') && !previousLine.includes(': ')) {
+                return [vscode_languageserver_types_1.TextEdit.insert(position, '- ')];
+            }
+            if (previousLine.includes(' - ') && previousLine.includes(': ')) {
+                return [vscode_languageserver_types_1.TextEdit.insert(position, '  ')];
+            }
+        }
+    }
+    exports.doDocumentOnTypeFormatting = doDocumentOnTypeFormatting;
+});
+//# sourceMappingURL=yamlOnTypeFormatting.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlOnTypeFormatting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlOnTypeFormatting.js","sourceRoot":"","sources":["../../../../src/languageservice/services/yamlOnTypeFormatting.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAGhG,6EAAwE;IAExE,oDAAiD;IAEjD,SAAgB,0BAA0B,CACxC,QAAsB,EACtB,MAAsC;QAEtC,MAAM,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC;QAC5B,MAAM,EAAE,GAAG,IAAI,uBAAU,CAAC,QAAQ,CAAC,CAAC;QACpC,IAAI,MAAM,CAAC,EAAE,KAAK,IAAI,EAAE;YACtB,MAAM,YAAY,GAAG,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;YAC1D,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;gBAC1C,MAAM,WAAW,GAAG,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACrD,MAAM,OAAO,GAAG,WAAW,CAAC,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;gBAC9E,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;gBACrD,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE;oBACpC,MAAM,cAAc,GAAG,QAAQ,CAAC,SAAS,GAAG,CAAC,YAAY,CAAC,MAAM,GAAG,YAAY,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,CAAC;oBACnG,IAAI,cAAc,KAAK,MAAM,CAAC,OAAO,CAAC,OAAO,IAAI,CAAC,SAAS,EAAE;wBAC3D,OAAO,CAAC,6CAA6C;qBACtD;oBACD,MAAM,MAAM,GAAG,EAAE,CAAC;oBAClB,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE;wBAC1B,MAAM,CAAC,IAAI,CAAC,sCAAQ,CAAC,GAAG,CAAC,mCAAK,CAAC,MAAM,CAAC,QAAQ,EAAE,sCAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;qBAC3G;oBACD,MAAM,CAAC,IAAI,CAAC,sCAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBAElH,OAAO,MAAM,CAAC;iBACf;gBACD,IAAI,SAAS,EAAE;oBACb,OAAO,CAAC,sCAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;iBACxE;aACF;YAED,IAAI,YAAY,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;gBAC1C,OAAO,CAAC,sCAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;aACxE;YAED,IAAI,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;gBAChE,OAAO,CAAC,sCAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;aAC1C;YAED,IAAI,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;gBAC/D,OAAO,CAAC,sCAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC;aAC1C;SACF;IACH,CAAC;IA1CD,gEA0CC"}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlSchemaService.d.ts

@@ -0,0 +1,102 @@
+import { JSONSchema } from '../jsonSchema';
+import { SchemaPriority, SchemaRequestService, WorkspaceContextService } from '../yamlLanguageService';
+import { UnresolvedSchema, ResolvedSchema, JSONSchemaService, SchemaDependencies, ISchemaContributions, SchemaHandle } from 'vscode-json-languageservice/lib/umd/services/jsonSchemaService';
+import { JSONDocument } from '../parser/jsonParser07';
+import { JSONSchemaDescriptionExt } from '../../requestTypes';
+import { SchemaVersions } from '../yamlTypes';
+export declare type CustomSchemaProvider = (uri: string) => Promise<string | string[]>;
+export declare enum MODIFICATION_ACTIONS {
+    'delete' = 0,
+    'add' = 1,
+    'deleteAll' = 2
+}
+export interface SchemaAdditions {
+    schema: string;
+    action: MODIFICATION_ACTIONS.add;
+    path: string;
+    key: string;
+    content: any;
+}
+export interface SchemaDeletions {
+    schema: string;
+    action: MODIFICATION_ACTIONS.delete;
+    path: string;
+    key: string;
+}
+export interface SchemaDeletionsAll {
+    schemas: string[];
+    action: MODIFICATION_ACTIONS.deleteAll;
+}
+export declare class FilePatternAssociation {
+    private schemas;
+    private patternRegExp;
+    constructor(pattern: string);
+    addSchema(id: string): void;
+    matchesPattern(fileName: string): boolean;
+    getSchemas(): string[];
+}
+export declare class YAMLSchemaService extends JSONSchemaService {
+    [x: string]: any;
+    private customSchemaProvider;
+    private filePatternAssociations;
+    private contextService;
+    private requestService;
+    schemaPriorityMapping: Map<string, Set<SchemaPriority>>;
+    private schemaUriToNameAndDescription;
+    constructor(requestService: SchemaRequestService, contextService?: WorkspaceContextService, promiseConstructor?: PromiseConstructor);
+    registerCustomSchemaProvider(customSchemaProvider: CustomSchemaProvider): void;
+    getAllSchemas(): JSONSchemaDescriptionExt[];
+    resolveSchemaContent(schemaToResolve: UnresolvedSchema, schemaURL: string, dependencies: SchemaDependencies): Promise<ResolvedSchema>;
+    getSchemaForResource(resource: string, doc: JSONDocument): Promise<ResolvedSchema>;
+    addSchemaPriority(uri: string, priority: number): void;
+    /**
+     * Search through all the schemas and find the ones with the highest priority
+     */
+    private highestPrioritySchemas;
+    private resolveCustomSchema;
+    /**
+     * Save a schema with schema ID and schema content.
+     * Overrides previous schemas set for that schema ID.
+     */
+    saveSchema(schemaId: string, schemaContent: JSONSchema): Promise<void>;
+    /**
+     * Delete schemas on specific path
+     */
+    deleteSchemas(deletions: SchemaDeletionsAll): Promise<void>;
+    /**
+     * Delete a schema with schema ID.
+     */
+    deleteSchema(schemaId: string): Promise<void>;
+    /**
+     * Add content to a specified schema at a specified path
+     */
+    addContent(additions: SchemaAdditions): Promise<void>;
+    /**
+     * Delete content in a specified schema at a specified path
+     */
+    deleteContent(deletions: SchemaDeletions): Promise<void>;
+    /**
+     * Take a JSON Schema and the path that you would like to get to
+     * @returns the JSON Schema resolved at that specific path
+     */
+    private resolveJSONSchemaToSection;
+    /**
+     * Resolve the next Object if they have compatible types
+     * @param object a location in the JSON Schema
+     * @param token the next token that you want to search for
+     */
+    private resolveNext;
+    /**
+     * Everything below here is needed because we're importing from vscode-json-languageservice umd and we need
+     * to provide a wrapper around the javascript methods we are calling since they have no type
+     */
+    normalizeId(id: string): string;
+    getOrAddSchemaHandle(id: string, unresolvedSchemaContent?: JSONSchema): SchemaHandle;
+    loadSchema(schemaUri: string): Promise<UnresolvedSchema>;
+    registerExternalSchema(uri: string, filePatterns?: string[], unresolvedSchema?: JSONSchema, name?: string, description?: string, versions?: SchemaVersions): SchemaHandle;
+    clearExternalSchemas(): void;
+    setSchemaContributions(schemaContributions: ISchemaContributions): void;
+    getRegisteredSchemaIds(filter?: (scheme: any) => boolean): string[];
+    getResolvedSchema(schemaId: string): Promise<ResolvedSchema>;
+    onResourceChange(uri: string): boolean;
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlSchemaService.js

@@ -0,0 +1,585 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../yamlLanguageService", "vscode-json-languageservice/lib/umd/services/jsonSchemaService", "vscode-uri", "vscode-nls", "../utils/strings", "yaml", "path", "./modelineUtil", "ajv", "../utils/schemaUtils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.YAMLSchemaService = exports.FilePatternAssociation = exports.MODIFICATION_ACTIONS = void 0;
+    const yamlLanguageService_1 = require("../yamlLanguageService");
+    const jsonSchemaService_1 = require("vscode-json-languageservice/lib/umd/services/jsonSchemaService");
+    const vscode_uri_1 = require("vscode-uri");
+    const nls = require("vscode-nls");
+    const strings_1 = require("../utils/strings");
+    const yaml_1 = require("yaml");
+    const path = require("path");
+    const modelineUtil_1 = require("./modelineUtil");
+    const ajv_1 = require("ajv");
+    const schemaUtils_1 = require("../utils/schemaUtils");
+    const localize = nls.loadMessageBundle();
+    const ajv = new ajv_1.default();
+    // load JSON Schema 07 def to validate loaded schemas
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const jsonSchema07 = require('ajv/dist/refs/json-schema-draft-07.json');
+    const schema07Validator = ajv.compile(jsonSchema07);
+    var MODIFICATION_ACTIONS;
+    (function (MODIFICATION_ACTIONS) {
+        MODIFICATION_ACTIONS[MODIFICATION_ACTIONS["delete"] = 0] = "delete";
+        MODIFICATION_ACTIONS[MODIFICATION_ACTIONS["add"] = 1] = "add";
+        MODIFICATION_ACTIONS[MODIFICATION_ACTIONS["deleteAll"] = 2] = "deleteAll";
+    })(MODIFICATION_ACTIONS = exports.MODIFICATION_ACTIONS || (exports.MODIFICATION_ACTIONS = {}));
+    class FilePatternAssociation {
+        constructor(pattern) {
+            try {
+                this.patternRegExp = new RegExp((0, strings_1.convertSimple2RegExpPattern)(pattern) + '$');
+            }
+            catch (e) {
+                // invalid pattern
+                this.patternRegExp = null;
+            }
+            this.schemas = [];
+        }
+        addSchema(id) {
+            this.schemas.push(id);
+        }
+        matchesPattern(fileName) {
+            return this.patternRegExp && this.patternRegExp.test(fileName);
+        }
+        getSchemas() {
+            return this.schemas;
+        }
+    }
+    exports.FilePatternAssociation = FilePatternAssociation;
+    class YAMLSchemaService extends jsonSchemaService_1.JSONSchemaService {
+        constructor(requestService, contextService, promiseConstructor) {
+            super(requestService, contextService, promiseConstructor);
+            this.schemaUriToNameAndDescription = new Map();
+            this.customSchemaProvider = undefined;
+            this.requestService = requestService;
+            this.schemaPriorityMapping = new Map();
+        }
+        registerCustomSchemaProvider(customSchemaProvider) {
+            this.customSchemaProvider = customSchemaProvider;
+        }
+        getAllSchemas() {
+            const result = [];
+            const schemaUris = new Set();
+            for (const filePattern of this.filePatternAssociations) {
+                const schemaUri = filePattern.uris[0];
+                if (schemaUris.has(schemaUri)) {
+                    continue;
+                }
+                schemaUris.add(schemaUri);
+                const schemaHandle = {
+                    uri: schemaUri,
+                    fromStore: false,
+                    usedForCurrentFile: false,
+                };
+                if (this.schemaUriToNameAndDescription.has(schemaUri)) {
+                    const { name, description, versions } = this.schemaUriToNameAndDescription.get(schemaUri);
+                    schemaHandle.name = name;
+                    schemaHandle.description = description;
+                    schemaHandle.fromStore = true;
+                    schemaHandle.versions = versions;
+                }
+                result.push(schemaHandle);
+            }
+            return result;
+        }
+        async resolveSchemaContent(schemaToResolve, schemaURL, dependencies) {
+            const resolveErrors = schemaToResolve.errors.slice(0);
+            let schema = schemaToResolve.schema;
+            const contextService = this.contextService;
+            if (!schema07Validator(schema)) {
+                const errs = [];
+                for (const err of schema07Validator.errors) {
+                    errs.push(`${err.instancePath} : ${err.message}`);
+                }
+                resolveErrors.push(`Schema '${(0, schemaUtils_1.getSchemaTitle)(schemaToResolve.schema, schemaURL)}' is not valid:\n${errs.join('\n')}`);
+            }
+            const findSection = (schema, path) => {
+                if (!path) {
+                    return schema;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                let current = schema;
+                if (path[0] === '/') {
+                    path = path.substr(1);
+                }
+                path.split('/').some((part) => {
+                    current = current[part];
+                    return !current;
+                });
+                return current;
+            };
+            const merge = (target, sourceRoot, sourceURI, path) => {
+                const section = findSection(sourceRoot, path);
+                if (section) {
+                    for (const key in section) {
+                        if (Object.prototype.hasOwnProperty.call(section, key) && !Object.prototype.hasOwnProperty.call(target, key)) {
+                            target[key] = section[key];
+                        }
+                    }
+                }
+                else {
+                    resolveErrors.push(localize('json.schema.invalidref', "$ref '{0}' in '{1}' can not be resolved.", path, sourceURI));
+                }
+            };
+            const resolveExternalLink = (node, uri, linkPath, parentSchemaURL, parentSchemaDependencies
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ) => {
+                if (contextService && !/^\w+:\/\/.*/.test(uri)) {
+                    uri = contextService.resolveRelativePath(uri, parentSchemaURL);
+                }
+                uri = this.normalizeId(uri);
+                const referencedHandle = this.getOrAddSchemaHandle(uri);
+                return referencedHandle.getUnresolvedSchema().then((unresolvedSchema) => {
+                    parentSchemaDependencies[uri] = true;
+                    if (unresolvedSchema.errors.length) {
+                        const loc = linkPath ? uri + '#' + linkPath : uri;
+                        resolveErrors.push(localize('json.schema.problemloadingref', "Problems loading reference '{0}': {1}", loc, unresolvedSchema.errors[0]));
+                    }
+                    merge(node, unresolvedSchema.schema, uri, linkPath);
+                    node.url = uri;
+                    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                    return resolveRefs(node, unresolvedSchema.schema, uri, referencedHandle.dependencies);
+                });
+            };
+            const resolveRefs = async (node, parentSchema, parentSchemaURL, parentSchemaDependencies
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ) => {
+                if (!node || typeof node !== 'object') {
+                    return null;
+                }
+                const toWalk = [node];
+                const seen = new Set();
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                const openPromises = [];
+                const collectEntries = (...entries) => {
+                    for (const entry of entries) {
+                        if (typeof entry === 'object') {
+                            toWalk.push(entry);
+                        }
+                    }
+                };
+                const collectMapEntries = (...maps) => {
+                    for (const map of maps) {
+                        if (typeof map === 'object') {
+                            for (const key in map) {
+                                const entry = map[key];
+                                if (typeof entry === 'object') {
+                                    toWalk.push(entry);
+                                }
+                            }
+                        }
+                    }
+                };
+                const collectArrayEntries = (...arrays) => {
+                    for (const array of arrays) {
+                        if (Array.isArray(array)) {
+                            for (const entry of array) {
+                                if (typeof entry === 'object') {
+                                    toWalk.push(entry);
+                                }
+                            }
+                        }
+                    }
+                };
+                const handleRef = (next) => {
+                    const seenRefs = new Set();
+                    while (next.$ref) {
+                        const ref = next.$ref;
+                        const segments = ref.split('#', 2);
+                        //return back removed $ref. We lost info about referenced type without it.
+                        next._$ref = next.$ref;
+                        delete next.$ref;
+                        if (segments[0].length > 0) {
+                            openPromises.push(resolveExternalLink(next, segments[0], segments[1], parentSchemaURL, parentSchemaDependencies));
+                            return;
+                        }
+                        else {
+                            if (!seenRefs.has(ref)) {
+                                merge(next, parentSchema, parentSchemaURL, segments[1]); // can set next.$ref again, use seenRefs to avoid circle
+                                seenRefs.add(ref);
+                            }
+                        }
+                    }
+                    collectEntries(next.items, next.additionalItems, next.additionalProperties, next.not, next.contains, next.propertyNames, next.if, next.then, next.else);
+                    collectMapEntries(next.definitions, next.properties, next.patternProperties, next.dependencies);
+                    collectArrayEntries(next.anyOf, next.allOf, next.oneOf, next.items, next.schemaSequence);
+                };
+                if (parentSchemaURL.indexOf('#') > 0) {
+                    const segments = parentSchemaURL.split('#', 2);
+                    if (segments[0].length > 0 && segments[1].length > 0) {
+                        const newSchema = {};
+                        await resolveExternalLink(newSchema, segments[0], segments[1], parentSchemaURL, parentSchemaDependencies);
+                        for (const key in schema) {
+                            if (key === 'required') {
+                                continue;
+                            }
+                            if (Object.prototype.hasOwnProperty.call(schema, key) && !Object.prototype.hasOwnProperty.call(newSchema, key)) {
+                                newSchema[key] = schema[key];
+                            }
+                        }
+                        schema = newSchema;
+                    }
+                }
+                while (toWalk.length) {
+                    const next = toWalk.pop();
+                    if (seen.has(next)) {
+                        continue;
+                    }
+                    seen.add(next);
+                    handleRef(next);
+                }
+                return Promise.all(openPromises);
+            };
+            await resolveRefs(schema, schema, schemaURL, dependencies);
+            return new jsonSchemaService_1.ResolvedSchema(schema, resolveErrors);
+        }
+        getSchemaForResource(resource, doc) {
+            const resolveModelineSchema = () => {
+                let schemaFromModeline = (0, modelineUtil_1.getSchemaFromModeline)(doc);
+                if (schemaFromModeline !== undefined) {
+                    if (!schemaFromModeline.startsWith('file:') && !schemaFromModeline.startsWith('http')) {
+                        // If path contains a fragment and it is left intact, "#" will be
+                        // considered part of the filename and converted to "%23" by
+                        // path.resolve() -> take it out and add back after path.resolve
+                        let appendix = '';
+                        if (schemaFromModeline.indexOf('#') > 0) {
+                            const segments = schemaFromModeline.split('#', 2);
+                            schemaFromModeline = segments[0];
+                            appendix = segments[1];
+                        }
+                        if (!path.isAbsolute(schemaFromModeline)) {
+                            const resUri = vscode_uri_1.URI.parse(resource);
+                            schemaFromModeline = vscode_uri_1.URI.file(path.resolve(path.parse(resUri.fsPath).dir, schemaFromModeline)).toString();
+                        }
+                        else {
+                            schemaFromModeline = vscode_uri_1.URI.file(schemaFromModeline).toString();
+                        }
+                        if (appendix.length > 0) {
+                            schemaFromModeline += '#' + appendix;
+                        }
+                    }
+                    return schemaFromModeline;
+                }
+            };
+            const resolveSchemaForResource = (schemas) => {
+                const schemaHandle = super.createCombinedSchema(resource, schemas);
+                return schemaHandle.getResolvedSchema().then((schema) => {
+                    if (schema.schema && typeof schema.schema === 'object') {
+                        schema.schema.url = schemaHandle.url;
+                    }
+                    if (schema.schema &&
+                        schema.schema.schemaSequence &&
+                        schema.schema.schemaSequence[doc.currentDocIndex]) {
+                        return new jsonSchemaService_1.ResolvedSchema(schema.schema.schemaSequence[doc.currentDocIndex]);
+                    }
+                    return schema;
+                });
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const resolveSchema = () => {
+                const seen = Object.create(null);
+                const schemas = [];
+                for (const entry of this.filePatternAssociations) {
+                    if (entry.matchesPattern(resource)) {
+                        for (const schemaId of entry.getURIs()) {
+                            if (!seen[schemaId]) {
+                                schemas.push(schemaId);
+                                seen[schemaId] = true;
+                            }
+                        }
+                    }
+                }
+                if (schemas.length > 0) {
+                    // Join all schemas with the highest priority.
+                    const highestPrioSchemas = this.highestPrioritySchemas(schemas);
+                    return resolveSchemaForResource(highestPrioSchemas);
+                }
+                return Promise.resolve(null);
+            };
+            const modelineSchema = resolveModelineSchema();
+            if (modelineSchema) {
+                return resolveSchemaForResource([modelineSchema]);
+            }
+            if (this.customSchemaProvider) {
+                return this.customSchemaProvider(resource)
+                    .then((schemaUri) => {
+                    if (Array.isArray(schemaUri)) {
+                        if (schemaUri.length === 0) {
+                            return resolveSchema();
+                        }
+                        return Promise.all(schemaUri.map((schemaUri) => {
+                            return this.resolveCustomSchema(schemaUri, doc);
+                        })).then((schemas) => {
+                            return {
+                                errors: [],
+                                schema: {
+                                    allOf: schemas.map((schemaObj) => {
+                                        return schemaObj.schema;
+                                    }),
+                                },
+                            };
+                        }, () => {
+                            return resolveSchema();
+                        });
+                    }
+                    if (!schemaUri) {
+                        return resolveSchema();
+                    }
+                    return this.resolveCustomSchema(schemaUri, doc);
+                })
+                    .then((schema) => {
+                    return schema;
+                }, () => {
+                    return resolveSchema();
+                });
+            }
+            else {
+                return resolveSchema();
+            }
+        }
+        // Set the priority of a schema in the schema service
+        addSchemaPriority(uri, priority) {
+            let currSchemaArray = this.schemaPriorityMapping.get(uri);
+            if (currSchemaArray) {
+                currSchemaArray = currSchemaArray.add(priority);
+                this.schemaPriorityMapping.set(uri, currSchemaArray);
+            }
+            else {
+                this.schemaPriorityMapping.set(uri, new Set().add(priority));
+            }
+        }
+        /**
+         * Search through all the schemas and find the ones with the highest priority
+         */
+        highestPrioritySchemas(schemas) {
+            let highestPrio = 0;
+            const priorityMapping = new Map();
+            schemas.forEach((schema) => {
+                // If the schema does not have a priority then give it a default one of [0]
+                const priority = this.schemaPriorityMapping.get(schema) || [0];
+                priority.forEach((prio) => {
+                    if (prio > highestPrio) {
+                        highestPrio = prio;
+                    }
+                    // Build up a mapping of priority to schemas so that we can easily get the highest priority schemas easier
+                    let currPriorityArray = priorityMapping.get(prio);
+                    if (currPriorityArray) {
+                        currPriorityArray = currPriorityArray.concat(schema);
+                        priorityMapping.set(prio, currPriorityArray);
+                    }
+                    else {
+                        priorityMapping.set(prio, [schema]);
+                    }
+                });
+            });
+            return priorityMapping.get(highestPrio) || [];
+        }
+        async resolveCustomSchema(schemaUri, doc) {
+            const unresolvedSchema = await this.loadSchema(schemaUri);
+            const schema = await this.resolveSchemaContent(unresolvedSchema, schemaUri, []);
+            if (schema.schema && typeof schema.schema === 'object') {
+                schema.schema.url = schemaUri;
+            }
+            if (schema.schema && schema.schema.schemaSequence && schema.schema.schemaSequence[doc.currentDocIndex]) {
+                return new jsonSchemaService_1.ResolvedSchema(schema.schema.schemaSequence[doc.currentDocIndex], schema.errors);
+            }
+            return schema;
+        }
+        /**
+         * Save a schema with schema ID and schema content.
+         * Overrides previous schemas set for that schema ID.
+         */
+        async saveSchema(schemaId, schemaContent) {
+            const id = this.normalizeId(schemaId);
+            this.getOrAddSchemaHandle(id, schemaContent);
+            this.schemaPriorityMapping.set(id, new Set().add(yamlLanguageService_1.SchemaPriority.Settings));
+            return Promise.resolve(undefined);
+        }
+        /**
+         * Delete schemas on specific path
+         */
+        async deleteSchemas(deletions) {
+            deletions.schemas.forEach((s) => {
+                this.deleteSchema(s);
+            });
+            return Promise.resolve(undefined);
+        }
+        /**
+         * Delete a schema with schema ID.
+         */
+        async deleteSchema(schemaId) {
+            const id = this.normalizeId(schemaId);
+            if (this.schemasById[id]) {
+                delete this.schemasById[id];
+            }
+            this.schemaPriorityMapping.delete(id);
+            return Promise.resolve(undefined);
+        }
+        /**
+         * Add content to a specified schema at a specified path
+         */
+        async addContent(additions) {
+            const schema = await this.getResolvedSchema(additions.schema);
+            if (schema) {
+                const resolvedSchemaLocation = this.resolveJSONSchemaToSection(schema.schema, additions.path);
+                if (typeof resolvedSchemaLocation === 'object') {
+                    resolvedSchemaLocation[additions.key] = additions.content;
+                }
+                await this.saveSchema(additions.schema, schema.schema);
+            }
+        }
+        /**
+         * Delete content in a specified schema at a specified path
+         */
+        async deleteContent(deletions) {
+            const schema = await this.getResolvedSchema(deletions.schema);
+            if (schema) {
+                const resolvedSchemaLocation = this.resolveJSONSchemaToSection(schema.schema, deletions.path);
+                if (typeof resolvedSchemaLocation === 'object') {
+                    delete resolvedSchemaLocation[deletions.key];
+                }
+                await this.saveSchema(deletions.schema, schema.schema);
+            }
+        }
+        /**
+         * Take a JSON Schema and the path that you would like to get to
+         * @returns the JSON Schema resolved at that specific path
+         */
+        resolveJSONSchemaToSection(schema, paths) {
+            const splitPathway = paths.split('/');
+            let resolvedSchemaLocation = schema;
+            for (const path of splitPathway) {
+                if (path === '') {
+                    continue;
+                }
+                this.resolveNext(resolvedSchemaLocation, path);
+                resolvedSchemaLocation = resolvedSchemaLocation[path];
+            }
+            return resolvedSchemaLocation;
+        }
+        /**
+         * Resolve the next Object if they have compatible types
+         * @param object a location in the JSON Schema
+         * @param token the next token that you want to search for
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        resolveNext(object, token) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (Array.isArray(object) && isNaN(token)) {
+                throw new Error('Expected a number after the array object');
+            }
+            else if (typeof object === 'object' && typeof token !== 'string') {
+                throw new Error('Expected a string after the object');
+            }
+        }
+        /**
+         * Everything below here is needed because we're importing from vscode-json-languageservice umd and we need
+         * to provide a wrapper around the javascript methods we are calling since they have no type
+         */
+        normalizeId(id) {
+            // The parent's `super.normalizeId(id)` isn't visible, so duplicated the code here
+            try {
+                return vscode_uri_1.URI.parse(id).toString();
+            }
+            catch (e) {
+                return id;
+            }
+        }
+        /*
+         * Everything below here is needed because we're importing from vscode-json-languageservice umd and we need
+         * to provide a wrapper around the javascript methods we are calling since they have no type
+         */
+        getOrAddSchemaHandle(id, unresolvedSchemaContent) {
+            return super.getOrAddSchemaHandle(id, unresolvedSchemaContent);
+        }
+        loadSchema(schemaUri) {
+            const requestService = this.requestService;
+            return super.loadSchema(schemaUri).then((unresolvedJsonSchema) => {
+                // If json-language-server failed to parse the schema, attempt to parse it as YAML instead.
+                if (unresolvedJsonSchema.errors && unresolvedJsonSchema.schema === undefined) {
+                    return requestService(schemaUri).then((content) => {
+                        if (!content) {
+                            const errorMessage = localize('json.schema.nocontent', "Unable to load schema from '{0}': No content. {1}", toDisplayString(schemaUri), unresolvedJsonSchema.errors);
+                            return new jsonSchemaService_1.UnresolvedSchema({}, [errorMessage]);
+                        }
+                        try {
+                            const schemaContent = (0, yaml_1.parse)(content);
+                            return new jsonSchemaService_1.UnresolvedSchema(schemaContent, []);
+                        }
+                        catch (yamlError) {
+                            const errorMessage = localize('json.schema.invalidFormat', "Unable to parse content from '{0}': {1}.", toDisplayString(schemaUri), yamlError);
+                            return new jsonSchemaService_1.UnresolvedSchema({}, [errorMessage]);
+                        }
+                    }, 
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (error) => {
+                        let errorMessage = error.toString();
+                        const errorSplit = error.toString().split('Error: ');
+                        if (errorSplit.length > 1) {
+                            // more concise error message, URL and context are attached by caller anyways
+                            errorMessage = errorSplit[1];
+                        }
+                        return new jsonSchemaService_1.UnresolvedSchema({}, [errorMessage]);
+                    });
+                }
+                unresolvedJsonSchema.uri = schemaUri;
+                if (this.schemaUriToNameAndDescription.has(schemaUri)) {
+                    const { name, description, versions } = this.schemaUriToNameAndDescription.get(schemaUri);
+                    unresolvedJsonSchema.schema.title = name ?? unresolvedJsonSchema.schema.title;
+                    unresolvedJsonSchema.schema.description = description ?? unresolvedJsonSchema.schema.description;
+                    unresolvedJsonSchema.schema.versions = versions ?? unresolvedJsonSchema.schema.versions;
+                }
+                return unresolvedJsonSchema;
+            });
+        }
+        registerExternalSchema(uri, filePatterns, unresolvedSchema, name, description, versions) {
+            if (name || description) {
+                this.schemaUriToNameAndDescription.set(uri, { name, description, versions });
+            }
+            return super.registerExternalSchema(uri, filePatterns, unresolvedSchema);
+        }
+        clearExternalSchemas() {
+            super.clearExternalSchemas();
+        }
+        setSchemaContributions(schemaContributions) {
+            super.setSchemaContributions(schemaContributions);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getRegisteredSchemaIds(filter) {
+            return super.getRegisteredSchemaIds(filter);
+        }
+        getResolvedSchema(schemaId) {
+            return super.getResolvedSchema(schemaId);
+        }
+        onResourceChange(uri) {
+            return super.onResourceChange(uri);
+        }
+    }
+    exports.YAMLSchemaService = YAMLSchemaService;
+    function toDisplayString(url) {
+        try {
+            const uri = vscode_uri_1.URI.parse(url);
+            if (uri.scheme === 'file') {
+                return uri.fsPath;
+            }
+        }
+        catch (e) {
+            // ignore
+        }
+        return url;
+    }
+});
+//# sourceMappingURL=yamlSchemaService.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlSelectionRanges.d.ts

@@ -0,0 +1,3 @@
+import { Position, SelectionRange } from 'vscode-languageserver-types';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+export declare function getSelectionRanges(document: TextDocument, positions: Position[]): SelectionRange[];

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlSelectionRanges.js

@@ -0,0 +1,144 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "../parser/yaml-documents"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getSelectionRanges = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const yaml_documents_1 = require("../parser/yaml-documents");
+    function getSelectionRanges(document, positions) {
+        const doc = yaml_documents_1.yamlDocumentsCache.getYamlDocument(document);
+        return positions.map((position) => {
+            const ranges = getRanges(position);
+            let current;
+            for (const range of ranges) {
+                current = vscode_languageserver_types_1.SelectionRange.create(range, current);
+            }
+            return current ?? vscode_languageserver_types_1.SelectionRange.create({ start: position, end: position });
+        });
+        function getRanges(position) {
+            const offset = document.offsetAt(position);
+            const result = [];
+            for (const ymlDoc of doc.documents) {
+                let currentNode;
+                let overrideStartOffset;
+                ymlDoc.visit((node) => {
+                    const endOffset = node.offset + node.length;
+                    // Skip if end offset doesn't even reach cursor position
+                    if (endOffset < offset) {
+                        return true;
+                    }
+                    // Skip if we're ending at new line
+                    // times:
+                    //   - second: 1
+                    //     millisecond: 10
+                    // | - second: 2
+                    // ↑   millisecond: 0
+                    // (| is actually part of { second: 1, millisecond: 10 })
+                    // \r\n doesn't matter here
+                    if (getTextFromOffsets(endOffset - 1, endOffset) === '\n') {
+                        if (endOffset - 1 < offset) {
+                            return true;
+                        }
+                    }
+                    let startOffset = node.offset;
+                    if (startOffset > offset) {
+                        // Recheck start offset for some special cases
+                        const newOffset = getStartOffsetForSpecialCases(node, position);
+                        if (!newOffset || newOffset > offset) {
+                            return true;
+                        }
+                        startOffset = newOffset;
+                    }
+                    // Allow equal for children to override
+                    if (!currentNode || startOffset >= currentNode.offset) {
+                        currentNode = node;
+                        overrideStartOffset = startOffset;
+                    }
+                    return true;
+                });
+                while (currentNode) {
+                    const startOffset = overrideStartOffset ?? currentNode.offset;
+                    const endOffset = currentNode.offset + currentNode.length;
+                    const range = {
+                        start: document.positionAt(startOffset),
+                        end: document.positionAt(endOffset),
+                    };
+                    const text = document.getText(range);
+                    const trimmedText = trimEndNewLine(text);
+                    const trimmedEndOffset = startOffset + trimmedText.length;
+                    if (trimmedEndOffset >= offset) {
+                        range.end = document.positionAt(trimmedEndOffset);
+                    }
+                    // Add a jump between '' "" {} []
+                    const isSurroundedBy = (startCharacter, endCharacter) => {
+                        return trimmedText.startsWith(startCharacter) && trimmedText.endsWith(endCharacter || startCharacter);
+                    };
+                    if ((currentNode.type === 'string' && (isSurroundedBy("'") || isSurroundedBy('"'))) ||
+                        (currentNode.type === 'object' && isSurroundedBy('{', '}')) ||
+                        (currentNode.type === 'array' && isSurroundedBy('[', ']'))) {
+                        result.push({
+                            start: document.positionAt(startOffset + 1),
+                            end: document.positionAt(endOffset - 1),
+                        });
+                    }
+                    result.push(range);
+                    currentNode = currentNode.parent;
+                    overrideStartOffset = undefined;
+                }
+                // A position can't be in multiple documents
+                if (result.length > 0) {
+                    break;
+                }
+            }
+            return result.reverse();
+        }
+        function getStartOffsetForSpecialCases(node, position) {
+            const nodeStartPosition = document.positionAt(node.offset);
+            if (nodeStartPosition.line !== position.line) {
+                return;
+            }
+            if (node.parent?.type === 'array') {
+                // array:
+                //   - value
+                //    ↑
+                if (getTextFromOffsets(node.offset - 2, node.offset) === '- ') {
+                    return node.offset - 2;
+                }
+            }
+            if (node.type === 'array' || node.type === 'object') {
+                // array:
+                //   - value
+                // ↑
+                const lineBeginning = { line: nodeStartPosition.line, character: 0 };
+                const text = document.getText({ start: lineBeginning, end: nodeStartPosition });
+                if (text.trim().length === 0) {
+                    return document.offsetAt(lineBeginning);
+                }
+            }
+        }
+        function getTextFromOffsets(startOffset, endOffset) {
+            return document.getText({
+                start: document.positionAt(startOffset),
+                end: document.positionAt(endOffset),
+            });
+        }
+    }
+    exports.getSelectionRanges = getSelectionRanges;
+    function trimEndNewLine(str) {
+        if (str.endsWith('\r\n')) {
+            return str.substring(0, str.length - 2);
+        }
+        if (str.endsWith('\n')) {
+            return str.substring(0, str.length - 1);
+        }
+        return str;
+    }
+});
+//# sourceMappingURL=yamlSelectionRanges.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlSelectionRanges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlSelectionRanges.js","sourceRoot":"","sources":["../../../../src/languageservice/services/yamlSelectionRanges.ts"],"names":[],"mappings":"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"}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlValidation.d.ts

@@ -0,0 +1,26 @@
+import { Diagnostic } from 'vscode-languageserver-types';
+import { LanguageSettings } from '../yamlLanguageService';
+import { YAMLSchemaService } from './yamlSchemaService';
+import { YAMLDocDiagnostic } from '../utils/parseUtils';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Telemetry } from '../telemetry';
+/**
+ * Convert a YAMLDocDiagnostic to a language server Diagnostic
+ * @param yamlDiag A YAMLDocDiagnostic from the parser
+ * @param textDocument TextDocument from the language server client
+ */
+export declare const yamlDiagToLSDiag: (yamlDiag: YAMLDocDiagnostic, textDocument: TextDocument) => Diagnostic;
+export declare class YAMLValidation {
+    private readonly telemetry?;
+    private validationEnabled;
+    private customTags;
+    private jsonValidation;
+    private disableAdditionalProperties;
+    private yamlVersion;
+    private validators;
+    private MATCHES_MULTIPLE;
+    constructor(schemaService: YAMLSchemaService, telemetry?: Telemetry);
+    configure(settings: LanguageSettings): void;
+    doValidation(textDocument: TextDocument, isKubernetes?: boolean): Promise<Diagnostic[]>;
+    private runAdditionalValidators;
+}

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlValidation.js

@@ -0,0 +1,144 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "vscode-languageserver-types", "vscode-json-languageservice/lib/umd/services/jsonValidation", "../parser/jsonParser07", "../utils/textBuffer", "../parser/yaml-documents", "../utils/objects", "./validation/unused-anchors", "./validation/yaml-style", "./validation/map-key-order"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.YAMLValidation = exports.yamlDiagToLSDiag = void 0;
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const jsonValidation_1 = require("vscode-json-languageservice/lib/umd/services/jsonValidation");
+    const jsonParser07_1 = require("../parser/jsonParser07");
+    const textBuffer_1 = require("../utils/textBuffer");
+    const yaml_documents_1 = require("../parser/yaml-documents");
+    const objects_1 = require("../utils/objects");
+    const unused_anchors_1 = require("./validation/unused-anchors");
+    const yaml_style_1 = require("./validation/yaml-style");
+    const map_key_order_1 = require("./validation/map-key-order");
+    /**
+     * Convert a YAMLDocDiagnostic to a language server Diagnostic
+     * @param yamlDiag A YAMLDocDiagnostic from the parser
+     * @param textDocument TextDocument from the language server client
+     */
+    const yamlDiagToLSDiag = (yamlDiag, textDocument) => {
+        const start = textDocument.positionAt(yamlDiag.location.start);
+        const range = {
+            start,
+            end: yamlDiag.location.toLineEnd
+                ? vscode_languageserver_types_1.Position.create(start.line, new textBuffer_1.TextBuffer(textDocument).getLineLength(start.line))
+                : textDocument.positionAt(yamlDiag.location.end),
+        };
+        return vscode_languageserver_types_1.Diagnostic.create(range, yamlDiag.message, yamlDiag.severity, yamlDiag.code, jsonParser07_1.YAML_SOURCE);
+    };
+    exports.yamlDiagToLSDiag = yamlDiagToLSDiag;
+    class YAMLValidation {
+        constructor(schemaService, telemetry) {
+            this.telemetry = telemetry;
+            this.validators = [];
+            this.MATCHES_MULTIPLE = 'Matches multiple schemas when only one must validate.';
+            this.validationEnabled = true;
+            this.jsonValidation = new jsonValidation_1.JSONValidation(schemaService, Promise);
+        }
+        configure(settings) {
+            this.validators = [];
+            if (settings) {
+                this.validationEnabled = settings.validate;
+                this.customTags = settings.customTags;
+                this.disableAdditionalProperties = settings.disableAdditionalProperties;
+                this.yamlVersion = settings.yamlVersion;
+                // Add style validator if flow style is set to forbid only.
+                if (settings.flowMapping === 'forbid' || settings.flowSequence === 'forbid') {
+                    this.validators.push(new yaml_style_1.YAMLStyleValidator(settings));
+                }
+                if (settings.keyOrdering) {
+                    this.validators.push(new map_key_order_1.MapKeyOrderValidator());
+                }
+            }
+            this.validators.push(new unused_anchors_1.UnusedAnchorsValidator());
+        }
+        async doValidation(textDocument, isKubernetes = false) {
+            if (!this.validationEnabled) {
+                return Promise.resolve([]);
+            }
+            const validationResult = [];
+            try {
+                const yamlDocument = yaml_documents_1.yamlDocumentsCache.getYamlDocument(textDocument, { customTags: this.customTags, yamlVersion: this.yamlVersion }, true);
+                let index = 0;
+                for (const currentYAMLDoc of yamlDocument.documents) {
+                    currentYAMLDoc.isKubernetes = isKubernetes;
+                    currentYAMLDoc.currentDocIndex = index;
+                    currentYAMLDoc.disableAdditionalProperties = this.disableAdditionalProperties;
+                    currentYAMLDoc.uri = textDocument.uri;
+                    const validation = await this.jsonValidation.doValidation(textDocument, currentYAMLDoc);
+                    const syd = currentYAMLDoc;
+                    if (syd.errors.length > 0) {
+                        // TODO: Get rid of these type assertions (shouldn't need them)
+                        validationResult.push(...syd.errors);
+                    }
+                    if (syd.warnings.length > 0) {
+                        validationResult.push(...syd.warnings);
+                    }
+                    validationResult.push(...validation);
+                    validationResult.push(...this.runAdditionalValidators(textDocument, currentYAMLDoc));
+                    index++;
+                }
+            }
+            catch (err) {
+                this.telemetry?.sendError('yaml.validation.error', { error: (0, objects_1.convertErrorToTelemetryMsg)(err) });
+            }
+            let previousErr;
+            const foundSignatures = new Set();
+            const duplicateMessagesRemoved = [];
+            for (let err of validationResult) {
+                /**
+                 * A patch ontop of the validation that removes the
+                 * 'Matches many schemas' error for kubernetes
+                 * for a better user experience.
+                 */
+                if (isKubernetes && err.message === this.MATCHES_MULTIPLE) {
+                    continue;
+                }
+                if (Object.prototype.hasOwnProperty.call(err, 'location')) {
+                    err = (0, exports.yamlDiagToLSDiag)(err, textDocument);
+                }
+                if (!err.source) {
+                    err.source = jsonParser07_1.YAML_SOURCE;
+                }
+                if (previousErr &&
+                    previousErr.message === err.message &&
+                    previousErr.range.end.line === err.range.start.line &&
+                    Math.abs(previousErr.range.end.character - err.range.end.character) >= 1) {
+                    previousErr.range.end = err.range.end;
+                    continue;
+                }
+                else {
+                    previousErr = err;
+                }
+                const errSig = err.range.start.line + ' ' + err.range.start.character + ' ' + err.message;
+                if (!foundSignatures.has(errSig)) {
+                    duplicateMessagesRemoved.push(err);
+                    foundSignatures.add(errSig);
+                }
+            }
+            return duplicateMessagesRemoved;
+        }
+        runAdditionalValidators(document, yarnDoc) {
+            const result = [];
+            for (const validator of this.validators) {
+                result.push(...validator.validate(document, yarnDoc));
+            }
+            return result;
+        }
+    }
+    exports.YAMLValidation = YAMLValidation;
+});
+//# sourceMappingURL=yamlValidation.js.map

node_modules/yaml-language-server/lib/umd/languageservice/services/yamlValidation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yamlValidation.js","sourceRoot":"","sources":["../../../../src/languageservice/services/yamlValidation.ts"],"names":[],"mappings":"AAAA;;;;gGAIgG;;;;;;;;;;;;;IAEhG,6EAAmE;IAMnE,gGAA6F;IAC7F,yDAAqD;IACrD,oDAAiD;IACjD,6DAA8D;IAC9D,8CAA8D;IAG9D,gEAAqE;IACrE,wDAA6D;IAC7D,8DAAkE;IAElE;;;;OAIG;IACI,MAAM,gBAAgB,GAAG,CAAC,QAA2B,EAAE,YAA0B,EAAc,EAAE;QACtG,MAAM,KAAK,GAAG,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC/D,MAAM,KAAK,GAAG;YACZ,KAAK;YACL,GAAG,EAAE,QAAQ,CAAC,QAAQ,CAAC,SAAS;gBAC9B,CAAC,CAAC,sCAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,uBAAU,CAAC,YAAY,CAAC,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBACrF,CAAC,CAAC,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC;SACnD,CAAC;QAEF,OAAO,wCAAU,CAAC,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,EAAE,0BAAW,CAAC,CAAC;IACnG,CAAC,CAAC;IAVW,QAAA,gBAAgB,oBAU3B;IAEF,MAAa,cAAc;QAUzB,YAAY,aAAgC,EAAmB,SAAqB;YAArB,cAAS,GAAT,SAAS,CAAY;YAJ5E,eAAU,GAA0B,EAAE,CAAC;YAEvC,qBAAgB,GAAG,uDAAuD,CAAC;YAGjF,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;YAC9B,IAAI,CAAC,cAAc,GAAG,IAAI,+BAAc,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;QACnE,CAAC;QAEM,SAAS,CAAC,QAA0B;YACzC,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;YACrB,IAAI,QAAQ,EAAE;gBACZ,IAAI,CAAC,iBAAiB,GAAG,QAAQ,CAAC,QAAQ,CAAC;gBAC3C,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC;gBACtC,IAAI,CAAC,2BAA2B,GAAG,QAAQ,CAAC,2BAA2B,CAAC;gBACxE,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,WAAW,CAAC;gBACxC,2DAA2D;gBAC3D,IAAI,QAAQ,CAAC,WAAW,KAAK,QAAQ,IAAI,QAAQ,CAAC,YAAY,KAAK,QAAQ,EAAE;oBAC3E,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,+BAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC;iBACxD;gBACD,IAAI,QAAQ,CAAC,WAAW,EAAE;oBACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,oCAAoB,EAAE,CAAC,CAAC;iBAClD;aACF;YACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,uCAAsB,EAAE,CAAC,CAAC;QACrD,CAAC;QAEM,KAAK,CAAC,YAAY,CAAC,YAA0B,EAAE,YAAY,GAAG,KAAK;YACxE,IAAI,CAAC,IAAI,CAAC,iBAAiB,EAAE;gBAC3B,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;aAC5B;YAED,MAAM,gBAAgB,GAAG,EAAE,CAAC;YAC5B,IAAI;gBACF,MAAM,YAAY,GAAiB,mCAAkB,CAAC,eAAe,CACnE,YAAY,EACZ,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,EAAE,EAC9D,IAAI,CACL,CAAC;gBAEF,IAAI,KAAK,GAAG,CAAC,CAAC;gBACd,KAAK,MAAM,cAAc,IAAI,YAAY,CAAC,SAAS,EAAE;oBACnD,cAAc,CAAC,YAAY,GAAG,YAAY,CAAC;oBAC3C,cAAc,CAAC,eAAe,GAAG,KAAK,CAAC;oBACvC,cAAc,CAAC,2BAA2B,GAAG,IAAI,CAAC,2BAA2B,CAAC;oBAC9E,cAAc,CAAC,GAAG,GAAG,YAAY,CAAC,GAAG,CAAC;oBAEtC,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;oBAExF,MAAM,GAAG,GAAG,cAA+C,CAAC;oBAC5D,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;wBACzB,+DAA+D;wBAC/D,gBAAgB,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC;qBACtC;oBACD,IAAI,GAAG,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;wBAC3B,gBAAgB,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC;qBACxC;oBAED,gBAAgB,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,CAAC;oBACrC,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,uBAAuB,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC,CAAC;oBACrF,KAAK,EAAE,CAAC;iBACT;aACF;YAAC,OAAO,GAAG,EAAE;gBACZ,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,uBAAuB,EAAE,EAAE,KAAK,EAAE,IAAA,oCAA0B,EAAC,GAAG,CAAC,EAAE,CAAC,CAAC;aAChG;YAED,IAAI,WAAuB,CAAC;YAC5B,MAAM,eAAe,GAAG,IAAI,GAAG,EAAE,CAAC;YAClC,MAAM,wBAAwB,GAAiB,EAAE,CAAC;YAClD,KAAK,IAAI,GAAG,IAAI,gBAAgB,EAAE;gBAChC;;;;mBAIG;gBACH,IAAI,YAAY,IAAI,GAAG,CAAC,OAAO,KAAK,IAAI,CAAC,gBAAgB,EAAE;oBACzD,SAAS;iBACV;gBAED,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE;oBACzD,GAAG,GAAG,IAAA,wBAAgB,EAAC,GAAG,EAAE,YAAY,CAAC,CAAC;iBAC3C;gBAED,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE;oBACf,GAAG,CAAC,MAAM,GAAG,0BAAW,CAAC;iBAC1B;gBAED,IACE,WAAW;oBACX,WAAW,CAAC,OAAO,KAAK,GAAG,CAAC,OAAO;oBACnC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,KAAK,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI;oBACnD,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,EACxE;oBACA,WAAW,CAAC,KAAK,CAAC,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC;oBACtC,SAAS;iBACV;qBAAM;oBACL,WAAW,GAAG,GAAG,CAAC;iBACnB;gBAED,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,GAAG,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,GAAG,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC;gBAC1F,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;oBAChC,wBAAwB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;oBACnC,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;iBAC7B;aACF;YAED,OAAO,wBAAwB,CAAC;QAClC,CAAC;QACO,uBAAuB,CAAC,QAAsB,EAAE,OAA2B;YACjF,MAAM,MAAM,GAAG,EAAE,CAAC;YAElB,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE;gBACvC,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;aACvD;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;KACF;IA1HD,wCA0HC"}

node_modules/yaml-language-server/lib/umd/languageservice/telemetry.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Due to LSP limitation this object must be JSON serializable
+ */
+export interface TelemetryEvent {
+    name: string;
+    type?: string;
+    properties?: unknown;
+    measures?: unknown;
+    traits?: unknown;
+    context?: unknown;
+}
+export interface Telemetry {
+    send(event: TelemetryEvent): void;
+    sendError(name: string, properties: unknown): void;
+    sendTrack(name: string, properties: unknown): void;
+}

node_modules/yaml-language-server/lib/umd/languageservice/telemetry.js

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=telemetry.js.map

node_modules/yaml-language-server/lib/umd/languageservice/telemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.js","sourceRoot":"","sources":["../../../src/languageservice/telemetry.ts"],"names":[],"mappings":"AAAA;;;gGAGgG"}

node_modules/yaml-language-server/lib/umd/languageservice/utils/arrUtils.d.ts

@@ -0,0 +1,6 @@
+import { YAMLDocument, SingleYAMLDocument } from '../parser/yamlParser07';
+export declare function getLineOffsets(textDocString: string): number[];
+export declare function removeDuplicatesObj<T>(objArray: T[]): T[];
+export declare function matchOffsetToDocument(offset: number, jsonDocuments: YAMLDocument): SingleYAMLDocument | null;
+export declare function filterInvalidCustomTags(customTags: string[]): string[];
+export declare function isArrayEqual(fst: Array<unknown>, snd: Array<unknown>): boolean;

node_modules/yaml-language-server/lib/umd/languageservice/utils/arrUtils.js

@@ -0,0 +1,99 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isArrayEqual = exports.filterInvalidCustomTags = exports.matchOffsetToDocument = exports.removeDuplicatesObj = exports.getLineOffsets = void 0;
+    function getLineOffsets(textDocString) {
+        const lineOffsets = [];
+        const text = textDocString;
+        let isLineStart = true;
+        for (let i = 0; i < text.length; i++) {
+            if (isLineStart) {
+                lineOffsets.push(i);
+                isLineStart = false;
+            }
+            const ch = text.charAt(i);
+            isLineStart = ch === '\r' || ch === '\n';
+            if (ch === '\r' && i + 1 < text.length && text.charAt(i + 1) === '\n') {
+                i++;
+            }
+        }
+        if (isLineStart && text.length > 0) {
+            lineOffsets.push(text.length);
+        }
+        return lineOffsets;
+    }
+    exports.getLineOffsets = getLineOffsets;
+    function removeDuplicatesObj(objArray) {
+        const nonDuplicateSet = new Set();
+        const nonDuplicateArr = [];
+        for (const obj in objArray) {
+            const currObj = objArray[obj];
+            const stringifiedObj = JSON.stringify(currObj);
+            if (!nonDuplicateSet.has(stringifiedObj)) {
+                nonDuplicateArr.push(currObj);
+                nonDuplicateSet.add(stringifiedObj);
+            }
+        }
+        return nonDuplicateArr;
+    }
+    exports.removeDuplicatesObj = removeDuplicatesObj;
+    function matchOffsetToDocument(offset, jsonDocuments) {
+        for (const jsonDoc of jsonDocuments.documents) {
+            if (jsonDoc.internalDocument && jsonDoc.internalDocument.range[0] <= offset && jsonDoc.internalDocument.range[2] >= offset) {
+                return jsonDoc;
+            }
+        }
+        if (jsonDocuments.documents.length === 1) {
+            return jsonDocuments.documents[0];
+        }
+        return null;
+    }
+    exports.matchOffsetToDocument = matchOffsetToDocument;
+    function filterInvalidCustomTags(customTags) {
+        const validCustomTags = ['mapping', 'scalar', 'sequence'];
+        if (!customTags) {
+            return [];
+        }
+        return customTags.filter((tag) => {
+            if (typeof tag === 'string') {
+                const typeInfo = tag.split(' ');
+                const type = (typeInfo[1] && typeInfo[1].toLowerCase()) || 'scalar';
+                // We need to check if map is a type because map will throw an error within the yaml-ast-parser
+                if (type === 'map') {
+                    return false;
+                }
+                return validCustomTags.indexOf(type) !== -1;
+            }
+            return false;
+        });
+    }
+    exports.filterInvalidCustomTags = filterInvalidCustomTags;
+    function isArrayEqual(fst, snd) {
+        if (!snd || !fst) {
+            return false;
+        }
+        if (snd.length !== fst.length) {
+            return false;
+        }
+        for (let index = fst.length - 1; index >= 0; index--) {
+            if (fst[index] !== snd[index]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    exports.isArrayEqual = isArrayEqual;
+});
+//# sourceMappingURL=arrUtils.js.map

node_modules/yaml-language-server/lib/umd/languageservice/utils/arrUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrUtils.js","sourceRoot":"","sources":["../../../../src/languageservice/utils/arrUtils.ts"],"names":[],"mappings":"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"}

node_modules/yaml-language-server/lib/umd/languageservice/utils/astUtils.d.ts

@@ -0,0 +1,13 @@
+import { Document, YAMLMap, YAMLSeq } from 'yaml';
+import { CollectionItem, Token } from 'yaml/dist/parse/cst';
+import { YamlNode } from '../jsonASTTypes';
+export declare function getParent(doc: Document, nodeToFind: YamlNode): YamlNode | undefined;
+export declare function isMapContainsEmptyPair(map: YAMLMap): boolean;
+export declare function indexOf(seq: YAMLSeq, item: YamlNode): number | undefined;
+/**
+ * Check that given offset is in YAML comment
+ * @param doc the yaml document
+ * @param offset the offset to check
+ */
+export declare function isInComment(tokens: Token[], offset: number): boolean;
+export declare function isCollectionItem(token: unknown): token is CollectionItem;

node_modules/yaml-language-server/lib/umd/languageservice/utils/astUtils.js

@@ -0,0 +1,126 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Red Hat, Inc. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "yaml"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isCollectionItem = exports.isInComment = exports.indexOf = exports.isMapContainsEmptyPair = exports.getParent = void 0;
+    const yaml_1 = require("yaml");
+    function getParent(doc, nodeToFind) {
+        let parentNode;
+        (0, yaml_1.visit)(doc, (_, node, path) => {
+            if (node === nodeToFind) {
+                parentNode = path[path.length - 1];
+                return yaml_1.visit.BREAK;
+            }
+        });
+        if ((0, yaml_1.isDocument)(parentNode)) {
+            return undefined;
+        }
+        return parentNode;
+    }
+    exports.getParent = getParent;
+    function isMapContainsEmptyPair(map) {
+        if (map.items.length > 1) {
+            return false;
+        }
+        const pair = map.items[0];
+        return (0, yaml_1.isScalar)(pair.key) && (0, yaml_1.isScalar)(pair.value) && pair.key.value === '' && !pair.value.value;
+    }
+    exports.isMapContainsEmptyPair = isMapContainsEmptyPair;
+    function indexOf(seq, item) {
+        for (const [i, obj] of seq.items.entries()) {
+            if (item === obj) {
+                return i;
+            }
+        }
+        return undefined;
+    }
+    exports.indexOf = indexOf;
+    /**
+     * Check that given offset is in YAML comment
+     * @param doc the yaml document
+     * @param offset the offset to check
+     */
+    function isInComment(tokens, offset) {
+        let inComment = false;
+        for (const token of tokens) {
+            if (token.type === 'document') {
+                _visit([], token, (item) => {
+                    if (isCollectionItem(item) && item.value?.type === 'comment') {
+                        if (token.offset <= offset && item.value.source.length + item.value.offset >= offset) {
+                            inComment = true;
+                            return yaml_1.visit.BREAK;
+                        }
+                    }
+                    else if (item.type === 'comment' && item.offset <= offset && item.offset + item.source.length >= offset) {
+                        inComment = true;
+                        return yaml_1.visit.BREAK;
+                    }
+                });
+            }
+            else if (token.type === 'comment') {
+                if (token.offset <= offset && token.source.length + token.offset >= offset) {
+                    return true;
+                }
+            }
+            if (inComment) {
+                break;
+            }
+        }
+        return inComment;
+    }
+    exports.isInComment = isInComment;
+    function isCollectionItem(token) {
+        return token['start'] !== undefined;
+    }
+    exports.isCollectionItem = isCollectionItem;
+    function _visit(path, item, visitor) {
+        let ctrl = visitor(item, path);
+        if (typeof ctrl === 'symbol')
+            return ctrl;
+        for (const field of ['key', 'value']) {
+            const token = item[field];
+            if (token && 'items' in token) {
+                for (let i = 0; i < token.items.length; ++i) {
+                    const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+                    if (typeof ci === 'number')
+                        i = ci - 1;
+                    else if (ci === yaml_1.visit.BREAK)
+                        return yaml_1.visit.BREAK;
+                    else if (ci === yaml_1.visit.REMOVE) {
+                        token.items.splice(i, 1);
+                        i -= 1;
+                    }
+                }
+                if (typeof ctrl === 'function' && field === 'key')
+                    ctrl = ctrl(item, path);
+            }
+        }
+        const token = item['sep'];
+        if (token) {
+            for (let i = 0; i < token.length; ++i) {
+                const ci = _visit(Object.freeze(path), token[i], visitor);
+                if (typeof ci === 'number')
+                    i = ci - 1;
+                else if (ci === yaml_1.visit.BREAK)
+                    return yaml_1.visit.BREAK;
+                else if (ci === yaml_1.visit.REMOVE) {
+                    token.items.splice(i, 1);
+                    i -= 1;
+                }
+            }
+        }
+        return typeof ctrl === 'function' ? ctrl(item, path) : ctrl;
+    }
+});
+//# sourceMappingURL=astUtils.js.map

node_modules/yaml-language-server/lib/umd/languageservice/utils/astUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"astUtils.js","sourceRoot":"","sources":["../../../../src/languageservice/utils/astUtils.ts"],"names":[],"mappings":"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"}

node_modules/yaml-language-server/lib/umd/languageservice/utils/charCode.d.ts

@@ -0,0 +1,415 @@
+/**
+ * An inlined enum containing useful character codes (to be used with String.charCodeAt).
+ * Please leave the const keyword such that it gets inlined when compiled to JavaScript!
+ */
+export declare const enum CharCode {
+    Null = 0,
+    /**
+     * The `\b` character.
+     */
+    Backspace = 8,
+    /**
+     * The `\t` character.
+     */
+    Tab = 9,
+    /**
+     * The `\n` character.
+     */
+    LineFeed = 10,
+    /**
+     * The `\r` character.
+     */
+    CarriageReturn = 13,
+    Space = 32,
+    /**
+     * The `!` character.
+     */
+    ExclamationMark = 33,
+    /**
+     * The `"` character.
+     */
+    DoubleQuote = 34,
+    /**
+     * The `#` character.
+     */
+    Hash = 35,
+    /**
+     * The `$` character.
+     */
+    DollarSign = 36,
+    /**
+     * The `%` character.
+     */
+    PercentSign = 37,
+    /**
+     * The `&` character.
+     */
+    Ampersand = 38,
+    /**
+     * The `'` character.
+     */
+    SingleQuote = 39,
+    /**
+     * The `(` character.
+     */
+    OpenParen = 40,
+    /**
+     * The `)` character.
+     */
+    CloseParen = 41,
+    /**
+     * The `*` character.
+     */
+    Asterisk = 42,
+    /**
+     * The `+` character.
+     */
+    Plus = 43,
+    /**
+     * The `,` character.
+     */
+    Comma = 44,
+    /**
+     * The `-` character.
+     */
+    Dash = 45,
+    /**
+     * The `.` character.
+     */
+    Period = 46,
+    /**
+     * The `/` character.
+     */
+    Slash = 47,
+    Digit0 = 48,
+    Digit1 = 49,
+    Digit2 = 50,
+    Digit3 = 51,
+    Digit4 = 52,
+    Digit5 = 53,
+    Digit6 = 54,
+    Digit7 = 55,
+    Digit8 = 56,
+    Digit9 = 57,
+    /**
+     * The `:` character.
+     */
+    Colon = 58,
+    /**
+     * The `;` character.
+     */
+    Semicolon = 59,
+    /**
+     * The `<` character.
+     */
+    LessThan = 60,
+    /**
+     * The `=` character.
+     */
+    Equals = 61,
+    /**
+     * The `>` character.
+     */
+    GreaterThan = 62,
+    /**
+     * The `?` character.
+     */
+    QuestionMark = 63,
+    /**
+     * The `@` character.
+     */
+    AtSign = 64,
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    E = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    /**
+     * The `[` character.
+     */
+    OpenSquareBracket = 91,
+    /**
+     * The `\` character.
+     */
+    Backslash = 92,
+    /**
+     * The `]` character.
+     */
+    CloseSquareBracket = 93,
+    /**
+     * The `^` character.
+     */
+    Caret = 94,
+    /**
+     * The `_` character.
+     */
+    Underline = 95,
+    /**
+     * The ``(`)`` character.
+     */
+    BackTick = 96,
+    a = 97,
+    b = 98,
+    c = 99,
+    d = 100,
+    e = 101,
+    f = 102,
+    g = 103,
+    h = 104,
+    i = 105,
+    j = 106,
+    k = 107,
+    l = 108,
+    m = 109,
+    n = 110,
+    o = 111,
+    p = 112,
+    q = 113,
+    r = 114,
+    s = 115,
+    t = 116,
+    u = 117,
+    v = 118,
+    w = 119,
+    x = 120,
+    y = 121,
+    z = 122,
+    /**
+     * The `{` character.
+     */
+    OpenCurlyBrace = 123,
+    /**
+     * The `|` character.
+     */
+    Pipe = 124,
+    /**
+     * The `}` character.
+     */
+    CloseCurlyBrace = 125,
+    /**
+     * The `~` character.
+     */
+    Tilde = 126,
+    U_Combining_Grave_Accent = 768,
+    U_Combining_Acute_Accent = 769,
+    U_Combining_Circumflex_Accent = 770,
+    U_Combining_Tilde = 771,
+    U_Combining_Macron = 772,
+    U_Combining_Overline = 773,
+    U_Combining_Breve = 774,
+    U_Combining_Dot_Above = 775,
+    U_Combining_Diaeresis = 776,
+    U_Combining_Hook_Above = 777,
+    U_Combining_Ring_Above = 778,
+    U_Combining_Double_Acute_Accent = 779,
+    U_Combining_Caron = 780,
+    U_Combining_Vertical_Line_Above = 781,
+    U_Combining_Double_Vertical_Line_Above = 782,
+    U_Combining_Double_Grave_Accent = 783,
+    U_Combining_Candrabindu = 784,
+    U_Combining_Inverted_Breve = 785,
+    U_Combining_Turned_Comma_Above = 786,
+    U_Combining_Comma_Above = 787,
+    U_Combining_Reversed_Comma_Above = 788,
+    U_Combining_Comma_Above_Right = 789,
+    U_Combining_Grave_Accent_Below = 790,
+    U_Combining_Acute_Accent_Below = 791,
+    U_Combining_Left_Tack_Below = 792,
+    U_Combining_Right_Tack_Below = 793,
+    U_Combining_Left_Angle_Above = 794,
+    U_Combining_Horn = 795,
+    U_Combining_Left_Half_Ring_Below = 796,
+    U_Combining_Up_Tack_Below = 797,
+    U_Combining_Down_Tack_Below = 798,
+    U_Combining_Plus_Sign_Below = 799,
+    U_Combining_Minus_Sign_Below = 800,
+    U_Combining_Palatalized_Hook_Below = 801,
+    U_Combining_Retroflex_Hook_Below = 802,
+    U_Combining_Dot_Below = 803,
+    U_Combining_Diaeresis_Below = 804,
+    U_Combining_Ring_Below = 805,
+    U_Combining_Comma_Below = 806,
+    U_Combining_Cedilla = 807,
+    U_Combining_Ogonek = 808,
+    U_Combining_Vertical_Line_Below = 809,
+    U_Combining_Bridge_Below = 810,
+    U_Combining_Inverted_Double_Arch_Below = 811,
+    U_Combining_Caron_Below = 812,
+    U_Combining_Circumflex_Accent_Below = 813,
+    U_Combining_Breve_Below = 814,
+    U_Combining_Inverted_Breve_Below = 815,
+    U_Combining_Tilde_Below = 816,
+    U_Combining_Macron_Below = 817,
+    U_Combining_Low_Line = 818,
+    U_Combining_Double_Low_Line = 819,
+    U_Combining_Tilde_Overlay = 820,
+    U_Combining_Short_Stroke_Overlay = 821,
+    U_Combining_Long_Stroke_Overlay = 822,
+    U_Combining_Short_Solidus_Overlay = 823,
+    U_Combining_Long_Solidus_Overlay = 824,
+    U_Combining_Right_Half_Ring_Below = 825,
+    U_Combining_Inverted_Bridge_Below = 826,
+    U_Combining_Square_Below = 827,
+    U_Combining_Seagull_Below = 828,
+    U_Combining_X_Above = 829,
+    U_Combining_Vertical_Tilde = 830,
+    U_Combining_Double_Overline = 831,
+    U_Combining_Grave_Tone_Mark = 832,
+    U_Combining_Acute_Tone_Mark = 833,
+    U_Combining_Greek_Perispomeni = 834,
+    U_Combining_Greek_Koronis = 835,
+    U_Combining_Greek_Dialytika_Tonos = 836,
+    U_Combining_Greek_Ypogegrammeni = 837,
+    U_Combining_Bridge_Above = 838,
+    U_Combining_Equals_Sign_Below = 839,
+    U_Combining_Double_Vertical_Line_Below = 840,
+    U_Combining_Left_Angle_Below = 841,
+    U_Combining_Not_Tilde_Above = 842,
+    U_Combining_Homothetic_Above = 843,
+    U_Combining_Almost_Equal_To_Above = 844,
+    U_Combining_Left_Right_Arrow_Below = 845,
+    U_Combining_Upwards_Arrow_Below = 846,
+    U_Combining_Grapheme_Joiner = 847,
+    U_Combining_Right_Arrowhead_Above = 848,
+    U_Combining_Left_Half_Ring_Above = 849,
+    U_Combining_Fermata = 850,
+    U_Combining_X_Below = 851,
+    U_Combining_Left_Arrowhead_Below = 852,
+    U_Combining_Right_Arrowhead_Below = 853,
+    U_Combining_Right_Arrowhead_And_Up_Arrowhead_Below = 854,
+    U_Combining_Right_Half_Ring_Above = 855,
+    U_Combining_Dot_Above_Right = 856,
+    U_Combining_Asterisk_Below = 857,
+    U_Combining_Double_Ring_Below = 858,
+    U_Combining_Zigzag_Above = 859,
+    U_Combining_Double_Breve_Below = 860,
+    U_Combining_Double_Breve = 861,
+    U_Combining_Double_Macron = 862,
+    U_Combining_Double_Macron_Below = 863,
+    U_Combining_Double_Tilde = 864,
+    U_Combining_Double_Inverted_Breve = 865,
+    U_Combining_Double_Rightwards_Arrow_Below = 866,
+    U_Combining_Latin_Small_Letter_A = 867,
+    U_Combining_Latin_Small_Letter_E = 868,
+    U_Combining_Latin_Small_Letter_I = 869,
+    U_Combining_Latin_Small_Letter_O = 870,
+    U_Combining_Latin_Small_Letter_U = 871,
+    U_Combining_Latin_Small_Letter_C = 872,
+    U_Combining_Latin_Small_Letter_D = 873,
+    U_Combining_Latin_Small_Letter_H = 874,
+    U_Combining_Latin_Small_Letter_M = 875,
+    U_Combining_Latin_Small_Letter_R = 876,
+    U_Combining_Latin_Small_Letter_T = 877,
+    U_Combining_Latin_Small_Letter_V = 878,
+    U_Combining_Latin_Small_Letter_X = 879,
+    /**
+     * Unicode Character 'LINE SEPARATOR' (U+2028)
+     * http://www.fileformat.info/info/unicode/char/2028/index.htm
+     */
+    LINE_SEPARATOR = 8232,
+    /**
+     * Unicode Character 'PARAGRAPH SEPARATOR' (U+2029)
+     * http://www.fileformat.info/info/unicode/char/2029/index.htm
+     */
+    PARAGRAPH_SEPARATOR = 8233,
+    /**
+     * Unicode Character 'NEXT LINE' (U+0085)
+     * http://www.fileformat.info/info/unicode/char/0085/index.htm
+     */
+    NEXT_LINE = 133,
+    U_CIRCUMFLEX = 94,
+    U_GRAVE_ACCENT = 96,
+    U_DIAERESIS = 168,
+    U_MACRON = 175,
+    U_ACUTE_ACCENT = 180,
+    U_CEDILLA = 184,
+    U_MODIFIER_LETTER_LEFT_ARROWHEAD = 706,
+    U_MODIFIER_LETTER_RIGHT_ARROWHEAD = 707,
+    U_MODIFIER_LETTER_UP_ARROWHEAD = 708,
+    U_MODIFIER_LETTER_DOWN_ARROWHEAD = 709,
+    U_MODIFIER_LETTER_CENTRED_RIGHT_HALF_RING = 722,
+    U_MODIFIER_LETTER_CENTRED_LEFT_HALF_RING = 723,
+    U_MODIFIER_LETTER_UP_TACK = 724,
+    U_MODIFIER_LETTER_DOWN_TACK = 725,
+    U_MODIFIER_LETTER_PLUS_SIGN = 726,
+    U_MODIFIER_LETTER_MINUS_SIGN = 727,
+    U_BREVE = 728,
+    U_DOT_ABOVE = 729,
+    U_RING_ABOVE = 730,
+    U_OGONEK = 731,
+    U_SMALL_TILDE = 732,
+    U_DOUBLE_ACUTE_ACCENT = 733,
+    U_MODIFIER_LETTER_RHOTIC_HOOK = 734,
+    U_MODIFIER_LETTER_CROSS_ACCENT = 735,
+    U_MODIFIER_LETTER_EXTRA_HIGH_TONE_BAR = 741,
+    U_MODIFIER_LETTER_HIGH_TONE_BAR = 742,
+    U_MODIFIER_LETTER_MID_TONE_BAR = 743,
+    U_MODIFIER_LETTER_LOW_TONE_BAR = 744,
+    U_MODIFIER_LETTER_EXTRA_LOW_TONE_BAR = 745,
+    U_MODIFIER_LETTER_YIN_DEPARTING_TONE_MARK = 746,
+    U_MODIFIER_LETTER_YANG_DEPARTING_TONE_MARK = 747,
+    U_MODIFIER_LETTER_UNASPIRATED = 749,
+    U_MODIFIER_LETTER_LOW_DOWN_ARROWHEAD = 751,
+    U_MODIFIER_LETTER_LOW_UP_ARROWHEAD = 752,
+    U_MODIFIER_LETTER_LOW_LEFT_ARROWHEAD = 753,
+    U_MODIFIER_LETTER_LOW_RIGHT_ARROWHEAD = 754,
+    U_MODIFIER_LETTER_LOW_RING = 755,
+    U_MODIFIER_LETTER_MIDDLE_GRAVE_ACCENT = 756,
+    U_MODIFIER_LETTER_MIDDLE_DOUBLE_GRAVE_ACCENT = 757,
+    U_MODIFIER_LETTER_MIDDLE_DOUBLE_ACUTE_ACCENT = 758,
+    U_MODIFIER_LETTER_LOW_TILDE = 759,
+    U_MODIFIER_LETTER_RAISED_COLON = 760,
+    U_MODIFIER_LETTER_BEGIN_HIGH_TONE = 761,
+    U_MODIFIER_LETTER_END_HIGH_TONE = 762,
+    U_MODIFIER_LETTER_BEGIN_LOW_TONE = 763,
+    U_MODIFIER_LETTER_END_LOW_TONE = 764,
+    U_MODIFIER_LETTER_SHELF = 765,
+    U_MODIFIER_LETTER_OPEN_SHELF = 766,
+    U_MODIFIER_LETTER_LOW_LEFT_ARROW = 767,
+    U_GREEK_LOWER_NUMERAL_SIGN = 885,
+    U_GREEK_TONOS = 900,
+    U_GREEK_DIALYTIKA_TONOS = 901,
+    U_GREEK_KORONIS = 8125,
+    U_GREEK_PSILI = 8127,
+    U_GREEK_PERISPOMENI = 8128,
+    U_GREEK_DIALYTIKA_AND_PERISPOMENI = 8129,
+    U_GREEK_PSILI_AND_VARIA = 8141,
+    U_GREEK_PSILI_AND_OXIA = 8142,
+    U_GREEK_PSILI_AND_PERISPOMENI = 8143,
+    U_GREEK_DASIA_AND_VARIA = 8157,
+    U_GREEK_DASIA_AND_OXIA = 8158,
+    U_GREEK_DASIA_AND_PERISPOMENI = 8159,
+    U_GREEK_DIALYTIKA_AND_VARIA = 8173,
+    U_GREEK_DIALYTIKA_AND_OXIA = 8174,
+    U_GREEK_VARIA = 8175,
+    U_GREEK_OXIA = 8189,
+    U_GREEK_DASIA = 8190,
+    U_OVERLINE = 8254,
+    /**
+     * UTF-8 BOM
+     * Unicode Character 'ZERO WIDTH NO-BREAK SPACE' (U+FEFF)
+     * http://www.fileformat.info/info/unicode/char/feff/index.htm
+     */
+    UTF8_BOM = 65279
+}

node_modules/yaml-language-server/lib/umd/languageservice/utils/charCode.js

@@ -0,0 +1,17 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+});
+//# sourceMappingURL=charCode.js.map

node_modules/yaml-language-server/lib/umd/languageservice/utils/charCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"charCode.js","sourceRoot":"","sources":["../../../../src/languageservice/utils/charCode.ts"],"names":[],"mappings":"AAAA;;;gGAGgG"}

node_modules/yaml-language-server/lib/umd/languageservice/utils/documentPositionCalculator.d.ts

@@ -0,0 +1,5 @@
+import { Position } from 'vscode-languageserver-types';
+export declare function insertionPointReturnValue(pt: number): number;
+export declare function binarySearch(array: number[], sought: number): number;
+export declare function getLineStartPositions(text: string): number[];
+export declare function getPosition(pos: number, lineStartPositions: number[]): Position;