Complete residential site build with Docker Compose & Gitea Actions deployment

node_modules/yaml-language-server/lib/umd/commands.d.ts

@@ -0,0 +1,3 @@
+export declare enum YamlCommands {
+    JUMP_TO_SCHEMA = "jumpToSchema"
+}

node_modules/yaml-language-server/lib/umd/commands.js

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  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.YamlCommands = void 0;
+    var YamlCommands;
+    (function (YamlCommands) {
+        YamlCommands["JUMP_TO_SCHEMA"] = "jumpToSchema";
+    })(YamlCommands = exports.YamlCommands || (exports.YamlCommands = {}));
+});
+//# sourceMappingURL=commands.js.map

node_modules/yaml-language-server/lib/umd/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.js","sourceRoot":"","sources":["../../src/commands.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAEhG,IAAY,YAEX;IAFD,WAAY,YAAY;QACtB,+CAA+B,CAAA;IACjC,CAAC,EAFW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAEvB"}

node_modules/yaml-language-server/lib/umd/index.d.ts

@@ -0,0 +1,3 @@
+export * from './languageservice/yamlLanguageService';
+export { getLanguageService as getJSONLanguageService } from 'vscode-json-languageservice';
+export * from 'vscode-languageserver-types';

node_modules/yaml-language-server/lib/umd/index.js

@@ -0,0 +1,32 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(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", "./languageservice/yamlLanguageService", "vscode-json-languageservice", "vscode-languageserver-types"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getJSONLanguageService = void 0;
+    __exportStar(require("./languageservice/yamlLanguageService"), exports);
+    var vscode_json_languageservice_1 = require("vscode-json-languageservice");
+    Object.defineProperty(exports, "getJSONLanguageService", { enumerable: true, get: function () { return vscode_json_languageservice_1.getLanguageService; } });
+    __exportStar(require("vscode-languageserver-types"), exports);
+});
+//# sourceMappingURL=index.js.map

node_modules/yaml-language-server/lib/umd/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;IAAA,wEAAsD;IACtD,2EAA2F;IAAlF,qIAAA,kBAAkB,OAA0B;IACrD,8DAA4C"}

node_modules/yaml-language-server/lib/umd/languageserver/commandExecutor.d.ts

@@ -0,0 +1,10 @@
+import { ExecuteCommandParams } from 'vscode-languageserver-protocol';
+export interface CommandHandler {
+    (...args: unknown[]): void;
+}
+export declare class CommandExecutor {
+    private commands;
+    executeCommand(params: ExecuteCommandParams): void;
+    registerCommand(commandId: string, handler: CommandHandler): void;
+}
+export declare const commandExecutor: CommandExecutor;

node_modules/yaml-language-server/lib/umd/languageserver/commandExecutor.js

@@ -0,0 +1,35 @@
+/*---------------------------------------------------------------------------------------------
+ *  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.commandExecutor = exports.CommandExecutor = void 0;
+    class CommandExecutor {
+        constructor() {
+            this.commands = new Map();
+        }
+        executeCommand(params) {
+            if (this.commands.has(params.command)) {
+                const handler = this.commands.get(params.command);
+                return handler(...params.arguments);
+            }
+            throw new Error(`Command '${params.command}' not found`);
+        }
+        registerCommand(commandId, handler) {
+            this.commands.set(commandId, handler);
+        }
+    }
+    exports.CommandExecutor = CommandExecutor;
+    exports.commandExecutor = new CommandExecutor();
+});
+//# sourceMappingURL=commandExecutor.js.map

node_modules/yaml-language-server/lib/umd/languageserver/commandExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandExecutor.js","sourceRoot":"","sources":["../../../src/languageserver/commandExecutor.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAQhG,MAAa,eAAe;QAA5B;YACU,aAAQ,GAAG,IAAI,GAAG,EAA0B,CAAC;QAYvD,CAAC;QAXC,cAAc,CAAC,MAA4B;YACzC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE;gBACrC,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;gBAClD,OAAO,OAAO,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;aACrC;YACD,MAAM,IAAI,KAAK,CAAC,YAAY,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC;QAC3D,CAAC;QAED,eAAe,CAAC,SAAiB,EAAE,OAAuB;YACxD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACxC,CAAC;KACF;IAbD,0CAaC;IAEY,QAAA,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC"}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/languageHandlers.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+import { Connection } from 'vscode-languageserver';
+import { CodeActionParams, DidChangeWatchedFilesParams, DocumentFormattingParams, DocumentLinkParams, DocumentOnTypeFormattingParams, DocumentSymbolParams, FoldingRangeParams, SelectionRangeParams, TextDocumentPositionParams, CodeLensParams, DefinitionParams, PrepareRenameParams, RenameParams } from 'vscode-languageserver-protocol';
+import { CodeAction, CodeLens, CompletionList, DefinitionLink, DocumentLink, DocumentSymbol, Hover, FoldingRange, Range, SelectionRange, SymbolInformation, TextEdit, WorkspaceEdit } from 'vscode-languageserver-types';
+import { LanguageService } from '../../languageservice/yamlLanguageService';
+import { SettingsState } from '../../yamlSettings';
+import { ValidationHandler } from './validationHandlers';
+export declare class LanguageHandlers {
+    private readonly connection;
+    private languageService;
+    private yamlSettings;
+    private validationHandler;
+    pendingLimitExceededWarnings: {
+        [uri: string]: {
+            features: {
+                [name: string]: string;
+            };
+            timeout?: NodeJS.Timeout;
+        };
+    };
+    constructor(connection: Connection, languageService: LanguageService, yamlSettings: SettingsState, validationHandler: ValidationHandler);
+    registerHandlers(): void;
+    documentLinkHandler(params: DocumentLinkParams): Promise<DocumentLink[]>;
+    /**
+     * Called when the code outline in an editor needs to be populated
+     * Returns a list of symbols that is then shown in the code outline
+     */
+    documentSymbolHandler(documentSymbolParams: DocumentSymbolParams): DocumentSymbol[] | SymbolInformation[];
+    /**
+     * Called when the formatter is invoked
+     * Returns the formatted document content using prettier
+     */
+    formatterHandler(formatParams: DocumentFormattingParams): Promise<TextEdit[]>;
+    formatOnTypeHandler(params: DocumentOnTypeFormattingParams): Promise<TextEdit[] | undefined> | TextEdit[] | undefined;
+    /**
+     * Called when the user hovers with their mouse over a keyword
+     * Returns an informational tooltip
+     */
+    hoverHandler(textDocumentPositionParams: TextDocumentPositionParams): Promise<Hover>;
+    /**
+     * Called when auto-complete is triggered in an editor
+     * Returns a list of valid completion items
+     */
+    completionHandler(textDocumentPosition: TextDocumentPositionParams): Promise<CompletionList>;
+    /**
+     * Called when a monitored file is changed in an editor
+     * Re-validates the entire document
+     */
+    watchedFilesHandler(change: DidChangeWatchedFilesParams): void;
+    foldingRangeHandler(params: FoldingRangeParams): Promise<FoldingRange[] | undefined> | FoldingRange[] | undefined;
+    selectionRangeHandler(params: SelectionRangeParams): SelectionRange[] | undefined;
+    codeActionHandler(params: CodeActionParams): CodeAction[] | undefined;
+    codeLensHandler(params: CodeLensParams): PromiseLike<CodeLens[] | undefined> | CodeLens[] | undefined;
+    codeLensResolveHandler(param: CodeLens): PromiseLike<CodeLens> | CodeLens;
+    definitionHandler(params: DefinitionParams): DefinitionLink[];
+    prepareRenameHandler(params: PrepareRenameParams): Range | null;
+    renameHandler(params: RenameParams): WorkspaceEdit | null;
+    private cancelLimitExceededWarnings;
+    private onResultLimitExceeded;
+}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/languageHandlers.js

@@ -0,0 +1,228 @@
+/*---------------------------------------------------------------------------------------------
+ *  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", "../../languageservice/parser/isKubernetes", "../../requestTypes", "path"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LanguageHandlers = void 0;
+    const isKubernetes_1 = require("../../languageservice/parser/isKubernetes");
+    const requestTypes_1 = require("../../requestTypes");
+    const path = require("path");
+    class LanguageHandlers {
+        constructor(connection, languageService, yamlSettings, validationHandler) {
+            this.connection = connection;
+            this.languageService = languageService;
+            this.yamlSettings = yamlSettings;
+            this.validationHandler = validationHandler;
+            this.pendingLimitExceededWarnings = {};
+        }
+        registerHandlers() {
+            this.connection.onDocumentLinks((params) => this.documentLinkHandler(params));
+            this.connection.onDocumentSymbol((documentSymbolParams) => this.documentSymbolHandler(documentSymbolParams));
+            this.connection.onDocumentFormatting((formatParams) => this.formatterHandler(formatParams));
+            this.connection.onHover((textDocumentPositionParams) => this.hoverHandler(textDocumentPositionParams));
+            this.connection.onCompletion((textDocumentPosition) => this.completionHandler(textDocumentPosition));
+            this.connection.onDidChangeWatchedFiles((change) => this.watchedFilesHandler(change));
+            this.connection.onFoldingRanges((params) => this.foldingRangeHandler(params));
+            this.connection.onSelectionRanges((params) => this.selectionRangeHandler(params));
+            this.connection.onCodeAction((params) => this.codeActionHandler(params));
+            this.connection.onDocumentOnTypeFormatting((params) => this.formatOnTypeHandler(params));
+            this.connection.onCodeLens((params) => this.codeLensHandler(params));
+            this.connection.onCodeLensResolve((params) => this.codeLensResolveHandler(params));
+            this.connection.onDefinition((params) => this.definitionHandler(params));
+            this.connection.onPrepareRename((params) => this.prepareRenameHandler(params));
+            this.connection.onRenameRequest((params) => this.renameHandler(params));
+            this.yamlSettings.documents.onDidChangeContent((change) => this.cancelLimitExceededWarnings(change.document.uri));
+            this.yamlSettings.documents.onDidClose((event) => this.cancelLimitExceededWarnings(event.document.uri));
+        }
+        documentLinkHandler(params) {
+            const document = this.yamlSettings.documents.get(params.textDocument.uri);
+            if (!document) {
+                return Promise.resolve([]);
+            }
+            return this.languageService.findLinks(document);
+        }
+        /**
+         * Called when the code outline in an editor needs to be populated
+         * Returns a list of symbols that is then shown in the code outline
+         */
+        documentSymbolHandler(documentSymbolParams) {
+            const document = this.yamlSettings.documents.get(documentSymbolParams.textDocument.uri);
+            if (!document) {
+                return;
+            }
+            const onResultLimitExceeded = this.onResultLimitExceeded(document.uri, this.yamlSettings.maxItemsComputed, 'document symbols');
+            const context = { resultLimit: this.yamlSettings.maxItemsComputed, onResultLimitExceeded };
+            if (this.yamlSettings.hierarchicalDocumentSymbolSupport) {
+                return this.languageService.findDocumentSymbols2(document, context);
+            }
+            else {
+                return this.languageService.findDocumentSymbols(document, context);
+            }
+        }
+        /**
+         * Called when the formatter is invoked
+         * Returns the formatted document content using prettier
+         */
+        formatterHandler(formatParams) {
+            const document = this.yamlSettings.documents.get(formatParams.textDocument.uri);
+            if (!document) {
+                return;
+            }
+            const customFormatterSettings = {
+                tabWidth: formatParams.options.tabSize,
+                ...this.yamlSettings.yamlFormatterSettings,
+            };
+            return this.languageService.doFormat(document, customFormatterSettings);
+        }
+        formatOnTypeHandler(params) {
+            const document = this.yamlSettings.documents.get(params.textDocument.uri);
+            if (!document) {
+                return;
+            }
+            return this.languageService.doDocumentOnTypeFormatting(document, params);
+        }
+        /**
+         * Called when the user hovers with their mouse over a keyword
+         * Returns an informational tooltip
+         */
+        hoverHandler(textDocumentPositionParams) {
+            const document = this.yamlSettings.documents.get(textDocumentPositionParams.textDocument.uri);
+            if (!document) {
+                return Promise.resolve(undefined);
+            }
+            return this.languageService.doHover(document, textDocumentPositionParams.position);
+        }
+        /**
+         * Called when auto-complete is triggered in an editor
+         * Returns a list of valid completion items
+         */
+        completionHandler(textDocumentPosition) {
+            const textDocument = this.yamlSettings.documents.get(textDocumentPosition.textDocument.uri);
+            const result = {
+                items: [],
+                isIncomplete: false,
+            };
+            if (!textDocument) {
+                return Promise.resolve(result);
+            }
+            return this.languageService.doComplete(textDocument, textDocumentPosition.position, (0, isKubernetes_1.isKubernetesAssociatedDocument)(textDocument, this.yamlSettings.specificValidatorPaths));
+        }
+        /**
+         * Called when a monitored file is changed in an editor
+         * Re-validates the entire document
+         */
+        watchedFilesHandler(change) {
+            let hasChanges = false;
+            change.changes.forEach((c) => {
+                if (this.languageService.resetSchema(c.uri)) {
+                    hasChanges = true;
+                }
+            });
+            if (hasChanges) {
+                this.yamlSettings.documents.all().forEach((document) => this.validationHandler.validate(document));
+            }
+        }
+        foldingRangeHandler(params) {
+            const textDocument = this.yamlSettings.documents.get(params.textDocument.uri);
+            if (!textDocument) {
+                return;
+            }
+            const capabilities = this.yamlSettings.capabilities.textDocument.foldingRange;
+            const rangeLimit = this.yamlSettings.maxItemsComputed || capabilities.rangeLimit;
+            const onRangeLimitExceeded = this.onResultLimitExceeded(textDocument.uri, rangeLimit, 'folding ranges');
+            const context = {
+                rangeLimit,
+                onRangeLimitExceeded,
+                lineFoldingOnly: capabilities.lineFoldingOnly,
+            };
+            return this.languageService.getFoldingRanges(textDocument, context);
+        }
+        selectionRangeHandler(params) {
+            const textDocument = this.yamlSettings.documents.get(params.textDocument.uri);
+            if (!textDocument) {
+                return;
+            }
+            return this.languageService.getSelectionRanges(textDocument, params.positions);
+        }
+        codeActionHandler(params) {
+            const textDocument = this.yamlSettings.documents.get(params.textDocument.uri);
+            if (!textDocument) {
+                return;
+            }
+            return this.languageService.getCodeAction(textDocument, params);
+        }
+        codeLensHandler(params) {
+            const textDocument = this.yamlSettings.documents.get(params.textDocument.uri);
+            if (!textDocument) {
+                return;
+            }
+            return this.languageService.getCodeLens(textDocument);
+        }
+        codeLensResolveHandler(param) {
+            return this.languageService.resolveCodeLens(param);
+        }
+        definitionHandler(params) {
+            const textDocument = this.yamlSettings.documents.get(params.textDocument.uri);
+            if (!textDocument) {
+                return;
+            }
+            return this.languageService.doDefinition(textDocument, params);
+        }
+        prepareRenameHandler(params) {
+            const textDocument = this.yamlSettings.documents.get(params.textDocument.uri);
+            if (!textDocument) {
+                return null;
+            }
+            return this.languageService.prepareRename(textDocument, params);
+        }
+        renameHandler(params) {
+            const textDocument = this.yamlSettings.documents.get(params.textDocument.uri);
+            if (!textDocument) {
+                return null;
+            }
+            return this.languageService.doRename(textDocument, params);
+        }
+        // Adapted from:
+        // https://github.com/microsoft/vscode/blob/94c9ea46838a9a619aeafb7e8afd1170c967bb55/extensions/json-language-features/server/src/jsonServer.ts#L172
+        cancelLimitExceededWarnings(uri) {
+            const warning = this.pendingLimitExceededWarnings[uri];
+            if (warning && warning.timeout) {
+                clearTimeout(warning.timeout);
+                delete this.pendingLimitExceededWarnings[uri];
+            }
+        }
+        onResultLimitExceeded(uri, resultLimit, name) {
+            return () => {
+                let warning = this.pendingLimitExceededWarnings[uri];
+                if (warning) {
+                    if (!warning.timeout) {
+                        // already shown
+                        return;
+                    }
+                    warning.features[name] = name;
+                    warning.timeout.refresh();
+                }
+                else {
+                    warning = { features: { [name]: name } };
+                    warning.timeout = setTimeout(() => {
+                        this.connection.sendNotification(requestTypes_1.ResultLimitReachedNotification.type, `${path.basename(uri)}: For performance reasons, ${Object.keys(warning.features).join(' and ')} have been limited to ${resultLimit} items.`);
+                        warning.timeout = undefined;
+                    }, 2000);
+                    this.pendingLimitExceededWarnings[uri] = warning;
+                }
+            };
+        }
+    }
+    exports.LanguageHandlers = LanguageHandlers;
+});
+//# sourceMappingURL=languageHandlers.js.map

node_modules/yaml-language-server/lib/umd/languageserver/handlers/notificationHandlers.d.ts

@@ -0,0 +1,29 @@
+import { Connection } from 'vscode-languageserver';
+import { LanguageService } from '../../languageservice/yamlLanguageService';
+import { SettingsState } from '../../yamlSettings';
+import { SettingsHandler } from './settingsHandlers';
+export declare class NotificationHandlers {
+    private readonly connection;
+    private languageService;
+    private yamlSettings;
+    private settingsHandler;
+    constructor(connection: Connection, languageService: LanguageService, yamlSettings: SettingsState, settingsHandler: SettingsHandler);
+    registerHandlers(): void;
+    /**
+     * Received a notification from the client with schema associations from other extensions
+     * Update the associations in the server
+     */
+    private schemaAssociationNotificationHandler;
+    /**
+     * Received a notification from the client that it can accept custom schema requests
+     * Register the custom schema provider and use it for requests of unknown scheme
+     */
+    private dynamicSchemaRequestHandler;
+    /**
+     * Received a notification from the client that it can accept content requests
+     * This means that the server sends schemas back to the client side to get resolved rather
+     * than resolving them on the extension side
+     */
+    private vscodeContentRequestHandler;
+    private schemaSelectionRequestHandler;
+}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/notificationHandlers.js

@@ -0,0 +1,60 @@
+(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", "../../requestTypes"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NotificationHandlers = void 0;
+    const requestTypes_1 = require("../../requestTypes");
+    class NotificationHandlers {
+        constructor(connection, languageService, yamlSettings, settingsHandler) {
+            this.connection = connection;
+            this.languageService = languageService;
+            this.yamlSettings = yamlSettings;
+            this.settingsHandler = settingsHandler;
+        }
+        registerHandlers() {
+            this.connection.onNotification(requestTypes_1.SchemaAssociationNotification.type, (associations) => this.schemaAssociationNotificationHandler(associations));
+            this.connection.onNotification(requestTypes_1.DynamicCustomSchemaRequestRegistration.type, () => this.dynamicSchemaRequestHandler());
+            this.connection.onNotification(requestTypes_1.VSCodeContentRequestRegistration.type, () => this.vscodeContentRequestHandler());
+            this.connection.onNotification(requestTypes_1.SchemaSelectionRequests.type, () => this.schemaSelectionRequestHandler());
+        }
+        /**
+         * Received a notification from the client with schema associations from other extensions
+         * Update the associations in the server
+         */
+        schemaAssociationNotificationHandler(associations) {
+            this.yamlSettings.schemaAssociations = associations;
+            this.yamlSettings.specificValidatorPaths = [];
+            this.settingsHandler.pullConfiguration().catch((error) => console.log(error));
+        }
+        /**
+         * Received a notification from the client that it can accept custom schema requests
+         * Register the custom schema provider and use it for requests of unknown scheme
+         */
+        dynamicSchemaRequestHandler() {
+            const schemaProvider = ((resource) => {
+                return this.connection.sendRequest(requestTypes_1.CustomSchemaRequest.type, resource);
+            });
+            this.languageService.registerCustomSchemaProvider(schemaProvider);
+        }
+        /**
+         * Received a notification from the client that it can accept content requests
+         * This means that the server sends schemas back to the client side to get resolved rather
+         * than resolving them on the extension side
+         */
+        vscodeContentRequestHandler() {
+            this.yamlSettings.useVSCodeContentRequest = true;
+        }
+        schemaSelectionRequestHandler() {
+            this.yamlSettings.useSchemaSelectionRequests = true;
+        }
+    }
+    exports.NotificationHandlers = NotificationHandlers;
+});
+//# sourceMappingURL=notificationHandlers.js.map

node_modules/yaml-language-server/lib/umd/languageserver/handlers/notificationHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notificationHandlers.js","sourceRoot":"","sources":["../../../../src/languageserver/handlers/notificationHandlers.ts"],"names":[],"mappings":";;;;;;;;;;;;IAOA,qDAM4B;IAI5B,MAAa,oBAAoB;QAK/B,YACmB,UAAsB,EACvC,eAAgC,EAChC,YAA2B,EAC3B,eAAgC;YAHf,eAAU,GAAV,UAAU,CAAY;YAKvC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;YACvC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;YACjC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACzC,CAAC;QAEM,gBAAgB;YACrB,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,4CAA6B,CAAC,IAAI,EAAE,CAAC,YAAY,EAAE,EAAE,CAClF,IAAI,CAAC,oCAAoC,CAAC,YAAY,CAAC,CACxD,CAAC;YACF,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,qDAAsC,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,2BAA2B,EAAE,CAAC,CAAC;YACtH,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,+CAAgC,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,2BAA2B,EAAE,CAAC,CAAC;YAChH,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,sCAAuB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,6BAA6B,EAAE,CAAC,CAAC;QAC3G,CAAC;QAED;;;WAGG;QACK,oCAAoC,CAAC,YAA8D;YACzG,IAAI,CAAC,YAAY,CAAC,kBAAkB,GAAG,YAAY,CAAC;YACpD,IAAI,CAAC,YAAY,CAAC,sBAAsB,GAAG,EAAE,CAAC;YAC9C,IAAI,CAAC,eAAe,CAAC,iBAAiB,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;QAChF,CAAC;QAED;;;WAGG;QACK,2BAA2B;YACjC,MAAM,cAAc,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE;gBACnC,OAAO,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,kCAAmB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;YACzE,CAAC,CAAyB,CAAC;YAC3B,IAAI,CAAC,eAAe,CAAC,4BAA4B,CAAC,cAAc,CAAC,CAAC;QACpE,CAAC;QAED;;;;WAIG;QACK,2BAA2B;YACjC,IAAI,CAAC,YAAY,CAAC,uBAAuB,GAAG,IAAI,CAAC;QACnD,CAAC;QAEO,6BAA6B;YACnC,IAAI,CAAC,YAAY,CAAC,0BAA0B,GAAG,IAAI,CAAC;QACtD,CAAC;KACF;IA1DD,oDA0DC"}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/requestHandlers.d.ts

@@ -0,0 +1,9 @@
+import { Connection } from 'vscode-languageserver';
+import { LanguageService } from '../../languageservice/yamlLanguageService';
+export declare class RequestHandlers {
+    private readonly connection;
+    private languageService;
+    constructor(connection: Connection, languageService: LanguageService);
+    registerHandlers(): void;
+    private registerSchemaModificationNotificationHandler;
+}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/requestHandlers.js

@@ -0,0 +1,37 @@
+(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", "../../languageservice/services/yamlSchemaService", "../../requestTypes"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RequestHandlers = void 0;
+    const yamlSchemaService_1 = require("../../languageservice/services/yamlSchemaService");
+    const requestTypes_1 = require("../../requestTypes");
+    class RequestHandlers {
+        constructor(connection, languageService) {
+            this.connection = connection;
+            this.languageService = languageService;
+        }
+        registerHandlers() {
+            this.connection.onRequest(requestTypes_1.SchemaModificationNotification.type, (modifications) => this.registerSchemaModificationNotificationHandler(modifications));
+        }
+        registerSchemaModificationNotificationHandler(modifications) {
+            if (modifications.action === yamlSchemaService_1.MODIFICATION_ACTIONS.add) {
+                this.languageService.modifySchemaContent(modifications);
+            }
+            else if (modifications.action === yamlSchemaService_1.MODIFICATION_ACTIONS.delete) {
+                this.languageService.deleteSchemaContent(modifications);
+            }
+            else if (modifications.action === yamlSchemaService_1.MODIFICATION_ACTIONS.deleteAll) {
+                this.languageService.deleteSchemasWhole(modifications);
+            }
+        }
+    }
+    exports.RequestHandlers = RequestHandlers;
+});
+//# sourceMappingURL=requestHandlers.js.map

node_modules/yaml-language-server/lib/umd/languageserver/handlers/requestHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestHandlers.js","sourceRoot":"","sources":["../../../../src/languageserver/handlers/requestHandlers.ts"],"names":[],"mappings":";;;;;;;;;;;;IAKA,wFAK0D;IAE1D,qDAAoE;IAEpE,MAAa,eAAe;QAE1B,YACmB,UAAsB,EACvC,eAAgC;YADf,eAAU,GAAV,UAAU,CAAY;YAGvC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACzC,CAAC;QAEM,gBAAgB;YACrB,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,6CAA8B,CAAC,IAAI,EAAE,CAAC,aAAa,EAAE,EAAE,CAC/E,IAAI,CAAC,6CAA6C,CAAC,aAAa,CAAC,CAClE,CAAC;QACJ,CAAC;QAEO,6CAA6C,CACnD,aAAqE;YAErE,IAAI,aAAa,CAAC,MAAM,KAAK,wCAAoB,CAAC,GAAG,EAAE;gBACrD,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;aACzD;iBAAM,IAAI,aAAa,CAAC,MAAM,KAAK,wCAAoB,CAAC,MAAM,EAAE;gBAC/D,IAAI,CAAC,eAAe,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC;aACzD;iBAAM,IAAI,aAAa,CAAC,MAAM,KAAK,wCAAoB,CAAC,SAAS,EAAE;gBAClE,IAAI,CAAC,eAAe,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;aACxD;QACH,CAAC;KACF;IA1BD,0CA0BC"}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/schemaSelectionHandlers.d.ts

@@ -0,0 +1,13 @@
+import { Connection } from 'vscode-languageserver/node';
+import { YAMLSchemaService } from '../../languageservice/services/yamlSchemaService';
+import { SettingsState } from '../../yamlSettings';
+import { JSONSchemaDescription, JSONSchemaDescriptionExt } from '../../requestTypes';
+export declare class JSONSchemaSelection {
+    private readonly schemaService;
+    private readonly yamlSettings?;
+    private readonly connection?;
+    constructor(schemaService: YAMLSchemaService, yamlSettings?: SettingsState, connection?: Connection);
+    getSchemas(docUri: string): Promise<JSONSchemaDescription[]>;
+    private getSchemasForFile;
+    getAllSchemas(docUri: string): Promise<JSONSchemaDescriptionExt[]>;
+}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/schemaSelectionHandlers.js

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------------------------
+ *  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", "../../languageservice/parser/yaml-documents", "../../languageservice/utils/schemaUrls", "../../requestTypes"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JSONSchemaSelection = void 0;
+    const yaml_documents_1 = require("../../languageservice/parser/yaml-documents");
+    const schemaUrls_1 = require("../../languageservice/utils/schemaUrls");
+    const requestTypes_1 = require("../../requestTypes");
+    class JSONSchemaSelection {
+        constructor(schemaService, yamlSettings, connection) {
+            this.schemaService = schemaService;
+            this.yamlSettings = yamlSettings;
+            this.connection = connection;
+            this.connection?.onRequest(requestTypes_1.SchemaSelectionRequests.getSchema, (fileUri) => {
+                return this.getSchemas(fileUri);
+            });
+            this.connection?.onRequest(requestTypes_1.SchemaSelectionRequests.getAllSchemas, (fileUri) => {
+                return this.getAllSchemas(fileUri);
+            });
+        }
+        async getSchemas(docUri) {
+            const schemas = await this.getSchemasForFile(docUri);
+            return Array.from(schemas).map((val) => {
+                return {
+                    name: val[1].title,
+                    uri: val[0],
+                    description: val[1].description,
+                    versions: val[1].versions,
+                };
+            });
+        }
+        async getSchemasForFile(docUri) {
+            const document = this.yamlSettings?.documents.get(docUri);
+            const schemas = new Map();
+            if (!document) {
+                return schemas;
+            }
+            const yamlDoc = yaml_documents_1.yamlDocumentsCache.getYamlDocument(document);
+            for (const currentYAMLDoc of yamlDoc.documents) {
+                const schema = await this.schemaService.getSchemaForResource(document.uri, currentYAMLDoc);
+                if (schema?.schema) {
+                    const schemaUrls = (0, schemaUrls_1.getSchemaUrls)(schema?.schema);
+                    if (schemaUrls.size === 0) {
+                        continue;
+                    }
+                    for (const urlToSchema of schemaUrls) {
+                        schemas.set(urlToSchema[0], urlToSchema[1]);
+                    }
+                }
+            }
+            return schemas;
+        }
+        async getAllSchemas(docUri) {
+            const fileSchemas = await this.getSchemasForFile(docUri);
+            const fileSchemasHandle = Array.from(fileSchemas.entries()).map((val) => {
+                return {
+                    uri: val[0],
+                    fromStore: false,
+                    usedForCurrentFile: true,
+                    name: val[1].title,
+                    description: val[1].description,
+                    versions: val[1].versions,
+                };
+            });
+            const result = [];
+            let allSchemas = this.schemaService.getAllSchemas();
+            allSchemas = allSchemas.filter((val) => !fileSchemas.has(val.uri));
+            result.push(...fileSchemasHandle);
+            result.push(...allSchemas);
+            return result;
+        }
+    }
+    exports.JSONSchemaSelection = JSONSchemaSelection;
+});
+//# sourceMappingURL=schemaSelectionHandlers.js.map

node_modules/yaml-language-server/lib/umd/languageserver/handlers/schemaSelectionHandlers.js.map

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

node_modules/yaml-language-server/lib/umd/languageserver/handlers/settingsHandlers.d.ts

@@ -0,0 +1,42 @@
+import { Connection } from 'vscode-languageserver';
+import { LanguageService } from '../../languageservice/yamlLanguageService';
+import { SettingsState } from '../../yamlSettings';
+import { Telemetry } from '../../languageservice/telemetry';
+import { ValidationHandler } from './validationHandlers';
+export declare class SettingsHandler {
+    private readonly connection;
+    private readonly languageService;
+    private readonly yamlSettings;
+    private readonly validationHandler;
+    private readonly telemetry;
+    constructor(connection: Connection, languageService: LanguageService, yamlSettings: SettingsState, validationHandler: ValidationHandler, telemetry: Telemetry);
+    registerHandlers(): Promise<void>;
+    /**
+     *  The server pull the 'yaml', 'http.proxy', 'http.proxyStrictSSL', '[yaml]' settings sections
+     */
+    pullConfiguration(): Promise<void>;
+    private setConfiguration;
+    /**
+     * This function helps set the schema store if it hasn't already been set
+     * AND the schema store setting is enabled. If the schema store setting
+     * is not enabled we need to clear the schemas.
+     */
+    private setSchemaStoreSettingsIfNotSet;
+    /**
+     * When the schema store is enabled, download and store YAML schema associations
+     */
+    private getSchemaStoreMatchingSchemas;
+    /**
+     * Called when server settings or schema associations are changed
+     * Re-creates schema associations and re-validates any open YAML files
+     */
+    private updateConfiguration;
+    /**
+     * Stores schema associations in server settings, handling kubernetes
+     * @param uri string path to schema (whether local or online)
+     * @param fileMatch file pattern to apply the schema to
+     * @param schema schema id
+     * @param languageSettings current server settings
+     */
+    private configureSchemas;
+}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/settingsHandlers.js

@@ -0,0 +1,326 @@
+(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", "request-light", "vscode-languageserver", "../../languageservice/utils/paths", "../../languageservice/utils/schemaUrls", "../../languageservice/yamlLanguageService", "../../requestTypes"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SettingsHandler = 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 request_light_1 = require("request-light");
+    const vscode_languageserver_1 = require("vscode-languageserver");
+    const paths_1 = require("../../languageservice/utils/paths");
+    const schemaUrls_1 = require("../../languageservice/utils/schemaUrls");
+    const yamlLanguageService_1 = require("../../languageservice/yamlLanguageService");
+    const requestTypes_1 = require("../../requestTypes");
+    class SettingsHandler {
+        constructor(connection, languageService, yamlSettings, validationHandler, telemetry) {
+            this.connection = connection;
+            this.languageService = languageService;
+            this.yamlSettings = yamlSettings;
+            this.validationHandler = validationHandler;
+            this.telemetry = telemetry;
+        }
+        async registerHandlers() {
+            if (this.yamlSettings.hasConfigurationCapability && this.yamlSettings.clientDynamicRegisterSupport) {
+                try {
+                    // Register for all configuration changes.
+                    await this.connection.client.register(vscode_languageserver_1.DidChangeConfigurationNotification.type);
+                }
+                catch (err) {
+                    this.telemetry.sendError('yaml.settings.error', err);
+                }
+            }
+            this.connection.onDidChangeConfiguration(() => this.pullConfiguration());
+        }
+        /**
+         *  The server pull the 'yaml', 'http.proxy', 'http.proxyStrictSSL', '[yaml]' settings sections
+         */
+        async pullConfiguration() {
+            const config = await this.connection.workspace.getConfiguration([
+                { section: 'yaml' },
+                { section: 'http' },
+                { section: '[yaml]', scopeUri: 'null' },
+                { section: 'editor' },
+                { section: 'files' },
+            ]);
+            const settings = {
+                yaml: config[0],
+                http: {
+                    proxy: config[1]?.proxy ?? '',
+                    proxyStrictSSL: config[1]?.proxyStrictSSL ?? false,
+                },
+                yamlEditor: config[2],
+                vscodeEditor: config[3],
+                files: config[4],
+            };
+            await this.setConfiguration(settings);
+        }
+        async setConfiguration(settings) {
+            (0, request_light_1.configure)(settings.http && settings.http.proxy, settings.http && settings.http.proxyStrictSSL);
+            this.yamlSettings.specificValidatorPaths = [];
+            if (settings.yaml) {
+                if (Object.prototype.hasOwnProperty.call(settings.yaml, 'schemas')) {
+                    this.yamlSettings.yamlConfigurationSettings = settings.yaml.schemas;
+                }
+                if (Object.prototype.hasOwnProperty.call(settings.yaml, 'validate')) {
+                    this.yamlSettings.yamlShouldValidate = settings.yaml.validate;
+                }
+                if (Object.prototype.hasOwnProperty.call(settings.yaml, 'hover')) {
+                    this.yamlSettings.yamlShouldHover = settings.yaml.hover;
+                }
+                if (Object.prototype.hasOwnProperty.call(settings.yaml, 'hoverAnchor')) {
+                    this.yamlSettings.yamlShouldHoverAnchor = settings.yaml.hoverAnchor;
+                }
+                if (Object.prototype.hasOwnProperty.call(settings.yaml, 'completion')) {
+                    this.yamlSettings.yamlShouldCompletion = settings.yaml.completion;
+                }
+                this.yamlSettings.customTags = settings.yaml.customTags ? settings.yaml.customTags : [];
+                this.yamlSettings.maxItemsComputed = Math.trunc(Math.max(0, Number(settings.yaml.maxItemsComputed))) || 5000;
+                if (settings.yaml.schemaStore) {
+                    this.yamlSettings.schemaStoreEnabled = settings.yaml.schemaStore.enable;
+                    if (settings.yaml.schemaStore.url) {
+                        this.yamlSettings.schemaStoreUrl = settings.yaml.schemaStore.url;
+                    }
+                }
+                if (settings.yaml.kubernetesCRDStore) {
+                    this.yamlSettings.kubernetesCRDStoreEnabled = settings.yaml.kubernetesCRDStore.enable;
+                    if (settings.yaml.kubernetesCRDStore.url?.length !== 0) {
+                        this.yamlSettings.kubernetesCRDStoreUrl = settings.yaml.kubernetesCRDStore.url;
+                    }
+                }
+                if (settings.files?.associations) {
+                    for (const [ext, languageId] of Object.entries(settings.files.associations)) {
+                        if (languageId === 'yaml') {
+                            this.yamlSettings.fileExtensions.push(ext);
+                        }
+                    }
+                }
+                this.yamlSettings.yamlVersion = settings.yaml.yamlVersion ?? '1.2';
+                if (settings.yaml.format) {
+                    this.yamlSettings.yamlFormatterSettings = {
+                        proseWrap: settings.yaml.format.proseWrap || 'preserve',
+                        printWidth: settings.yaml.format.printWidth || 80,
+                    };
+                    if (settings.yaml.format.singleQuote !== undefined) {
+                        this.yamlSettings.yamlFormatterSettings.singleQuote = settings.yaml.format.singleQuote;
+                    }
+                    if (settings.yaml.format.bracketSpacing !== undefined) {
+                        this.yamlSettings.yamlFormatterSettings.bracketSpacing = settings.yaml.format.bracketSpacing;
+                    }
+                    if (settings.yaml.format.trailingComma !== undefined) {
+                        this.yamlSettings.yamlFormatterSettings.trailingComma = settings.yaml.format.trailingComma;
+                    }
+                    if (settings.yaml.format.enable !== undefined) {
+                        this.yamlSettings.yamlFormatterSettings.enable = settings.yaml.format.enable;
+                    }
+                }
+                this.yamlSettings.disableAdditionalProperties = settings.yaml.disableAdditionalProperties;
+                this.yamlSettings.disableDefaultProperties = settings.yaml.disableDefaultProperties;
+                if (settings.yaml.suggest) {
+                    this.yamlSettings.suggest.parentSkeletonSelectedFirst = settings.yaml.suggest.parentSkeletonSelectedFirst;
+                }
+                this.yamlSettings.style = {
+                    flowMapping: settings.yaml.style?.flowMapping ?? 'allow',
+                    flowSequence: settings.yaml.style?.flowSequence ?? 'allow',
+                };
+                this.yamlSettings.keyOrdering = settings.yaml.keyOrdering ?? false;
+            }
+            this.yamlSettings.schemaConfigurationSettings = [];
+            let tabSize = 2;
+            if (settings.vscodeEditor) {
+                tabSize =
+                    !settings.vscodeEditor['detectIndentation'] && settings.yamlEditor ? settings.yamlEditor['editor.tabSize'] : tabSize;
+            }
+            if (settings.yamlEditor && settings.yamlEditor['editor.tabSize']) {
+                this.yamlSettings.indentation = ' '.repeat(tabSize);
+            }
+            for (const uri in this.yamlSettings.yamlConfigurationSettings) {
+                const globPattern = this.yamlSettings.yamlConfigurationSettings[uri];
+                const schemaObj = {
+                    fileMatch: Array.isArray(globPattern) ? globPattern : [globPattern],
+                    uri: (0, schemaUrls_1.checkSchemaURI)(this.yamlSettings.workspaceFolders, this.yamlSettings.workspaceRoot, uri, this.telemetry),
+                };
+                this.yamlSettings.schemaConfigurationSettings.push(schemaObj);
+            }
+            await this.setSchemaStoreSettingsIfNotSet();
+            this.updateConfiguration();
+            if (this.yamlSettings.useSchemaSelectionRequests) {
+                this.connection.sendNotification(requestTypes_1.SchemaSelectionRequests.schemaStoreInitialized, {});
+            }
+            // dynamically enable & disable the formatter
+            if (this.yamlSettings.clientDynamicRegisterSupport) {
+                const enableFormatter = settings && settings.yaml && settings.yaml.format && settings.yaml.format.enable;
+                if (enableFormatter) {
+                    if (!this.yamlSettings.formatterRegistration) {
+                        this.yamlSettings.formatterRegistration = this.connection.client.register(vscode_languageserver_1.DocumentFormattingRequest.type, {
+                            documentSelector: [
+                                { language: 'yaml' },
+                                { language: 'dockercompose' },
+                                { language: 'github-actions-workflow' },
+                                { language: 'yaml-textmate' },
+                                { language: 'yaml-tmlanguage' },
+                                { pattern: '**/*.{yaml,yml}' },
+                            ],
+                        });
+                    }
+                }
+                else if (this.yamlSettings.formatterRegistration) {
+                    this.yamlSettings.formatterRegistration.then((r) => {
+                        return r.dispose();
+                    });
+                    this.yamlSettings.formatterRegistration = null;
+                }
+            }
+        }
+        /**
+         * This function helps set the schema store if it hasn't already been set
+         * AND the schema store setting is enabled. If the schema store setting
+         * is not enabled we need to clear the schemas.
+         */
+        async setSchemaStoreSettingsIfNotSet() {
+            const schemaStoreIsSet = this.yamlSettings.schemaStoreSettings.length !== 0;
+            const schemaStoreUrl = this.yamlSettings.schemaStoreUrl || schemaUrls_1.JSON_SCHEMASTORE_URL;
+            if (this.yamlSettings.schemaStoreEnabled && !schemaStoreIsSet) {
+                try {
+                    const schemaStore = await this.getSchemaStoreMatchingSchemas(schemaStoreUrl);
+                    this.yamlSettings.schemaStoreSettings = schemaStore.schemas;
+                }
+                catch (err) {
+                    // ignore
+                }
+            }
+            else if (!this.yamlSettings.schemaStoreEnabled) {
+                this.yamlSettings.schemaStoreSettings = [];
+            }
+        }
+        /**
+         * When the schema store is enabled, download and store YAML schema associations
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async getSchemaStoreMatchingSchemas(schemaStoreUrl) {
+            const response = await (0, request_light_1.xhr)({ url: schemaStoreUrl });
+            const languageSettings = {
+                schemas: [],
+            };
+            // Parse the schema store catalog as JSON
+            const schemas = JSON.parse(response.responseText);
+            for (const schemaIndex in schemas.schemas) {
+                const schema = schemas.schemas[schemaIndex];
+                if (schema && schema.fileMatch) {
+                    for (const fileMatch in schema.fileMatch) {
+                        const currFileMatch = schema.fileMatch[fileMatch];
+                        // If the schema is for files with a YAML extension, save the schema association
+                        if (this.yamlSettings.fileExtensions.findIndex((value) => {
+                            return currFileMatch.indexOf(value) > -1;
+                        }) > -1) {
+                            languageSettings.schemas.push({
+                                uri: schema.url,
+                                fileMatch: [currFileMatch],
+                                priority: yamlLanguageService_1.SchemaPriority.SchemaStore,
+                                name: schema.name,
+                                description: schema.description,
+                                versions: schema.versions,
+                            });
+                        }
+                    }
+                }
+            }
+            return languageSettings;
+        }
+        /**
+         * Called when server settings or schema associations are changed
+         * Re-creates schema associations and re-validates any open YAML files
+         */
+        updateConfiguration() {
+            let languageSettings = {
+                validate: this.yamlSettings.yamlShouldValidate,
+                hover: this.yamlSettings.yamlShouldHover,
+                hoverAnchor: this.yamlSettings.yamlShouldHoverAnchor,
+                completion: this.yamlSettings.yamlShouldCompletion,
+                schemas: [],
+                customTags: this.yamlSettings.customTags,
+                format: this.yamlSettings.yamlFormatterSettings.enable,
+                indentation: this.yamlSettings.indentation,
+                disableAdditionalProperties: this.yamlSettings.disableAdditionalProperties,
+                disableDefaultProperties: this.yamlSettings.disableDefaultProperties,
+                parentSkeletonSelectedFirst: this.yamlSettings.suggest.parentSkeletonSelectedFirst,
+                flowMapping: this.yamlSettings.style?.flowMapping,
+                flowSequence: this.yamlSettings.style?.flowSequence,
+                yamlVersion: this.yamlSettings.yamlVersion,
+                keyOrdering: this.yamlSettings.keyOrdering,
+            };
+            if (this.yamlSettings.schemaAssociations) {
+                if (Array.isArray(this.yamlSettings.schemaAssociations)) {
+                    this.yamlSettings.schemaAssociations.forEach((association) => {
+                        languageSettings = this.configureSchemas(association.uri, association.fileMatch, association.schema, languageSettings, yamlLanguageService_1.SchemaPriority.SchemaAssociation);
+                    });
+                }
+                else {
+                    for (const uri in this.yamlSettings.schemaAssociations) {
+                        const fileMatch = this.yamlSettings.schemaAssociations[uri];
+                        languageSettings = this.configureSchemas(uri, fileMatch, null, languageSettings, yamlLanguageService_1.SchemaPriority.SchemaAssociation);
+                    }
+                }
+            }
+            if (this.yamlSettings.schemaConfigurationSettings) {
+                this.yamlSettings.schemaConfigurationSettings.forEach((schema) => {
+                    let uri = schema.uri;
+                    if (!uri && schema.schema) {
+                        uri = schema.schema.id;
+                    }
+                    if (!uri && schema.fileMatch) {
+                        uri = 'vscode://schemas/custom/' + encodeURIComponent(schema.fileMatch.join('&'));
+                    }
+                    if (uri) {
+                        if ((0, paths_1.isRelativePath)(uri)) {
+                            uri = (0, paths_1.relativeToAbsolutePath)(this.yamlSettings.workspaceFolders, this.yamlSettings.workspaceRoot, uri);
+                        }
+                        languageSettings = this.configureSchemas(uri, schema.fileMatch, schema.schema, languageSettings, yamlLanguageService_1.SchemaPriority.Settings);
+                    }
+                });
+            }
+            if (this.yamlSettings.schemaStoreSettings) {
+                languageSettings.schemas = languageSettings.schemas.concat(this.yamlSettings.schemaStoreSettings);
+            }
+            this.languageService.configure(languageSettings);
+            // Revalidate any open text documents
+            this.yamlSettings.documents.all().forEach((document) => this.validationHandler.validate(document));
+        }
+        /**
+         * Stores schema associations in server settings, handling kubernetes
+         * @param uri string path to schema (whether local or online)
+         * @param fileMatch file pattern to apply the schema to
+         * @param schema schema id
+         * @param languageSettings current server settings
+         */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        configureSchemas(uri, fileMatch, schema, languageSettings, priorityLevel) {
+            uri = (0, schemaUrls_1.checkSchemaURI)(this.yamlSettings.workspaceFolders, this.yamlSettings.workspaceRoot, uri, this.telemetry);
+            if (schema === null) {
+                languageSettings.schemas.push({ uri, fileMatch: fileMatch, priority: priorityLevel });
+            }
+            else {
+                languageSettings.schemas.push({ uri, fileMatch: fileMatch, schema: schema, priority: priorityLevel });
+            }
+            if (fileMatch.constructor === Array && uri === schemaUrls_1.KUBERNETES_SCHEMA_URL) {
+                fileMatch.forEach((url) => {
+                    this.yamlSettings.specificValidatorPaths.push(url);
+                });
+            }
+            else if (uri === schemaUrls_1.KUBERNETES_SCHEMA_URL) {
+                this.yamlSettings.specificValidatorPaths.push(fileMatch);
+            }
+            return languageSettings;
+        }
+    }
+    exports.SettingsHandler = SettingsHandler;
+});
+//# sourceMappingURL=settingsHandlers.js.map

node_modules/yaml-language-server/lib/umd/languageserver/handlers/validationHandlers.d.ts

@@ -0,0 +1,14 @@
+import { Connection } from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Diagnostic } from 'vscode-languageserver-types';
+import { LanguageService } from '../../languageservice/yamlLanguageService';
+import { SettingsState } from '../../yamlSettings';
+export declare class ValidationHandler {
+    private readonly connection;
+    private languageService;
+    private yamlSettings;
+    constructor(connection: Connection, languageService: LanguageService, yamlSettings: SettingsState);
+    validate(textDocument: TextDocument): void;
+    private cleanPendingValidation;
+    validateTextDocument(textDocument: TextDocument): Promise<Diagnostic[]>;
+}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/validationHandlers.js

@@ -0,0 +1,68 @@
+(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", "../../languageservice/parser/isKubernetes", "../../languageservice/utils/arrUtils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ValidationHandler = void 0;
+    const isKubernetes_1 = require("../../languageservice/parser/isKubernetes");
+    const arrUtils_1 = require("../../languageservice/utils/arrUtils");
+    class ValidationHandler {
+        constructor(connection, languageService, yamlSettings) {
+            this.connection = connection;
+            this.languageService = languageService;
+            this.yamlSettings = yamlSettings;
+            this.yamlSettings.documents.onDidChangeContent((change) => {
+                this.validate(change.document);
+            });
+            this.yamlSettings.documents.onDidClose((event) => {
+                this.cleanPendingValidation(event.document);
+                this.connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
+            });
+        }
+        validate(textDocument) {
+            this.cleanPendingValidation(textDocument);
+            this.yamlSettings.pendingValidationRequests[textDocument.uri] = setTimeout(() => {
+                delete this.yamlSettings.pendingValidationRequests[textDocument.uri];
+                this.validateTextDocument(textDocument);
+            }, this.yamlSettings.validationDelayMs);
+        }
+        cleanPendingValidation(textDocument) {
+            const request = this.yamlSettings.pendingValidationRequests[textDocument.uri];
+            if (request) {
+                clearTimeout(request);
+                delete this.yamlSettings.pendingValidationRequests[textDocument.uri];
+            }
+        }
+        validateTextDocument(textDocument) {
+            if (!textDocument) {
+                return;
+            }
+            return this.languageService
+                .doValidation(textDocument, (0, isKubernetes_1.isKubernetesAssociatedDocument)(textDocument, this.yamlSettings.specificValidatorPaths))
+                .then((diagnosticResults) => {
+                const diagnostics = [];
+                for (const diagnosticItem of diagnosticResults) {
+                    // Convert all warnings to errors
+                    if (diagnosticItem.severity === 2) {
+                        diagnosticItem.severity = 1;
+                    }
+                    diagnostics.push(diagnosticItem);
+                }
+                const removeDuplicatesDiagnostics = (0, arrUtils_1.removeDuplicatesObj)(diagnostics);
+                this.connection.sendDiagnostics({
+                    uri: textDocument.uri,
+                    diagnostics: removeDuplicatesDiagnostics,
+                });
+                return removeDuplicatesDiagnostics;
+            });
+        }
+    }
+    exports.ValidationHandler = ValidationHandler;
+});
+//# sourceMappingURL=validationHandlers.js.map

node_modules/yaml-language-server/lib/umd/languageserver/handlers/validationHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationHandlers.js","sourceRoot":"","sources":["../../../../src/languageserver/handlers/validationHandlers.ts"],"names":[],"mappings":";;;;;;;;;;;;IAOA,4EAA2F;IAC3F,mEAA2E;IAI3E,MAAa,iBAAiB;QAI5B,YACmB,UAAsB,EACvC,eAAgC,EAChC,YAA2B;YAFV,eAAU,GAAV,UAAU,CAAY;YAIvC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;YACvC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;YAEjC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,kBAAkB,CAAC,CAAC,MAAM,EAAE,EAAE;gBACxD,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;YACjC,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;gBAC/C,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;gBAC5C,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC;YAChF,CAAC,CAAC,CAAC;QACL,CAAC;QAED,QAAQ,CAAC,YAA0B;YACjC,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAAC,CAAC;YAC1C,IAAI,CAAC,YAAY,CAAC,yBAAyB,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC9E,OAAO,IAAI,CAAC,YAAY,CAAC,yBAAyB,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;gBACrE,IAAI,CAAC,oBAAoB,CAAC,YAAY,CAAC,CAAC;YAC1C,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;QAC1C,CAAC;QAEO,sBAAsB,CAAC,YAA0B;YACvD,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,yBAAyB,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;YAE9E,IAAI,OAAO,EAAE;gBACX,YAAY,CAAC,OAAO,CAAC,CAAC;gBACtB,OAAO,IAAI,CAAC,YAAY,CAAC,yBAAyB,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;aACtE;QACH,CAAC;QAED,oBAAoB,CAAC,YAA0B;YAC7C,IAAI,CAAC,YAAY,EAAE;gBACjB,OAAO;aACR;YAED,OAAO,IAAI,CAAC,eAAe;iBACxB,YAAY,CAAC,YAAY,EAAE,IAAA,6CAA8B,EAAC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,sBAAsB,CAAC,CAAC;iBAClH,IAAI,CAAC,CAAC,iBAAiB,EAAE,EAAE;gBAC1B,MAAM,WAAW,GAAiB,EAAE,CAAC;gBACrC,KAAK,MAAM,cAAc,IAAI,iBAAiB,EAAE;oBAC9C,iCAAiC;oBACjC,IAAI,cAAc,CAAC,QAAQ,KAAK,CAAC,EAAE;wBACjC,cAAc,CAAC,QAAQ,GAAG,CAAC,CAAC;qBAC7B;oBACD,WAAW,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;iBAClC;gBAED,MAAM,2BAA2B,GAAG,IAAA,8BAAmB,EAAC,WAAW,CAAC,CAAC;gBACrE,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC;oBAC9B,GAAG,EAAE,YAAY,CAAC,GAAG;oBACrB,WAAW,EAAE,2BAA2B;iBACzC,CAAC,CAAC;gBACH,OAAO,2BAA2B,CAAC;YACrC,CAAC,CAAC,CAAC;QACP,CAAC;KACF;IA/DD,8CA+DC"}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/workspaceHandlers.d.ts

@@ -0,0 +1,9 @@
+import { Connection } from 'vscode-languageserver';
+import { CommandExecutor } from '../commandExecutor';
+export declare class WorkspaceHandlers {
+    private readonly connection;
+    private readonly commandExecutor;
+    constructor(connection: Connection, commandExecutor: CommandExecutor);
+    registerHandlers(): void;
+    private executeCommand;
+}

node_modules/yaml-language-server/lib/umd/languageserver/handlers/workspaceHandlers.js

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+ *  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.WorkspaceHandlers = void 0;
+    class WorkspaceHandlers {
+        constructor(connection, commandExecutor) {
+            this.connection = connection;
+            this.commandExecutor = commandExecutor;
+        }
+        registerHandlers() {
+            this.connection.onExecuteCommand((params) => this.executeCommand(params));
+        }
+        executeCommand(params) {
+            return this.commandExecutor.executeCommand(params);
+        }
+    }
+    exports.WorkspaceHandlers = WorkspaceHandlers;
+});
+//# sourceMappingURL=workspaceHandlers.js.map

node_modules/yaml-language-server/lib/umd/languageserver/handlers/workspaceHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaceHandlers.js","sourceRoot":"","sources":["../../../../src/languageserver/handlers/workspaceHandlers.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAKhG,MAAa,iBAAiB;QAC5B,YACmB,UAAsB,EACtB,eAAgC;YADhC,eAAU,GAAV,UAAU,CAAY;YACtB,oBAAe,GAAf,eAAe,CAAiB;QAChD,CAAC;QAEJ,gBAAgB;YACd,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;QAC5E,CAAC;QAEO,cAAc,CAAC,MAA4B;YACjD,OAAO,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QACrD,CAAC;KACF;IAbD,8CAaC"}

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

@@ -0,0 +1,9 @@
+import { Connection } from 'vscode-languageserver';
+import { TelemetryEvent, Telemetry } from '../languageservice/telemetry';
+export declare class TelemetryImpl implements Telemetry {
+    private readonly connection;
+    constructor(connection: Connection);
+    send(event: TelemetryEvent): void;
+    sendError(name: string, error: unknown): void;
+    sendTrack(name: string, properties: unknown): void;
+}

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

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------------------------------------------
+ *  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", "../languageservice/utils/objects"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TelemetryImpl = void 0;
+    const objects_1 = require("../languageservice/utils/objects");
+    class TelemetryImpl {
+        constructor(connection) {
+            this.connection = connection;
+        }
+        send(event) {
+            this.connection.telemetry.logEvent(event);
+        }
+        sendError(name, error) {
+            this.send({ name, type: 'track', properties: { error: (0, objects_1.convertErrorToTelemetryMsg)(error) } });
+        }
+        sendTrack(name, properties) {
+            this.send({ name, type: 'track', properties: properties });
+        }
+    }
+    exports.TelemetryImpl = TelemetryImpl;
+});
+//# sourceMappingURL=telemetry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.js","sourceRoot":"","sources":["../../../src/languageserver/telemetry.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAIhG,8DAA8E;IAE9E,MAAa,aAAa;QACxB,YAA6B,UAAsB;YAAtB,eAAU,GAAV,UAAU,CAAY;QAAG,CAAC;QAEvD,IAAI,CAAC,KAAqB;YACxB,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC5C,CAAC;QAED,SAAS,CAAC,IAAY,EAAE,KAAc;YACpC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,IAAA,oCAA0B,EAAC,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;QAC/F,CAAC;QAED,SAAS,CAAC,IAAY,EAAE,UAAmB;YACzC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC,CAAC;QAC7D,CAAC;KACF;IAdD,sCAcC"}

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

@@ -0,0 +1,49 @@
+import { Node, Pair } from 'yaml';
+export type YamlNode = Node | Pair;
+export 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;
+    readonly source: string;
+}
+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,103 @@
+import { CompletionItemKind } from 'vscode-json-languageservice';
+import { SchemaVersions } from './yamlTypes';
+export type JSONSchemaRef = JSONSchema | boolean;
+export declare enum SchemaDialect {
+    draft04 = "draft04",
+    draft07 = "draft07",
+    draft2019 = "draft2019-09",
+    draft2020 = "draft2020-12"
+}
+export interface JSONSchema {
+    _dialect?: SchemaDialect;
+    _baseUrl?: string;
+    _$ref?: string;
+    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?: JSONSchemaRef;
+    minProperties?: number;
+    maxProperties?: number;
+    dependencies?: JSONSchemaMap | {
+        [prop: string]: string[];
+    };
+    items?: JSONSchemaRef | JSONSchemaRef[];
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    additionalItems?: JSONSchemaRef;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean | number;
+    exclusiveMaximum?: boolean | number;
+    multipleOf?: number;
+    required?: 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;
+    $anchor?: string;
+    $defs?: {
+        [name: string]: JSONSchema;
+    };
+    $recursiveAnchor?: boolean;
+    $recursiveRef?: string;
+    $vocabulary?: Record<string, boolean>;
+    dependentSchemas?: JSONSchemaMap;
+    unevaluatedItems?: JSONSchemaRef;
+    unevaluatedProperties?: JSONSchemaRef;
+    dependentRequired?: Record<string, string[]>;
+    minContains?: number;
+    maxContains?: number;
+    prefixItems?: JSONSchemaRef[];
+    $dynamicRef?: string;
+    $dynamicAnchor?: string;
+    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,25 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SchemaDialect = void 0;
+    var SchemaDialect;
+    (function (SchemaDialect) {
+        SchemaDialect["draft04"] = "draft04";
+        SchemaDialect["draft07"] = "draft07";
+        SchemaDialect["draft2019"] = "draft2019-09";
+        SchemaDialect["draft2020"] = "draft2020-12";
+    })(SchemaDialect = exports.SchemaDialect || (exports.SchemaDialect = {}));
+});
+//# 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;;;;;;;;;;;;;IAMhG,IAAY,aAKX;IALD,WAAY,aAAa;QACvB,oCAAmB,CAAA;QACnB,oCAAmB,CAAA;QACnB,2CAA0B,CAAA;QAC1B,2CAA0B,CAAA;IAC5B,CAAC,EALW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAKxB"}

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

@@ -0,0 +1,11 @@
+import { Alias, Document, LineCounter } from 'yaml';
+import { ASTNode, YamlNode } from '../jsonASTTypes';
+type NodeRange = [number, number, number];
+export declare const aliasDepth: {
+    maxRefCount: number;
+    currentRefDepth: number;
+    aliasResolutionCache: Map<Alias, ASTNode>;
+};
+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,191 @@
+/*---------------------------------------------------------------------------------------------
+ *  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", "./jsonDocument"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.toOffsetLength = exports.convertAST = exports.aliasDepth = void 0;
+    const yaml_1 = require("yaml");
+    const jsonDocument_1 = require("./jsonDocument");
+    // Exported for tests
+    exports.aliasDepth = {
+        maxRefCount: 1000,
+        currentRefDepth: 0,
+        aliasResolutionCache: new Map(),
+    };
+    function convertAST(parent, node, doc, lineCounter) {
+        if (!parent) {
+            // first invocation
+            exports.aliasDepth.currentRefDepth = 0;
+            exports.aliasDepth.aliasResolutionCache = new Map();
+        }
+        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) && exports.aliasDepth.currentRefDepth < exports.aliasDepth.maxRefCount) {
+            return convertAlias(node, parent, doc, lineCounter);
+        }
+        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 jsonDocument_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 jsonDocument_1.PropertyASTNodeImpl(parent, node, ...toFixedOffsetLength([rangeStart, rangeEnd, nodeEnd], lineCounter));
+        if ((0, yaml_1.isAlias)(keyNode)) {
+            const keyAlias = new jsonDocument_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 jsonDocument_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 jsonDocument_1.NullASTNodeImpl(parent, node, ...toOffsetLength(node.range));
+        }
+        switch (typeof node.value) {
+            case 'string': {
+                const result = new jsonDocument_1.StringASTNodeImpl(parent, node, ...toOffsetLength(node.range));
+                result.value = node.value;
+                return result;
+            }
+            case 'boolean':
+                return new jsonDocument_1.BooleanASTNodeImpl(parent, node, node.value, node.source, ...toOffsetLength(node.range));
+            case 'number': {
+                const result = new jsonDocument_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 jsonDocument_1.StringASTNodeImpl(parent, node, ...toOffsetLength(node.range));
+                result.value = node.source;
+                return result;
+            }
+        }
+    }
+    function convertAlias(node, parent, doc, lineCounter) {
+        if (exports.aliasDepth.aliasResolutionCache.has(node)) {
+            return exports.aliasDepth.aliasResolutionCache.get(node);
+        }
+        exports.aliasDepth.currentRefDepth++;
+        const resolvedNode = node.resolve(doc);
+        let ans;
+        if (resolvedNode) {
+            ans = convertAST(parent, resolvedNode, doc, lineCounter);
+        }
+        else {
+            const resultNode = new jsonDocument_1.StringASTNodeImpl(parent, node, ...toOffsetLength(node.range));
+            resultNode.value = node.source;
+            ans = resultNode;
+        }
+        exports.aliasDepth.currentRefDepth--;
+        exports.aliasDepth.aliasResolutionCache.set(node, ans);
+        return ans;
+    }
+    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/astNodeUtils.d.ts

@@ -0,0 +1,4 @@
+import type { ASTNode } from '../jsonASTTypes';
+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;

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

@@ -0,0 +1,64 @@
+(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.findNodeAtOffset = exports.contains = exports.getNodeValue = void 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    function getNodeValue(node) {
+        switch (node.type) {
+            case 'array':
+                return node.children.map(getNodeValue);
+            case 'object': {
+                const obj = Object.create(null);
+                for (let _i = 0, _a = node.children; _i < _a.length; _i++) {
+                    const prop = _a[_i];
+                    const valueNode = prop.children[1];
+                    if (valueNode) {
+                        obj[prop.children[0].value] = getNodeValue(valueNode);
+                    }
+                }
+                return obj;
+            }
+            case 'null':
+            case 'string':
+            case 'number':
+                return node.value;
+            case 'boolean':
+                return node.source;
+            default:
+                return undefined;
+        }
+    }
+    exports.getNodeValue = getNodeValue;
+    function contains(node, offset, includeRightBound = false) {
+        return ((offset >= node.offset && offset <= node.offset + node.length) || (includeRightBound && offset === node.offset + node.length));
+    }
+    exports.contains = contains;
+    function findNodeAtOffset(node, offset, includeRightBound) {
+        if (includeRightBound === void 0) {
+            includeRightBound = false;
+        }
+        if (contains(node, offset, includeRightBound)) {
+            const children = node.children;
+            if (Array.isArray(children)) {
+                for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
+                    const item = findNodeAtOffset(children[i], offset, includeRightBound);
+                    if (item) {
+                        return item;
+                    }
+                }
+            }
+            return node;
+        }
+        return undefined;
+    }
+    exports.findNodeAtOffset = findNodeAtOffset;
+});
+//# sourceMappingURL=astNodeUtils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"astNodeUtils.js","sourceRoot":"","sources":["../../../../src/languageservice/parser/astNodeUtils.ts"],"names":[],"mappings":";;;;;;;;;;;;IAEA,8DAA8D;IAC9D,SAAgB,YAAY,CAAC,IAAa;QACxC,QAAQ,IAAI,CAAC,IAAI,EAAE;YACjB,KAAK,OAAO;gBACV,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YACzC,KAAK,QAAQ,CAAC,CAAC;gBACb,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBAChC,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,EAAE,GAAG,EAAE,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE;oBACzD,MAAM,IAAI,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;oBACpB,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;oBACnC,IAAI,SAAS,EAAE;wBACb,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAe,CAAC,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;qBACjE;iBACF;gBACD,OAAO,GAAG,CAAC;aACZ;YACD,KAAK,MAAM,CAAC;YACZ,KAAK,QAAQ,CAAC;YACd,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,KAAK,CAAC;YACpB,KAAK,SAAS;gBACZ,OAAO,IAAI,CAAC,MAAM,CAAC;YACrB;gBACE,OAAO,SAAS,CAAC;SACpB;IACH,CAAC;IAxBD,oCAwBC;IAED,SAAgB,QAAQ,CAAC,IAAa,EAAE,MAAc,EAAE,iBAAiB,GAAG,KAAK;QAC/E,OAAO,CACL,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,IAAI,MAAM,IAAI,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,iBAAiB,IAAI,MAAM,KAAK,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,CAC9H,CAAC;IACJ,CAAC;IAJD,4BAIC;IAED,SAAgB,gBAAgB,CAAC,IAAa,EAAE,MAAc,EAAE,iBAA0B;QACxF,IAAI,iBAAiB,KAAK,KAAK,CAAC,EAAE;YAChC,iBAAiB,GAAG,KAAK,CAAC;SAC3B;QACD,IAAI,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE;YAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;YAC/B,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,MAAM,EAAE,CAAC,EAAE,EAAE;oBACxE,MAAM,IAAI,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,CAAC;oBACtE,IAAI,IAAI,EAAE;wBACR,OAAO,IAAI,CAAC;qBACb;iBACF;aACF;YACD,OAAO,IAAI,CAAC;SACb;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAjBD,4CAiBC"}

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 './jsonDocument';
+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", "../utils/filePatternAssociation"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isKubernetesAssociatedDocument = exports.setKubernetesParserOption = void 0;
+    const filePatternAssociation_1 = require("../utils/filePatternAssociation");
+    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 filePatternAssociation_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,4EAAyE;IAGzE,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,+CAAsB,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/jsonDocument.d.ts

@@ -0,0 +1,83 @@
+import { JSONSchema } from '../jsonSchema';
+import { ASTNode, ObjectASTNode, ArrayASTNode, BooleanASTNode, NumberASTNode, StringASTNode, NullASTNode, PropertyASTNode, YamlNode } from '../jsonASTTypes';
+import { Diagnostic, Range } from 'vscode-languageserver-types';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { Node, Pair } from 'yaml';
+import { type IApplicableSchema } from './schemaValidation/baseValidator';
+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;
+    source: string;
+    constructor(parent: ASTNode, internalNode: Node, boolValue: boolean, boolSource: string, 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 interface JSONDocumentConfig {
+    collectComments?: boolean;
+}
+export declare enum EnumMatch {
+    Key = 0,
+    Enum = 1
+}
+export declare function newJSONDocument(root: ASTNode, diagnostics?: Diagnostic[]): JSONDocument;
+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[];
+    getMatchingSchemas(schema: JSONSchema, focusOffset?: number, exclude?: ASTNode, didCallFromAutoComplete?: boolean): IApplicableSchema[];
+}
+export {};

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

@@ -0,0 +1,193 @@
+(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", "./astNodeUtils", "./schemaValidation/validatorFactory"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JSONDocument = exports.newJSONDocument = exports.EnumMatch = exports.ObjectASTNodeImpl = exports.PropertyASTNodeImpl = exports.StringASTNodeImpl = exports.NumberASTNodeImpl = exports.ArrayASTNodeImpl = exports.BooleanASTNodeImpl = exports.NullASTNodeImpl = void 0;
+    const astNodeUtils_1 = require("./astNodeUtils");
+    const validatorFactory_1 = require("./schemaValidation/validatorFactory");
+    class ASTNodeImpl {
+        constructor(parent, internalNode, offset, length) {
+            this.offset = offset;
+            this.length = length;
+            this.parent = parent;
+            this.internalNode = internalNode;
+        }
+        getNodeFromOffsetEndInclusive(offset) {
+            const collector = [];
+            const findNode = (node) => {
+                if (offset >= node.offset && offset <= node.offset + node.length) {
+                    const children = node.children;
+                    for (let i = 0; i < children.length && children[i].offset <= offset; i++) {
+                        const item = findNode(children[i]);
+                        if (item) {
+                            collector.push(item);
+                        }
+                    }
+                    return node;
+                }
+                return null;
+            };
+            const foundNode = findNode(this);
+            let currMinDist = Number.MAX_VALUE;
+            let currMinNode = null;
+            for (const currNode of collector) {
+                const minDist = currNode.length + currNode.offset - offset + (offset - currNode.offset);
+                if (minDist < currMinDist) {
+                    currMinNode = currNode;
+                    currMinDist = minDist;
+                }
+            }
+            return currMinNode || foundNode;
+        }
+        get children() {
+            return [];
+        }
+        toString() {
+            return ('type: ' +
+                this.type +
+                ' (' +
+                this.offset +
+                '/' +
+                this.length +
+                ')' +
+                (this.parent ? ' parent: {' + this.parent.toString() + '}' : ''));
+        }
+    }
+    class NullASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, internalNode, offset, length) {
+            super(parent, internalNode, offset, length);
+            this.type = 'null';
+            this.value = null;
+        }
+    }
+    exports.NullASTNodeImpl = NullASTNodeImpl;
+    class BooleanASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, internalNode, boolValue, boolSource, offset, length) {
+            super(parent, internalNode, offset, length);
+            this.type = 'boolean';
+            this.value = boolValue;
+            this.source = boolSource;
+        }
+    }
+    exports.BooleanASTNodeImpl = BooleanASTNodeImpl;
+    class ArrayASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, internalNode, offset, length) {
+            super(parent, internalNode, offset, length);
+            this.type = 'array';
+            this.items = [];
+        }
+        get children() {
+            return this.items;
+        }
+    }
+    exports.ArrayASTNodeImpl = ArrayASTNodeImpl;
+    class NumberASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, internalNode, offset, length) {
+            super(parent, internalNode, offset, length);
+            this.type = 'number';
+            this.isInteger = true;
+            this.value = Number.NaN;
+        }
+    }
+    exports.NumberASTNodeImpl = NumberASTNodeImpl;
+    class StringASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, internalNode, offset, length) {
+            super(parent, internalNode, offset, length);
+            this.type = 'string';
+            this.value = '';
+        }
+    }
+    exports.StringASTNodeImpl = StringASTNodeImpl;
+    class PropertyASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, internalNode, offset, length) {
+            super(parent, internalNode, offset, length);
+            this.type = 'property';
+            this.colonOffset = -1;
+        }
+        get children() {
+            return this.valueNode ? [this.keyNode, this.valueNode] : [this.keyNode];
+        }
+    }
+    exports.PropertyASTNodeImpl = PropertyASTNodeImpl;
+    class ObjectASTNodeImpl extends ASTNodeImpl {
+        constructor(parent, internalNode, offset, length) {
+            super(parent, internalNode, offset, length);
+            this.type = 'object';
+            this.properties = [];
+        }
+        get children() {
+            return this.properties;
+        }
+    }
+    exports.ObjectASTNodeImpl = ObjectASTNodeImpl;
+    var EnumMatch;
+    (function (EnumMatch) {
+        EnumMatch[EnumMatch["Key"] = 0] = "Key";
+        EnumMatch[EnumMatch["Enum"] = 1] = "Enum";
+    })(EnumMatch = exports.EnumMatch || (exports.EnumMatch = {}));
+    function newJSONDocument(root, diagnostics = []) {
+        return new JSONDocument(root, diagnostics, []);
+    }
+    exports.newJSONDocument = newJSONDocument;
+    class JSONDocument {
+        constructor(root, syntaxErrors = [], comments = []) {
+            this.root = root;
+            this.syntaxErrors = syntaxErrors;
+            this.comments = comments;
+        }
+        getNodeFromOffset(offset, includeRightBound = false) {
+            if (this.root) {
+                return (0, astNodeUtils_1.findNodeAtOffset)(this.root, offset, includeRightBound);
+            }
+            return undefined;
+        }
+        getNodeFromOffsetEndInclusive(offset) {
+            return this.root && this.root.getNodeFromOffsetEndInclusive(offset);
+        }
+        visit(visitor) {
+            if (this.root) {
+                const doVisit = (node) => {
+                    let ctn = visitor(node);
+                    const children = node.children;
+                    if (Array.isArray(children)) {
+                        for (let i = 0; i < children.length && ctn; i++) {
+                            ctn = doVisit(children[i]);
+                        }
+                    }
+                    return ctn;
+                };
+                doVisit(this.root);
+            }
+        }
+        validate(textDocument, schema) {
+            if (!this.root || !schema)
+                return null;
+            const validator = (0, validatorFactory_1.getValidator)(schema._dialect);
+            return validator.validateDocument(this.root, textDocument, schema, {
+                isKubernetes: this.isKubernetes,
+                disableAdditionalProperties: this.disableAdditionalProperties,
+                uri: this.uri,
+            });
+        }
+        getMatchingSchemas(schema, focusOffset = -1, exclude = null, didCallFromAutoComplete) {
+            if (!this.root || !schema)
+                return [];
+            const validator = (0, validatorFactory_1.getValidator)(schema._dialect);
+            return validator.getMatchingSchemas(this.root, schema, {
+                isKubernetes: this.isKubernetes,
+                disableAdditionalProperties: this.disableAdditionalProperties,
+                uri: this.uri,
+                callFromAutoComplete: didCallFromAutoComplete,
+            }, focusOffset, exclude);
+        }
+    }
+    exports.JSONDocument = JSONDocument;
+});
+//# sourceMappingURL=jsonDocument.js.map

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/schemaValidation/baseValidator.d.ts

@@ -0,0 +1,124 @@
+import type { JSONSchema, JSONSchemaRef, SchemaDialect } from '../../jsonSchema';
+import type { ASTNode, ArrayASTNode, NumberASTNode, ObjectASTNode, StringASTNode } from '../../jsonASTTypes';
+import { ErrorCode } from 'vscode-json-languageservice';
+import { Diagnostic, DiagnosticSeverity } from 'vscode-languageserver-types';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+export declare const YAML_SOURCE = "YAML";
+export interface IRange {
+    offset: number;
+    length: number;
+}
+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 interface IApplicableSchema {
+    node: ASTNode;
+    inverted?: boolean;
+    schema: JSONSchema;
+}
+export interface ISchemaCollector {
+    schemas: IApplicableSchema[];
+    add(schema: IApplicableSchema): void;
+    merge(other: ISchemaCollector): void;
+    include(node: ASTNode): boolean;
+    newSub(): ISchemaCollector;
+}
+export declare const formats: Record<string, {
+    errorMessage: string;
+    pattern: RegExp;
+}>;
+export declare class ValidationResult {
+    problems: IProblem[];
+    propertiesMatches: number;
+    propertiesValueMatches: number;
+    primaryValueMatches: number;
+    enumValueMatch: boolean;
+    enumValues: any[];
+    /**
+     * Optional bookkeeping for newer drafts (2019/2020).
+     * BaseValidator only populates evaluatedProperties conservatively for object keywords it processes directly.
+     */
+    evaluatedProperties?: Set<string>;
+    evaluatedItemsByNode?: Map<ASTNode, Set<number>>;
+    constructor(isKubernetes: boolean);
+    getEvaluatedItems(node: ASTNode): Set<number>;
+    hasProblems(): boolean;
+    merge(other: ValidationResult): void;
+    mergeEnumValues(other: ValidationResult): void;
+    mergeWarningGeneric(sub: ValidationResult, problemTypesToMerge: ProblemType[]): void;
+    mergePropertyMatch(propertyValidationResult: ValidationResult, mergeEvaluated?: boolean): void;
+    private mergeSources;
+    compareGeneric(other: ValidationResult): number;
+    compareKubernetes(other: ValidationResult): number;
+}
+export interface Options {
+    isKubernetes: boolean;
+    disableAdditionalProperties: boolean;
+    uri: string;
+    callFromAutoComplete?: boolean;
+}
+interface IValidationMatch {
+    schema: JSONSchema;
+    validationResult: ValidationResult;
+    matchingSchemas: ISchemaCollector;
+}
+export declare abstract class BaseValidator {
+    protected collectSeenKeys(node: ObjectASTNode): Record<string, ASTNode>;
+    validateDocument(root: ASTNode, textDocument: TextDocument, schema: JSONSchema, options: Options): Diagnostic[];
+    getMatchingSchemas(root: ASTNode, schema: JSONSchema, options: Options, focusOffset: number, exclude: ASTNode | null): IApplicableSchema[];
+    protected getNoOpCollector(): ISchemaCollector;
+    protected getSchemaSource(schema: JSONSchema, originalSchema: JSONSchema): string;
+    protected getSchemaUri(schema: JSONSchema, originalSchema: JSONSchema): string[];
+    /**
+     * Draft-specific hook: interpret numeric bounds in the draft’s way.
+     * - Draft07+: numeric exclusiveMinimum/exclusiveMaximum
+     * - Draft04: boolean exclusiveMinimum/exclusiveMaximum that modify minimum/maximum
+     */
+    protected abstract getNumberLimits(schema: JSONSchema): {
+        minimum?: number;
+        maximum?: number;
+        exclusiveMinimum?: number;
+        exclusiveMaximum?: number;
+    };
+    /**
+     * Get the current validator's dialect.
+     */
+    protected abstract getCurrentDialect(): SchemaDialect;
+    protected validateNode(node: ASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options): void;
+    protected validateGenericNode(node: ASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options): void;
+    protected validateStringNode(node: StringASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult): void;
+    protected validateNumberNode(node: NumberASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult): void;
+    protected validateArrayNode(node: ArrayASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options): void;
+    protected applyContains(node: ArrayASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, _matchingSchemas: ISchemaCollector, options: Options): void;
+    protected applyArrayLength(node: ArrayASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, _options: Options): void;
+    protected applyUniqueItems(node: ArrayASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult): void;
+    protected validateObjectNode(node: ObjectASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options): void;
+    protected applyRequired(node: ObjectASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, _options: Options, seenKeys: Record<string, ASTNode>): void;
+    protected applyProperties(_node: ObjectASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options, seenKeys: Record<string, ASTNode>, _unprocessedProperties: string[], propertyProcessed: (prop: string) => void): void;
+    protected applyPatternProperties(_node: ObjectASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options, seenKeys: Record<string, ASTNode>, unprocessedProperties: string[], propertyProcessed: (prop: string) => void): void;
+    protected applyAdditionalProperties(_node: ObjectASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options, seenKeys: Record<string, ASTNode>, unprocessedProperties: string[]): void;
+    protected applyPropertyCount(node: ObjectASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult): void;
+    protected applyDependencies(node: ObjectASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options, seenKeys: Record<string, ASTNode>): void;
+    protected applyPropertyNames(node: ObjectASTNode, schema: JSONSchema, validationResult: ValidationResult, options: Options): void;
+    protected applyUnevaluatedProperties(_node: ObjectASTNode, _schema: JSONSchema, _originalSchema: JSONSchema, _validationResult: ValidationResult, _matchingSchemas: ISchemaCollector, _options: Options, _seenKeys?: Record<string, ASTNode>, _unprocessedProperties?: string[]): void;
+    protected applyUnevaluatedItems(_node: ArrayASTNode | ASTNode, _schema: JSONSchema, _originalSchema: JSONSchema, _validationResult: ValidationResult, _matchingSchemas: ISchemaCollector, _options: Options): void;
+    protected alternativeComparison(subValidationResult: ValidationResult, bestMatch: IValidationMatch, subSchema: JSONSchema, subMatchingSchemas: ISchemaCollector): IValidationMatch;
+    protected genericComparison(node: ASTNode, maxOneMatch: boolean, subValidationResult: ValidationResult, bestMatch: IValidationMatch, subSchema: JSONSchema, subMatchingSchemas: ISchemaCollector): IValidationMatch;
+    protected mergeValidationMatches(bestMatch: IValidationMatch, subMatchingSchemas: ISchemaCollector, subValidationResult: ValidationResult): void;
+}
+export declare function asSchema(schema: JSONSchemaRef): JSONSchema | undefined;
+export {};

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

@@ -0,0 +1,17 @@
+import type { JSONSchema } from '../../jsonSchema';
+import { SchemaDialect } from '../../jsonSchema';
+import { BaseValidator } from './baseValidator';
+export declare class Draft04Validator extends BaseValidator {
+    protected getCurrentDialect(): SchemaDialect;
+    /**
+     * Keyword: exclusiveMinimum/exclusiveMaximum
+     *
+     * Booleans that make minimum/maximum exclusive.
+     */
+    protected getNumberLimits(schema: JSONSchema): {
+        minimum?: number;
+        maximum?: number;
+        exclusiveMinimum?: number;
+        exclusiveMaximum?: number;
+    };
+}

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

@@ -0,0 +1,44 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) IBM 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", "../../jsonSchema", "../../utils/objects", "./baseValidator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Draft04Validator = void 0;
+    const jsonSchema_1 = require("../../jsonSchema");
+    const objects_1 = require("../../utils/objects");
+    const baseValidator_1 = require("./baseValidator");
+    class Draft04Validator extends baseValidator_1.BaseValidator {
+        getCurrentDialect() {
+            return jsonSchema_1.SchemaDialect.draft04;
+        }
+        /**
+         * Keyword: exclusiveMinimum/exclusiveMaximum
+         *
+         * Booleans that make minimum/maximum exclusive.
+         */
+        getNumberLimits(schema) {
+            const minimum = (0, objects_1.isNumber)(schema.minimum) ? schema.minimum : undefined;
+            const maximum = (0, objects_1.isNumber)(schema.maximum) ? schema.maximum : undefined;
+            const exclusiveMinimum = (0, objects_1.isBoolean)(schema.exclusiveMinimum) && schema.exclusiveMinimum ? minimum : undefined;
+            const exclusiveMaximum = (0, objects_1.isBoolean)(schema.exclusiveMaximum) && schema.exclusiveMaximum ? maximum : undefined;
+            return {
+                minimum: exclusiveMinimum === undefined ? minimum : undefined,
+                maximum: exclusiveMaximum === undefined ? maximum : undefined,
+                exclusiveMinimum,
+                exclusiveMaximum,
+            };
+        }
+    }
+    exports.Draft04Validator = Draft04Validator;
+});
+//# sourceMappingURL=draft04Validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"draft04Validator.js","sourceRoot":"","sources":["../../../../../src/languageservice/parser/schemaValidation/draft04Validator.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAGhG,iDAAiD;IACjD,iDAA0D;IAC1D,mDAAgD;IAEhD,MAAa,gBAAiB,SAAQ,6BAAa;QAC9B,iBAAiB;YAClC,OAAO,0BAAa,CAAC,OAAO,CAAC;QAC/B,CAAC;QAED;;;;WAIG;QACgB,eAAe,CAAC,MAAkB;YAMnD,MAAM,OAAO,GAAG,IAAA,kBAAQ,EAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;YACtE,MAAM,OAAO,GAAG,IAAA,kBAAQ,EAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;YAEtE,MAAM,gBAAgB,GAAG,IAAA,mBAAS,EAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;YAC7G,MAAM,gBAAgB,GAAG,IAAA,mBAAS,EAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;YAE7G,OAAO;gBACL,OAAO,EAAE,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;gBAC7D,OAAO,EAAE,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;gBAC7D,gBAAgB;gBAChB,gBAAgB;aACjB,CAAC;QACJ,CAAC;KACF;IA7BD,4CA6BC"}

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

@@ -0,0 +1,15 @@
+import type { JSONSchema } from '../../jsonSchema';
+import { SchemaDialect } from '../../jsonSchema';
+import { BaseValidator } from './baseValidator';
+export declare class Draft07Validator extends BaseValidator {
+    protected getCurrentDialect(): SchemaDialect;
+    /**
+     * Keyword: exclusiveMinimum/exclusiveMaximum are treated as numeric bounds
+     */
+    protected getNumberLimits(schema: JSONSchema): {
+        minimum?: number;
+        maximum?: number;
+        exclusiveMinimum?: number;
+        exclusiveMaximum?: number;
+    };
+}

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

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) IBM 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", "../../jsonSchema", "../../utils/objects", "./baseValidator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Draft07Validator = void 0;
+    const jsonSchema_1 = require("../../jsonSchema");
+    const objects_1 = require("../../utils/objects");
+    const baseValidator_1 = require("./baseValidator");
+    class Draft07Validator extends baseValidator_1.BaseValidator {
+        getCurrentDialect() {
+            return jsonSchema_1.SchemaDialect.draft07;
+        }
+        /**
+         * Keyword: exclusiveMinimum/exclusiveMaximum are treated as numeric bounds
+         */
+        getNumberLimits(schema) {
+            const minimum = (0, objects_1.isNumber)(schema.minimum) ? schema.minimum : undefined;
+            const maximum = (0, objects_1.isNumber)(schema.maximum) ? schema.maximum : undefined;
+            const exclusiveMinimum = (0, objects_1.isNumber)(schema.exclusiveMinimum) ? schema.exclusiveMinimum : undefined;
+            const exclusiveMaximum = (0, objects_1.isNumber)(schema.exclusiveMaximum) ? schema.exclusiveMaximum : undefined;
+            return {
+                minimum: exclusiveMinimum === undefined ? minimum : undefined,
+                maximum: exclusiveMaximum === undefined ? maximum : undefined,
+                exclusiveMinimum,
+                exclusiveMaximum,
+            };
+        }
+    }
+    exports.Draft07Validator = Draft07Validator;
+});
+//# sourceMappingURL=draft07Validator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"draft07Validator.js","sourceRoot":"","sources":["../../../../../src/languageservice/parser/schemaValidation/draft07Validator.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAGhG,iDAAiD;IACjD,iDAA+C;IAC/C,mDAAgD;IAEhD,MAAa,gBAAiB,SAAQ,6BAAa;QAC9B,iBAAiB;YAClC,OAAO,0BAAa,CAAC,OAAO,CAAC;QAC/B,CAAC;QAED;;WAEG;QACO,eAAe,CAAC,MAAkB;YAM1C,MAAM,OAAO,GAAG,IAAA,kBAAQ,EAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;YACtE,MAAM,OAAO,GAAG,IAAA,kBAAQ,EAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;YAEtE,MAAM,gBAAgB,GAAG,IAAA,kBAAQ,EAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC;YACjG,MAAM,gBAAgB,GAAG,IAAA,kBAAQ,EAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC;YAEjG,OAAO;gBACL,OAAO,EAAE,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;gBAC7D,OAAO,EAAE,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS;gBAC7D,gBAAgB;gBAChB,gBAAgB;aACjB,CAAC;QACJ,CAAC;KACF;IA3BD,4CA2BC"}

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

@@ -0,0 +1,28 @@
+import type { JSONSchema } from '../../jsonSchema';
+import { SchemaDialect } from '../../jsonSchema';
+import type { ASTNode, ArrayASTNode, ObjectASTNode } from '../../jsonASTTypes';
+import { Draft07Validator } from './draft07Validator';
+import { ValidationResult } from './baseValidator';
+import type { ISchemaCollector, Options } from './baseValidator';
+export declare class Draft2019Validator extends Draft07Validator {
+    protected getCurrentDialect(): SchemaDialect;
+    /**
+     * Keyword: contains + minContains/maxContains
+     *
+     * Draft-07 behavior: contains must match at least 1 item.
+     * Draft-2019-09 behavior: minContains/maxContains constrain how many matches are required/allowed.
+     */
+    protected applyContains(node: ArrayASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, _matchingSchemas: ISchemaCollector, options: Options): void;
+    /**
+     * Keyword: dependentRequired + dependentSchemas.
+     */
+    protected applyDependencies(node: ObjectASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options, seenKeys: Record<string, ASTNode>): void;
+    /**
+     * Keyword: unevaluatedProperties
+     */
+    protected applyUnevaluatedProperties(node: ObjectASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options, seenKeys?: Record<string, ASTNode>): void;
+    /**
+     * Keyword: unevaluatedItems
+     */
+    protected applyUnevaluatedItems(node: ArrayASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options): void;
+}

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

@@ -0,0 +1,238 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) IBM 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", "../../jsonSchema", "../../utils/objects", "@vscode/l10n", "vscode-languageserver-types", "vscode-json-languageservice", "./draft07Validator", "./baseValidator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Draft2019Validator = void 0;
+    const jsonSchema_1 = require("../../jsonSchema");
+    const objects_1 = require("../../utils/objects");
+    const l10n = require("@vscode/l10n");
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const vscode_json_languageservice_1 = require("vscode-json-languageservice");
+    const draft07Validator_1 = require("./draft07Validator");
+    const baseValidator_1 = require("./baseValidator");
+    class Draft2019Validator extends draft07Validator_1.Draft07Validator {
+        getCurrentDialect() {
+            return jsonSchema_1.SchemaDialect.draft2019;
+        }
+        /**
+         * Keyword: contains + minContains/maxContains
+         *
+         * Draft-07 behavior: contains must match at least 1 item.
+         * Draft-2019-09 behavior: minContains/maxContains constrain how many matches are required/allowed.
+         */
+        applyContains(node, schema, originalSchema, validationResult, _matchingSchemas, options) {
+            const containsSchema = (0, baseValidator_1.asSchema)(schema.contains);
+            if (!containsSchema)
+                return;
+            const minContainsRaw = schema.minContains;
+            const maxContainsRaw = schema.maxContains;
+            const minContains = (0, objects_1.isNumber)(minContainsRaw) ? minContainsRaw : 1;
+            const maxContains = (0, objects_1.isNumber)(maxContainsRaw) ? maxContainsRaw : undefined;
+            let matchCount = 0;
+            const items = (node.items ?? []);
+            for (const item of items) {
+                const itemValidationResult = new baseValidator_1.ValidationResult(options.isKubernetes);
+                this.validateNode(item, containsSchema, schema, itemValidationResult, this.getNoOpCollector(), options);
+                if (!itemValidationResult.hasProblems()) {
+                    matchCount++;
+                    if (maxContains !== undefined && matchCount > maxContains) {
+                        break;
+                    }
+                }
+            }
+            if (matchCount < minContains) {
+                validationResult.problems.push({
+                    location: { offset: node.offset, length: node.length },
+                    severity: vscode_languageserver_types_1.DiagnosticSeverity.Warning,
+                    message: schema.errorMessage || l10n.t('Array has too few items matching "contains". Expected {0} or more.', minContains),
+                    source: this.getSchemaSource(schema, originalSchema),
+                    schemaUri: this.getSchemaUri(schema, originalSchema),
+                });
+            }
+            if (maxContains !== undefined && matchCount > maxContains) {
+                validationResult.problems.push({
+                    location: { offset: node.offset, length: node.length },
+                    severity: vscode_languageserver_types_1.DiagnosticSeverity.Warning,
+                    message: schema.errorMessage || l10n.t('Array has too many items matching "contains". Expected {0} or fewer.', maxContains),
+                    source: this.getSchemaSource(schema, originalSchema),
+                    schemaUri: this.getSchemaUri(schema, originalSchema),
+                });
+            }
+        }
+        /**
+         * Keyword: dependentRequired + dependentSchemas.
+         */
+        applyDependencies(node, schema, originalSchema, validationResult, matchingSchemas, options, seenKeys) {
+            // keep draft-07 dependencies support
+            super.applyDependencies(node, schema, originalSchema, validationResult, matchingSchemas, options, seenKeys);
+            const dependentRequired = schema.dependentRequired;
+            if (dependentRequired && typeof dependentRequired === 'object') {
+                for (const prop of Object.keys(dependentRequired)) {
+                    if (!seenKeys[prop])
+                        continue;
+                    const requiredProps = dependentRequired[prop];
+                    if (!Array.isArray(requiredProps))
+                        continue;
+                    for (const requiredProp of requiredProps) {
+                        if (!seenKeys[requiredProp]) {
+                            validationResult.problems.push({
+                                location: { offset: node.offset, length: node.length },
+                                severity: vscode_languageserver_types_1.DiagnosticSeverity.Warning,
+                                message: l10n.t('Object is missing property {0} required by property {1}.', requiredProp, prop),
+                                source: this.getSchemaSource(schema, originalSchema),
+                                schemaUri: this.getSchemaUri(schema, originalSchema),
+                            });
+                        }
+                        else {
+                            validationResult.propertiesValueMatches++;
+                        }
+                    }
+                }
+            }
+            const dependentSchemas = schema.dependentSchemas;
+            if (dependentSchemas && typeof dependentSchemas === 'object') {
+                for (const prop of Object.keys(dependentSchemas)) {
+                    if (!seenKeys[prop])
+                        continue;
+                    const depSchema = (0, baseValidator_1.asSchema)(dependentSchemas[prop]);
+                    if (!depSchema)
+                        continue;
+                    const depValidationResult = new baseValidator_1.ValidationResult(options.isKubernetes);
+                    this.validateNode(node, depSchema, schema, depValidationResult, matchingSchemas, options);
+                    validationResult.mergePropertyMatch(depValidationResult);
+                    validationResult.mergeEnumValues(depValidationResult);
+                }
+            }
+        }
+        /**
+         * Keyword: unevaluatedProperties
+         */
+        applyUnevaluatedProperties(node, schema, originalSchema, validationResult, matchingSchemas, options, seenKeys) {
+            const unevaluated = schema.unevaluatedProperties;
+            if (unevaluated === undefined)
+                return;
+            if (!seenKeys)
+                return;
+            // ensure evaluatedProperties exists
+            validationResult.evaluatedProperties ?? (validationResult.evaluatedProperties = new Set());
+            // remaining = properties not evaluated by properties/patternProperties/additionalProperties
+            const remaining = Object.keys(seenKeys).filter((name) => !validationResult.evaluatedProperties?.has(name));
+            if (remaining.length === 0)
+                return;
+            // unevaluatedProperties: false => forbid remaining properties
+            if (unevaluated === false) {
+                for (const propName of remaining) {
+                    const child = seenKeys[propName];
+                    if (!child)
+                        continue;
+                    const propertyNode = child.type === 'property' ? child : child.parent;
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const keyNode = propertyNode.keyNode;
+                    if (!keyNode)
+                        continue;
+                    validationResult.problems.push({
+                        location: { offset: keyNode.offset, length: keyNode.length },
+                        severity: vscode_languageserver_types_1.DiagnosticSeverity.Warning,
+                        code: vscode_json_languageservice_1.ErrorCode.PropertyExpected,
+                        message: schema.errorMessage || l10n.t('Property {0} is not allowed.', propName),
+                        source: this.getSchemaSource(schema, originalSchema),
+                        schemaUri: this.getSchemaUri(schema, originalSchema),
+                    });
+                    validationResult.evaluatedProperties?.add(propName);
+                }
+                return;
+            }
+            // unevaluatedProperties: true => allow anything remaining, but mark evaluated
+            if (unevaluated === true) {
+                for (const propName of remaining) {
+                    validationResult.evaluatedProperties?.add(propName);
+                }
+                return;
+            }
+            // unevaluatedProperties: <schema> => validate value of each remaining property
+            const unevaluatedSchema = (0, baseValidator_1.asSchema)(unevaluated);
+            if (!unevaluatedSchema)
+                return;
+            for (const propName of remaining) {
+                const child = seenKeys[propName];
+                if (!child)
+                    continue;
+                const valueNode = child.type === 'property' ? child.valueNode : child;
+                if (!valueNode)
+                    continue;
+                const subResult = new baseValidator_1.ValidationResult(options.isKubernetes);
+                this.validateNode(valueNode, unevaluatedSchema, schema, subResult, matchingSchemas, options);
+                validationResult.mergePropertyMatch(subResult);
+                validationResult.mergeEnumValues(subResult);
+                validationResult.evaluatedProperties?.add(propName);
+            }
+        }
+        /**
+         * Keyword: unevaluatedItems
+         */
+        applyUnevaluatedItems(node, schema, originalSchema, validationResult, matchingSchemas, options) {
+            const unevaluated = schema.unevaluatedItems;
+            if (unevaluated === undefined)
+                return;
+            const items = (node.items ?? []);
+            if (items.length === 0)
+                return;
+            const evaluated = validationResult.getEvaluatedItems(node);
+            const remaining = [];
+            for (let i = 0; i < items.length; i++) {
+                if (!evaluated.has(i))
+                    remaining.push(i);
+            }
+            if (remaining.length === 0)
+                return;
+            // unevaluatedItems: false => forbid remaining indices
+            if (unevaluated === false) {
+                for (const idx of remaining) {
+                    const item = items[idx];
+                    validationResult.problems.push({
+                        location: { offset: item.offset, length: item.length || 1 },
+                        severity: vscode_languageserver_types_1.DiagnosticSeverity.Warning,
+                        code: vscode_json_languageservice_1.ErrorCode.PropertyExpected,
+                        message: schema.errorMessage || l10n.t('Array has too many items according to schema. Expected {0} or fewer.', idx),
+                        source: this.getSchemaSource(schema, originalSchema),
+                        schemaUri: this.getSchemaUri(schema, originalSchema),
+                    });
+                    evaluated.add(idx);
+                }
+                return;
+            }
+            // unevaluatedItems: true => allow everything remaining, but mark evaluated
+            if (unevaluated === true) {
+                for (const idx of remaining)
+                    evaluated.add(idx);
+                return;
+            }
+            // unevaluatedItems: <schema> => validate remaining items against that schema
+            const unevaluatedSchema = (0, baseValidator_1.asSchema)(unevaluated);
+            if (!unevaluatedSchema)
+                return;
+            for (const idx of remaining) {
+                const item = items[idx];
+                const subResult = new baseValidator_1.ValidationResult(options.isKubernetes);
+                // validate the item node with the unevaluatedItems subschema
+                this.validateNode(item, unevaluatedSchema, schema, subResult, matchingSchemas, options);
+                validationResult.merge(subResult);
+                validationResult.mergeEnumValues(subResult);
+                evaluated.add(idx);
+            }
+        }
+    }
+    exports.Draft2019Validator = Draft2019Validator;
+});
+//# sourceMappingURL=draft2019Validator.js.map

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

@@ -0,0 +1,17 @@
+import type { JSONSchema } from '../../jsonSchema';
+import { SchemaDialect } from '../../jsonSchema';
+import type { ArrayASTNode } from '../../jsonASTTypes';
+import { Draft2019Validator } from './draft2019Validator';
+import type { ISchemaCollector, Options } from './baseValidator';
+import { ValidationResult } from './baseValidator';
+export declare class Draft2020Validator extends Draft2019Validator {
+    protected getCurrentDialect(): SchemaDialect;
+    /**
+     * Keyword: prefixItems + items
+     */
+    protected validateArrayNode(node: ArrayASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, matchingSchemas: ISchemaCollector, options: Options): void;
+    /**
+     * Draft 2020-12: contains keyword affects the unevaluatedItems keyword
+     */
+    protected applyContains(node: ArrayASTNode, schema: JSONSchema, originalSchema: JSONSchema, validationResult: ValidationResult, _matchingSchemas: ISchemaCollector, options: Options): void;
+}

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

@@ -0,0 +1,140 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) IBM 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", "../../jsonSchema", "../../utils/objects", "@vscode/l10n", "vscode-languageserver-types", "./draft2019Validator", "./baseValidator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Draft2020Validator = void 0;
+    const jsonSchema_1 = require("../../jsonSchema");
+    const objects_1 = require("../../utils/objects");
+    const l10n = require("@vscode/l10n");
+    const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+    const draft2019Validator_1 = require("./draft2019Validator");
+    const baseValidator_1 = require("./baseValidator");
+    class Draft2020Validator extends draft2019Validator_1.Draft2019Validator {
+        getCurrentDialect() {
+            return jsonSchema_1.SchemaDialect.draft2020;
+        }
+        /**
+         * Keyword: prefixItems + items
+         */
+        validateArrayNode(node, schema, originalSchema, validationResult, matchingSchemas, options) {
+            const items = (node.items ?? []);
+            // prefixItems/items/contains contribute to evaluatedItems
+            const evaluatedItems = validationResult.getEvaluatedItems(node);
+            const prefixItems = schema.prefixItems;
+            // validate prefixItems
+            if (Array.isArray(prefixItems)) {
+                const limit = Math.min(prefixItems.length, items.length);
+                for (let i = 0; i < limit; i++) {
+                    const subSchema = (0, baseValidator_1.asSchema)(prefixItems[i]);
+                    if (!subSchema) {
+                        evaluatedItems.add(i);
+                        continue;
+                    }
+                    const itemValidationResult = new baseValidator_1.ValidationResult(options.isKubernetes);
+                    this.validateNode(items[i], subSchema, schema, itemValidationResult, matchingSchemas, options);
+                    validationResult.mergePropertyMatch(itemValidationResult, false);
+                    validationResult.mergeEnumValues(itemValidationResult);
+                    // mark as evaluated even if invalid (avoids duplicate unevaluatedItems noise)
+                    evaluatedItems.add(i);
+                }
+            }
+            // validate remaining items against items
+            const itemsKeyword = schema.items;
+            const prefixLen = Array.isArray(prefixItems) ? prefixItems.length : 0;
+            if (items.length > prefixLen) {
+                if (itemsKeyword === false) {
+                    // "items": false => no items allowed beyond prefixItems
+                    validationResult.problems.push({
+                        location: { offset: node.offset, length: node.length },
+                        severity: vscode_languageserver_types_1.DiagnosticSeverity.Warning,
+                        message: l10n.t('Array has too many items according to schema. Expected {0} or fewer.', prefixLen),
+                        source: this.getSchemaSource(schema, originalSchema),
+                        schemaUri: this.getSchemaUri(schema, originalSchema),
+                    });
+                    // mark these as evaluated by "items": false (so unevaluatedItems doesn't also complain)
+                    for (let i = prefixLen; i < items.length; i++) {
+                        evaluatedItems.add(i);
+                    }
+                }
+                else {
+                    const tailSchema = (0, baseValidator_1.asSchema)(itemsKeyword);
+                    // if items is undefined, there's no constraint for remaining items and they remain unevaluated
+                    if (tailSchema) {
+                        for (let i = prefixLen; i < items.length; i++) {
+                            const itemValidationResult = new baseValidator_1.ValidationResult(options.isKubernetes);
+                            this.validateNode(items[i], tailSchema, schema, itemValidationResult, matchingSchemas, options);
+                            validationResult.mergePropertyMatch(itemValidationResult, false);
+                            validationResult.mergeEnumValues(itemValidationResult);
+                            // mark as evaluated even if invalid (avoids duplicate unevaluatedItems noise)
+                            evaluatedItems.add(i);
+                        }
+                    }
+                }
+            }
+            // contains enforces min/max and marks matching indices as evaluated
+            this.applyContains(node, schema, originalSchema, validationResult, matchingSchemas, options);
+            // generic array keywords
+            this.applyArrayLength(node, schema, originalSchema, validationResult, options);
+            this.applyUniqueItems(node, schema, originalSchema, validationResult);
+        }
+        /**
+         * Draft 2020-12: contains keyword affects the unevaluatedItems keyword
+         */
+        applyContains(node, schema, originalSchema, validationResult, _matchingSchemas, options) {
+            const containsSchema = (0, baseValidator_1.asSchema)(schema.contains);
+            if (!containsSchema)
+                return;
+            const items = (node.items ?? []);
+            const minContainsRaw = schema.minContains;
+            const maxContainsRaw = schema.maxContains;
+            const minContains = (0, objects_1.isNumber)(minContainsRaw) ? minContainsRaw : 1;
+            const maxContains = (0, objects_1.isNumber)(maxContainsRaw) ? maxContainsRaw : undefined;
+            let matchCount = 0;
+            // ensure evaluatedItems exists
+            const evaluatedItems = validationResult.getEvaluatedItems(node);
+            for (let i = 0; i < items.length; i++) {
+                const itemValidationResult = new baseValidator_1.ValidationResult(options.isKubernetes);
+                this.validateNode(items[i], containsSchema, schema, itemValidationResult, this.getNoOpCollector(), options);
+                if (!itemValidationResult.hasProblems()) {
+                    // items that match contains are considered evaluated
+                    evaluatedItems.add(i);
+                    matchCount++;
+                    if (maxContains !== undefined && matchCount > maxContains) {
+                        break;
+                    }
+                }
+            }
+            if (matchCount < minContains) {
+                validationResult.problems.push({
+                    location: { offset: node.offset, length: node.length },
+                    severity: vscode_languageserver_types_1.DiagnosticSeverity.Warning,
+                    message: schema.errorMessage || l10n.t('Array has too few items matching "contains". Expected {0} or more.', minContains),
+                    source: this.getSchemaSource(schema, originalSchema),
+                    schemaUri: this.getSchemaUri(schema, originalSchema),
+                });
+            }
+            if (maxContains !== undefined && matchCount > maxContains) {
+                validationResult.problems.push({
+                    location: { offset: node.offset, length: node.length },
+                    severity: vscode_languageserver_types_1.DiagnosticSeverity.Warning,
+                    message: schema.errorMessage || l10n.t('Array has too many items matching "contains". Expected {0} or fewer.', maxContains),
+                    source: this.getSchemaSource(schema, originalSchema),
+                    schemaUri: this.getSchemaUri(schema, originalSchema),
+                });
+            }
+        }
+    }
+    exports.Draft2020Validator = Draft2020Validator;
+});
+//# sourceMappingURL=draft2020Validator.js.map

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

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

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

@@ -0,0 +1,3 @@
+import { SchemaDialect } from '../../jsonSchema';
+import { BaseValidator } from './baseValidator';
+export declare function getValidator(dialect: SchemaDialect): BaseValidator;

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

@@ -0,0 +1,38 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) IBM 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", "../../jsonSchema", "./draft04Validator", "./draft07Validator", "./draft2019Validator", "./draft2020Validator"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getValidator = void 0;
+    const jsonSchema_1 = require("../../jsonSchema");
+    const draft04Validator_1 = require("./draft04Validator");
+    const draft07Validator_1 = require("./draft07Validator");
+    const draft2019Validator_1 = require("./draft2019Validator");
+    const draft2020Validator_1 = require("./draft2020Validator");
+    function getValidator(dialect) {
+        switch (dialect) {
+            case jsonSchema_1.SchemaDialect.draft04:
+                return new draft04Validator_1.Draft04Validator();
+            case jsonSchema_1.SchemaDialect.draft07:
+                return new draft07Validator_1.Draft07Validator();
+            case jsonSchema_1.SchemaDialect.draft2019:
+                return new draft2019Validator_1.Draft2019Validator();
+            case jsonSchema_1.SchemaDialect.draft2020:
+                return new draft2020Validator_1.Draft2020Validator();
+            default:
+                return new draft07Validator_1.Draft07Validator(); // fallback
+        }
+    }
+    exports.getValidator = getValidator;
+});
+//# sourceMappingURL=validatorFactory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validatorFactory.js","sourceRoot":"","sources":["../../../../../src/languageservice/parser/schemaValidation/validatorFactory.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;;;;;;;;;;;;;IAEhG,iDAAiD;IAEjD,yDAAsD;IACtD,yDAAsD;IACtD,6DAA0D;IAC1D,6DAA0D;IAE1D,SAAgB,YAAY,CAAC,OAAsB;QACjD,QAAQ,OAAO,EAAE;YACf,KAAK,0BAAa,CAAC,OAAO;gBACxB,OAAO,IAAI,mCAAgB,EAAE,CAAC;YAChC,KAAK,0BAAa,CAAC,OAAO;gBACxB,OAAO,IAAI,mCAAgB,EAAE,CAAC;YAChC,KAAK,0BAAa,CAAC,SAAS;gBAC1B,OAAO,IAAI,uCAAkB,EAAE,CAAC;YAClC,KAAK,0BAAa,CAAC,SAAS;gBAC1B,OAAO,IAAI,uCAAkB,EAAE,CAAC;YAClC;gBACE,OAAO,IAAI,mCAAgB,EAAE,CAAC,CAAC,WAAW;SAC7C;IACH,CAAC;IAbD,oCAaC"}

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 './jsonDocument';
+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", "./jsonDocument", "yaml", "./yamlParser07", "vscode-json-languageservice", "./ast-converter", "../utils/arrUtils", "../utils/yamlAstUtils", "../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 jsonDocument_1 = require("./jsonDocument");
+    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 yamlAstUtils_1 = require("../utils/yamlAstUtils");
+    const strings_1 = require("../utils/strings");
+    /**
+     * These documents are collected into a final YAMLDocument
+     * and passed to the `parseYAML` caller.
+     */
+    class SingleYAMLDocument extends jsonDocument_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, yamlAstUtils_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 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/crdUtil.d.ts

@@ -0,0 +1,23 @@
+import { SingleYAMLDocument } from '../parser/yamlParser07';
+import { JSONDocument } from '../parser/jsonDocument';
+import { ResolvedSchema } from 'vscode-json-languageservice/lib/umd/services/jsonSchemaService';
+/**
+ * Retrieve schema by auto-detecting the Kubernetes GroupVersionKind (GVK) from the document.
+ * If there is no definition for the GVK in the main kubernetes schema,
+ * the schema is then retrieved from the CRD catalog.
+ * Public for testing purpose, not part of the API.
+ * @param doc
+ * @param crdCatalogURI The URL of the CRD catalog to retrieve the schema from
+ * @param kubernetesSchema The main kubernetes schema, if it includes a definition for the GVK it will be used
+ */
+export declare function autoDetectKubernetesSchemaFromDocument(doc: SingleYAMLDocument | JSONDocument, crdCatalogURI: string, kubernetesSchema: ResolvedSchema): string | undefined;
+/**
+ * Retrieve the group, version and kind from the document.
+ * Public for testing purpose, not part of the API.
+ * @param doc
+ */
+export declare function getGroupVersionKindFromDocument(doc: SingleYAMLDocument | JSONDocument): {
+    group: string;
+    version: string;
+    kind: string;
+} | undefined;

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

@@ -0,0 +1,89 @@
+(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.getGroupVersionKindFromDocument = exports.autoDetectKubernetesSchemaFromDocument = void 0;
+    const yamlParser07_1 = require("../parser/yamlParser07");
+    /**
+     * Retrieve schema by auto-detecting the Kubernetes GroupVersionKind (GVK) from the document.
+     * If there is no definition for the GVK in the main kubernetes schema,
+     * the schema is then retrieved from the CRD catalog.
+     * Public for testing purpose, not part of the API.
+     * @param doc
+     * @param crdCatalogURI The URL of the CRD catalog to retrieve the schema from
+     * @param kubernetesSchema The main kubernetes schema, if it includes a definition for the GVK it will be used
+     */
+    function autoDetectKubernetesSchemaFromDocument(doc, crdCatalogURI, kubernetesSchema) {
+        const res = getGroupVersionKindFromDocument(doc);
+        if (!res) {
+            return undefined;
+        }
+        const { group, version, kind } = res;
+        if (!group || !version || !kind) {
+            return undefined;
+        }
+        const k8sSchema = kubernetesSchema.schema;
+        const kubernetesBuildIns = (k8sSchema.oneOf || [])
+            .map((s) => {
+            if (typeof s === 'boolean') {
+                return undefined;
+            }
+            return s._$ref || s.$ref;
+        })
+            .filter((ref) => ref)
+            .map((ref) => ref.replace('_definitions.json#/definitions/', '').toLowerCase());
+        const groupWithoutK8sIO = group.replace('.k8s.io', '');
+        const k8sTypeName = `io.k8s.api.${groupWithoutK8sIO.toLowerCase()}.${version.toLowerCase()}.${kind.toLowerCase()}`;
+        if (kubernetesBuildIns.includes(k8sTypeName)) {
+            return undefined;
+        }
+        if (k8sTypeName.includes('openshift.io')) {
+            return `${crdCatalogURI}/openshift/v4.15-strict/${kind.toLowerCase()}_${group.toLowerCase()}_${version.toLowerCase()}.json`;
+        }
+        const schemaURL = `${crdCatalogURI}/${group.toLowerCase()}/${kind.toLowerCase()}_${version.toLowerCase()}.json`;
+        return schemaURL;
+    }
+    exports.autoDetectKubernetesSchemaFromDocument = autoDetectKubernetesSchemaFromDocument;
+    /**
+     * Retrieve the group, version and kind from the document.
+     * Public for testing purpose, not part of the API.
+     * @param doc
+     */
+    function getGroupVersionKindFromDocument(doc) {
+        if (doc instanceof yamlParser07_1.SingleYAMLDocument) {
+            try {
+                const rootJSON = doc.root.internalNode.toJSON();
+                if (!rootJSON) {
+                    return undefined;
+                }
+                const groupVersion = rootJSON['apiVersion'];
+                if (!groupVersion) {
+                    return undefined;
+                }
+                const [group, version] = groupVersion.split('/');
+                if (!group || !version) {
+                    return undefined;
+                }
+                const kind = rootJSON['kind'];
+                if (!kind) {
+                    return undefined;
+                }
+                return { group, version, kind };
+            }
+            catch (error) {
+                console.error('Error parsing YAML document:', error);
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    exports.getGroupVersionKindFromDocument = getGroupVersionKindFromDocument;
+});
+//# sourceMappingURL=crdUtil.js.map

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

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

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,81 @@
+/*---------------------------------------------------------------------------------------------
+ *  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"], 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");
+    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', 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', 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;IAE1C,MAAa,mBAAmB;QAG9B,YACE,aAAgC,EACf,SAAqB;YAArB,cAAS,GAAT,SAAS,CAAY;YAEtC,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,GAAG,CAAC,CAAC;aAC9D;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,GAAG,CAAC,CAAC;aAC1E;YAED,OAAO,OAAO,CAAC;QACjB,CAAC;KACF;IArED,kDAqEC"}

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/jsonDocument';
+/**
+ * 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 { Connection, WorkspaceFolder } from 'vscode-languageserver';
+import { URI } from 'vscode-uri';
+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, isWeb: boolean) => Promise<string>;
+export declare const workspaceContext: WorkspaceContextService;

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

@@ -0,0 +1,98 @@
+(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", "path", "request-light", "url", "vscode-languageserver", "vscode-uri", "../../requestTypes", "../utils/paths"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.workspaceContext = exports.schemaRequestHandler = void 0;
+    const path_1 = require("path");
+    const request_light_1 = require("request-light");
+    const URL = require("url");
+    const vscode_languageserver_1 = require("vscode-languageserver");
+    const vscode_uri_1 = require("vscode-uri");
+    const requestTypes_1 = require("../../requestTypes");
+    const paths_1 = require("../utils/paths");
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    var FSReadUri;
+    (function (FSReadUri) {
+        FSReadUri.type = new vscode_languageserver_1.RequestType('fs/readUri');
+    })(FSReadUri || (FSReadUri = {}));
+    /**
+     * 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 = async (connection, uri, workspaceFolders, workspaceRoot, useVSCodeContentRequest, fs, isWeb) => {
+        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)) {
+            // HACK: the fs/readUri extension is only available with vscode-yaml,
+            // and this fix is specific to vscode-yaml on web, so don't use it in other cases
+            if (workspaceFolders.length === 1 && isWeb) {
+                const wsUri = vscode_uri_1.URI.parse(workspaceFolders[0].uri);
+                const wsDirname = wsUri.path;
+                const modifiedUri = wsUri.with({ path: (0, path_1.join)(wsDirname, uri) });
+                try {
+                    return connection.sendRequest(FSReadUri.type, modifiedUri.toString());
+                }
+                catch (e) {
+                    connection.window.showErrorMessage(`failed to get content of '${modifiedUri}': ${e}`);
+                }
+            }
+            else {
+                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,+BAA4B;IAC5B,iDAA4E;IAC5E,2BAA2B;IAC3B,iEAAiF;IACjF,2CAAiC;IACjC,qDAAsF;IACtF,0CAAwE;IAOxE,2DAA2D;IAC3D,IAAU,SAAS,CAElB;IAFD,WAAU,SAAS;QACJ,cAAI,GAAyC,IAAI,mCAAW,CAAC,YAAY,CAAC,CAAC;IAC1F,CAAC,EAFS,SAAS,KAAT,SAAS,QAElB;IAED;;;OAGG;IACI,MAAM,oBAAoB,GAAG,KAAK,EACvC,UAAsB,EACtB,GAAW,EACX,gBAAmC,EACnC,aAAkB,EAClB,uBAAgC,EAChC,EAAc,EACd,KAAc,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,qEAAqE;YACrE,iFAAiF;YACjF,IAAI,gBAAgB,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,EAAE;gBAC1C,MAAM,KAAK,GAAG,gBAAG,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;gBACjD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC;gBAC7B,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAA,WAAI,EAAC,SAAS,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;gBAC/D,IAAI;oBACF,OAAO,UAAU,CAAC,WAAW,CAAC,SAAS,CAAC,IAAI,EAAE,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC;iBACvE;gBAAC,OAAO,CAAC,EAAE;oBACV,UAAU,CAAC,MAAM,CAAC,gBAAgB,CAAC,6BAA6B,WAAW,MAAM,CAAC,EAAE,CAAC,CAAC;iBACvF;aACF;iBAAM;gBACL,GAAG,GAAG,IAAA,8BAAsB,EAAC,gBAAgB,EAAE,aAAa,EAAE,GAAG,CAAC,CAAC;aACpE;SACF;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;IAjFW,QAAA,oBAAoB,wBAiF/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,49 @@
+/*---------------------------------------------------------------------------------------------
+ *  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'));
+                            break;
+                        }
+                    }
+                }
+            });
+            return result;
+        }
+    }
+    exports.MapKeyOrderValidator = MapKeyOrderValidator;
+    function createRange(document, node) {
+        const keySourceToken = node.key.srcToken;
+        const start = keySourceToken.offset;
+        const end = start + keySourceToken.source.length;
+        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;IACpF,+BAAgD;IAKhD,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;4BACF,MAAM;yBACP;qBACF;iBACF;YACH,CAAC,CAAC,CAAC;YAEH,OAAO,MAAM,CAAC;QAChB,CAAC;KACF;IAzBD,oDAyBC;IAED,SAAS,WAAW,CAAC,QAAsB,EAAE,IAAU;QACrD,MAAM,cAAc,GAAI,IAAI,CAAC,GAAY,CAAC,QAAuB,CAAC;QAClE,MAAM,KAAK,GAAG,cAAc,CAAC,MAAM,CAAC;QACpC,MAAM,GAAG,GAAG,KAAK,GAAG,cAAc,CAAC,MAAM,CAAC,MAAM,CAAC;QACjD,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;
+}