qidian-vue-ui 1.1.50 → 1.1.51

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/validation/document-validator.mjs

@@ -0,0 +1,237 @@
+import { findNodeForProperty, findNodeForKeyword } from "../utils/grammar-utils.mjs";
+import { streamAst } from "../utils/ast-utils.mjs";
+import { tokenToRange } from "../utils/cst-utils.mjs";
+import { interruptAndCheck, isOperationCancelled } from "../utils/promise-utils.mjs";
+import { diagnosticData } from "./validation-registry.mjs";
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+class DefaultDocumentValidator {
+  constructor(services) {
+    this.validationRegistry = services.validation.ValidationRegistry;
+    this.metadata = services.LanguageMetaData;
+  }
+  async validateDocument(document, options = {}, cancelToken = cancellationExports.CancellationToken.None) {
+    const parseResult = document.parseResult;
+    const diagnostics = [];
+    await interruptAndCheck(cancelToken);
+    if (!options.categories || options.categories.includes("built-in")) {
+      this.processLexingErrors(parseResult, diagnostics, options);
+      if (options.stopAfterLexingErrors && diagnostics.some((d) => {
+        var _a;
+        return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LexingError;
+      })) {
+        return diagnostics;
+      }
+      this.processParsingErrors(parseResult, diagnostics, options);
+      if (options.stopAfterParsingErrors && diagnostics.some((d) => {
+        var _a;
+        return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.ParsingError;
+      })) {
+        return diagnostics;
+      }
+      this.processLinkingErrors(document, diagnostics, options);
+      if (options.stopAfterLinkingErrors && diagnostics.some((d) => {
+        var _a;
+        return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LinkingError;
+      })) {
+        return diagnostics;
+      }
+    }
+    try {
+      diagnostics.push(...await this.validateAst(parseResult.value, options, cancelToken));
+    } catch (err) {
+      if (isOperationCancelled(err)) {
+        throw err;
+      }
+      console.error("An error occurred during validation:", err);
+    }
+    await interruptAndCheck(cancelToken);
+    return diagnostics;
+  }
+  processLexingErrors(parseResult, diagnostics, _options) {
+    var _a, _b, _c;
+    const lexerDiagnostics = [...parseResult.lexerErrors, ...(_b = (_a = parseResult.lexerReport) === null || _a === void 0 ? void 0 : _a.diagnostics) !== null && _b !== void 0 ? _b : []];
+    for (const lexerDiagnostic of lexerDiagnostics) {
+      const severity = (_c = lexerDiagnostic.severity) !== null && _c !== void 0 ? _c : "error";
+      const diagnostic = {
+        severity: toDiagnosticSeverity(severity),
+        range: {
+          start: {
+            line: lexerDiagnostic.line - 1,
+            character: lexerDiagnostic.column - 1
+          },
+          end: {
+            line: lexerDiagnostic.line - 1,
+            character: lexerDiagnostic.column + lexerDiagnostic.length - 1
+          }
+        },
+        message: lexerDiagnostic.message,
+        data: toDiagnosticData(severity),
+        source: this.getSource()
+      };
+      diagnostics.push(diagnostic);
+    }
+  }
+  processParsingErrors(parseResult, diagnostics, _options) {
+    for (const parserError of parseResult.parserErrors) {
+      let range = void 0;
+      if (isNaN(parserError.token.startOffset)) {
+        if ("previousToken" in parserError) {
+          const token = parserError.previousToken;
+          if (!isNaN(token.startOffset)) {
+            const position = { line: token.endLine - 1, character: token.endColumn };
+            range = { start: position, end: position };
+          } else {
+            const position = { line: 0, character: 0 };
+            range = { start: position, end: position };
+          }
+        }
+      } else {
+        range = tokenToRange(parserError.token);
+      }
+      if (range) {
+        const diagnostic = {
+          severity: toDiagnosticSeverity("error"),
+          range,
+          message: parserError.message,
+          data: diagnosticData(DocumentValidator.ParsingError),
+          source: this.getSource()
+        };
+        diagnostics.push(diagnostic);
+      }
+    }
+  }
+  processLinkingErrors(document, diagnostics, _options) {
+    for (const reference of document.references) {
+      const linkingError = reference.error;
+      if (linkingError) {
+        const info = {
+          node: linkingError.container,
+          property: linkingError.property,
+          index: linkingError.index,
+          data: {
+            code: DocumentValidator.LinkingError,
+            containerType: linkingError.container.$type,
+            property: linkingError.property,
+            refText: linkingError.reference.$refText
+          }
+        };
+        diagnostics.push(this.toDiagnostic("error", linkingError.message, info));
+      }
+    }
+  }
+  async validateAst(rootNode, options, cancelToken = cancellationExports.CancellationToken.None) {
+    const validationItems = [];
+    const acceptor = (severity, message, info) => {
+      validationItems.push(this.toDiagnostic(severity, message, info));
+    };
+    await this.validateAstBefore(rootNode, options, acceptor, cancelToken);
+    await this.validateAstNodes(rootNode, options, acceptor, cancelToken);
+    await this.validateAstAfter(rootNode, options, acceptor, cancelToken);
+    return validationItems;
+  }
+  async validateAstBefore(rootNode, options, acceptor, cancelToken = cancellationExports.CancellationToken.None) {
+    var _a;
+    const checksBefore = this.validationRegistry.checksBefore;
+    for (const checkBefore of checksBefore) {
+      await interruptAndCheck(cancelToken);
+      await checkBefore(rootNode, acceptor, (_a = options.categories) !== null && _a !== void 0 ? _a : [], cancelToken);
+    }
+  }
+  async validateAstNodes(rootNode, options, acceptor, cancelToken = cancellationExports.CancellationToken.None) {
+    await Promise.all(streamAst(rootNode).map(async (node) => {
+      await interruptAndCheck(cancelToken);
+      const checks = this.validationRegistry.getChecks(node.$type, options.categories);
+      for (const check of checks) {
+        await check(node, acceptor, cancelToken);
+      }
+    }));
+  }
+  async validateAstAfter(rootNode, options, acceptor, cancelToken = cancellationExports.CancellationToken.None) {
+    var _a;
+    const checksAfter = this.validationRegistry.checksAfter;
+    for (const checkAfter of checksAfter) {
+      await interruptAndCheck(cancelToken);
+      await checkAfter(rootNode, acceptor, (_a = options.categories) !== null && _a !== void 0 ? _a : [], cancelToken);
+    }
+  }
+  toDiagnostic(severity, message, info) {
+    return {
+      message,
+      range: getDiagnosticRange(info),
+      severity: toDiagnosticSeverity(severity),
+      code: info.code,
+      codeDescription: info.codeDescription,
+      tags: info.tags,
+      relatedInformation: info.relatedInformation,
+      data: info.data,
+      source: this.getSource()
+    };
+  }
+  getSource() {
+    return this.metadata.languageId;
+  }
+}
+function getDiagnosticRange(info) {
+  if (info.range) {
+    return info.range;
+  }
+  let cstNode;
+  if (typeof info.property === "string") {
+    cstNode = findNodeForProperty(info.node.$cstNode, info.property, info.index);
+  } else if (typeof info.keyword === "string") {
+    cstNode = findNodeForKeyword(info.node.$cstNode, info.keyword, info.index);
+  }
+  cstNode !== null && cstNode !== void 0 ? cstNode : cstNode = info.node.$cstNode;
+  if (!cstNode) {
+    return {
+      start: { line: 0, character: 0 },
+      end: { line: 0, character: 0 }
+    };
+  }
+  return cstNode.range;
+}
+function toDiagnosticSeverity(severity) {
+  switch (severity) {
+    case "error":
+      return 1;
+    case "warning":
+      return 2;
+    case "info":
+      return 3;
+    case "hint":
+      return 4;
+    default:
+      throw new Error("Invalid diagnostic severity: " + severity);
+  }
+}
+function toDiagnosticData(severity) {
+  switch (severity) {
+    case "error":
+      return diagnosticData(DocumentValidator.LexingError);
+    case "warning":
+      return diagnosticData(DocumentValidator.LexingWarning);
+    case "info":
+      return diagnosticData(DocumentValidator.LexingInfo);
+    case "hint":
+      return diagnosticData(DocumentValidator.LexingHint);
+    default:
+      throw new Error("Invalid diagnostic severity: " + severity);
+  }
+}
+var DocumentValidator;
+(function(DocumentValidator2) {
+  DocumentValidator2.LexingError = "lexing-error";
+  DocumentValidator2.LexingWarning = "lexing-warning";
+  DocumentValidator2.LexingInfo = "lexing-info";
+  DocumentValidator2.LexingHint = "lexing-hint";
+  DocumentValidator2.ParsingError = "parsing-error";
+  DocumentValidator2.LinkingError = "linking-error";
+})(DocumentValidator || (DocumentValidator = {}));
+export {
+  DefaultDocumentValidator,
+  DocumentValidator,
+  getDiagnosticRange,
+  toDiagnosticData,
+  toDiagnosticSeverity
+};
+//# sourceMappingURL=document-validator.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/validation/document-validator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-validator.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/validation/document-validator.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { findNodeForKeyword, findNodeForProperty } from '../utils/grammar-utils.js';\nimport { streamAst } from '../utils/ast-utils.js';\nimport { tokenToRange } from '../utils/cst-utils.js';\nimport { interruptAndCheck, isOperationCancelled } from '../utils/promise-utils.js';\nimport { diagnosticData } from './validation-registry.js';\nexport class DefaultDocumentValidator {\n    constructor(services) {\n        this.validationRegistry = services.validation.ValidationRegistry;\n        this.metadata = services.LanguageMetaData;\n    }\n    async validateDocument(document, options = {}, cancelToken = CancellationToken.None) {\n        const parseResult = document.parseResult;\n        const diagnostics = [];\n        await interruptAndCheck(cancelToken);\n        if (!options.categories || options.categories.includes('built-in')) {\n            this.processLexingErrors(parseResult, diagnostics, options);\n            if (options.stopAfterLexingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LexingError; })) {\n                return diagnostics;\n            }\n            this.processParsingErrors(parseResult, diagnostics, options);\n            if (options.stopAfterParsingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.ParsingError; })) {\n                return diagnostics;\n            }\n            this.processLinkingErrors(document, diagnostics, options);\n            if (options.stopAfterLinkingErrors && diagnostics.some(d => { var _a; return ((_a = d.data) === null || _a === void 0 ? void 0 : _a.code) === DocumentValidator.LinkingError; })) {\n                return diagnostics;\n            }\n        }\n        // Process custom validations\n        try {\n            diagnostics.push(...await this.validateAst(parseResult.value, options, cancelToken));\n        }\n        catch (err) {\n            if (isOperationCancelled(err)) {\n                throw err;\n            }\n            console.error('An error occurred during validation:', err);\n        }\n        await interruptAndCheck(cancelToken);\n        return diagnostics;\n    }\n    processLexingErrors(parseResult, diagnostics, _options) {\n        var _a, _b, _c;\n        const lexerDiagnostics = [...parseResult.lexerErrors, ...(_b = (_a = parseResult.lexerReport) === null || _a === void 0 ? void 0 : _a.diagnostics) !== null && _b !== void 0 ? _b : []];\n        for (const lexerDiagnostic of lexerDiagnostics) {\n            const severity = (_c = lexerDiagnostic.severity) !== null && _c !== void 0 ? _c : 'error';\n            const diagnostic = {\n                severity: toDiagnosticSeverity(severity),\n                range: {\n                    start: {\n                        line: lexerDiagnostic.line - 1,\n                        character: lexerDiagnostic.column - 1\n                    },\n                    end: {\n                        line: lexerDiagnostic.line - 1,\n                        character: lexerDiagnostic.column + lexerDiagnostic.length - 1\n                    }\n                },\n                message: lexerDiagnostic.message,\n                data: toDiagnosticData(severity),\n                source: this.getSource()\n            };\n            diagnostics.push(diagnostic);\n        }\n    }\n    processParsingErrors(parseResult, diagnostics, _options) {\n        for (const parserError of parseResult.parserErrors) {\n            let range = undefined;\n            // We can run into the chevrotain error recovery here\n            // The token contained in the parser error might be automatically inserted\n            // In this case every position value will be `NaN`\n            if (isNaN(parserError.token.startOffset)) {\n                // Some special parser error types contain a `previousToken`\n                // We can simply append our diagnostic to that token\n                if ('previousToken' in parserError) {\n                    const token = parserError.previousToken;\n                    if (!isNaN(token.startOffset)) {\n                        const position = { line: token.endLine - 1, character: token.endColumn };\n                        range = { start: position, end: position };\n                    }\n                    else {\n                        // No valid prev token. Might be empty document or containing only hidden tokens.\n                        // Point to document start\n                        const position = { line: 0, character: 0 };\n                        range = { start: position, end: position };\n                    }\n                }\n            }\n            else {\n                range = tokenToRange(parserError.token);\n            }\n            if (range) {\n                const diagnostic = {\n                    severity: toDiagnosticSeverity('error'),\n                    range,\n                    message: parserError.message,\n                    data: diagnosticData(DocumentValidator.ParsingError),\n                    source: this.getSource()\n                };\n                diagnostics.push(diagnostic);\n            }\n        }\n    }\n    processLinkingErrors(document, diagnostics, _options) {\n        for (const reference of document.references) {\n            const linkingError = reference.error;\n            if (linkingError) {\n                const info = {\n                    node: linkingError.container,\n                    property: linkingError.property,\n                    index: linkingError.index,\n                    data: {\n                        code: DocumentValidator.LinkingError,\n                        containerType: linkingError.container.$type,\n                        property: linkingError.property,\n                        refText: linkingError.reference.$refText\n                    }\n                };\n                diagnostics.push(this.toDiagnostic('error', linkingError.message, info));\n            }\n        }\n    }\n    async validateAst(rootNode, options, cancelToken = CancellationToken.None) {\n        const validationItems = [];\n        const acceptor = (severity, message, info) => {\n            validationItems.push(this.toDiagnostic(severity, message, info));\n        };\n        await this.validateAstBefore(rootNode, options, acceptor, cancelToken);\n        await this.validateAstNodes(rootNode, options, acceptor, cancelToken);\n        await this.validateAstAfter(rootNode, options, acceptor, cancelToken);\n        return validationItems;\n    }\n    async validateAstBefore(rootNode, options, acceptor, cancelToken = CancellationToken.None) {\n        var _a;\n        const checksBefore = this.validationRegistry.checksBefore;\n        for (const checkBefore of checksBefore) {\n            await interruptAndCheck(cancelToken);\n            await checkBefore(rootNode, acceptor, (_a = options.categories) !== null && _a !== void 0 ? _a : [], cancelToken);\n        }\n    }\n    async validateAstNodes(rootNode, options, acceptor, cancelToken = CancellationToken.None) {\n        await Promise.all(streamAst(rootNode).map(async (node) => {\n            await interruptAndCheck(cancelToken);\n            const checks = this.validationRegistry.getChecks(node.$type, options.categories);\n            for (const check of checks) {\n                await check(node, acceptor, cancelToken);\n            }\n        }));\n    }\n    async validateAstAfter(rootNode, options, acceptor, cancelToken = CancellationToken.None) {\n        var _a;\n        const checksAfter = this.validationRegistry.checksAfter;\n        for (const checkAfter of checksAfter) {\n            await interruptAndCheck(cancelToken);\n            await checkAfter(rootNode, acceptor, (_a = options.categories) !== null && _a !== void 0 ? _a : [], cancelToken);\n        }\n    }\n    toDiagnostic(severity, message, info) {\n        return {\n            message,\n            range: getDiagnosticRange(info),\n            severity: toDiagnosticSeverity(severity),\n            code: info.code,\n            codeDescription: info.codeDescription,\n            tags: info.tags,\n            relatedInformation: info.relatedInformation,\n            data: info.data,\n            source: this.getSource()\n        };\n    }\n    getSource() {\n        return this.metadata.languageId;\n    }\n}\nexport function getDiagnosticRange(info) {\n    if (info.range) {\n        return info.range;\n    }\n    let cstNode;\n    if (typeof info.property === 'string') {\n        cstNode = findNodeForProperty(info.node.$cstNode, info.property, info.index);\n    }\n    else if (typeof info.keyword === 'string') {\n        cstNode = findNodeForKeyword(info.node.$cstNode, info.keyword, info.index);\n    }\n    cstNode !== null && cstNode !== void 0 ? cstNode : (cstNode = info.node.$cstNode);\n    if (!cstNode) {\n        return {\n            start: { line: 0, character: 0 },\n            end: { line: 0, character: 0 }\n        };\n    }\n    return cstNode.range;\n}\n/**\n * Transforms the diagnostic severity from the {@link LexingDiagnosticSeverity} format to LSP's `DiagnosticSeverity` format.\n *\n * @param severity The lexing diagnostic severity\n * @returns Diagnostic severity according to `vscode-languageserver-types/lib/esm/main.js#DiagnosticSeverity`\n */\nexport function toDiagnosticSeverity(severity) {\n    switch (severity) {\n        case 'error':\n            return 1;\n        case 'warning':\n            return 2;\n        case 'info':\n            return 3;\n        case 'hint':\n            return 4;\n        default:\n            throw new Error('Invalid diagnostic severity: ' + severity);\n    }\n}\nexport function toDiagnosticData(severity) {\n    switch (severity) {\n        case 'error':\n            return diagnosticData(DocumentValidator.LexingError);\n        case 'warning':\n            return diagnosticData(DocumentValidator.LexingWarning);\n        case 'info':\n            return diagnosticData(DocumentValidator.LexingInfo);\n        case 'hint':\n            return diagnosticData(DocumentValidator.LexingHint);\n        default:\n            throw new Error('Invalid diagnostic severity: ' + severity);\n    }\n}\nexport var DocumentValidator;\n(function (DocumentValidator) {\n    DocumentValidator.LexingError = 'lexing-error';\n    DocumentValidator.LexingWarning = 'lexing-warning';\n    DocumentValidator.LexingInfo = 'lexing-info';\n    DocumentValidator.LexingHint = 'lexing-hint';\n    DocumentValidator.ParsingError = 'parsing-error';\n    DocumentValidator.LinkingError = 'linking-error';\n})(DocumentValidator || (DocumentValidator = {}));\n//# sourceMappingURL=document-validator.js.map"],"names":["CancellationToken","DocumentValidator"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/validation/validation-registry.mjs

@@ -0,0 +1,143 @@
+import { MultiMap } from "../utils/collections.mjs";
+import { isOperationCancelled } from "../utils/promise-utils.mjs";
+import { stream } from "../utils/stream.mjs";
+import { assertUnreachable } from "../utils/errors.mjs";
+function diagnosticData(code) {
+  return { code };
+}
+var ValidationCategory;
+(function(ValidationCategory2) {
+  ValidationCategory2.all = ["fast", "slow", "built-in"];
+})(ValidationCategory || (ValidationCategory = {}));
+class ValidationRegistry {
+  constructor(services) {
+    this.entries = new MultiMap();
+    this.entriesBefore = [];
+    this.entriesAfter = [];
+    this.reflection = services.shared.AstReflection;
+  }
+  /**
+   * Register a set of validation checks. Each value in the record can be either a single validation check (i.e. a function)
+   * or an array of validation checks.
+   *
+   * @param checksRecord Set of validation checks to register.
+   * @param category Optional category for the validation checks (defaults to `'fast'`).
+   * @param thisObj Optional object to be used as `this` when calling the validation check functions.
+   */
+  register(checksRecord, thisObj = this, category = "fast") {
+    if (category === "built-in") {
+      throw new Error("The 'built-in' category is reserved for lexer, parser, and linker errors.");
+    }
+    for (const [type, ch] of Object.entries(checksRecord)) {
+      const callbacks = ch;
+      if (Array.isArray(callbacks)) {
+        for (const check of callbacks) {
+          const entry = {
+            check: this.wrapValidationException(check, thisObj),
+            category
+          };
+          this.addEntry(type, entry);
+        }
+      } else if (typeof callbacks === "function") {
+        const entry = {
+          check: this.wrapValidationException(callbacks, thisObj),
+          category
+        };
+        this.addEntry(type, entry);
+      } else {
+        assertUnreachable();
+      }
+    }
+  }
+  wrapValidationException(check, thisObj) {
+    return async (node, accept, cancelToken) => {
+      await this.handleException(() => check.call(thisObj, node, accept, cancelToken), "An error occurred during validation", accept, node);
+    };
+  }
+  async handleException(functionality, messageContext, accept, node) {
+    try {
+      await functionality();
+    } catch (err) {
+      if (isOperationCancelled(err)) {
+        throw err;
+      }
+      console.error(`${messageContext}:`, err);
+      if (err instanceof Error && err.stack) {
+        console.error(err.stack);
+      }
+      const messageDetails = err instanceof Error ? err.message : String(err);
+      accept("error", `${messageContext}: ${messageDetails}`, { node });
+    }
+  }
+  addEntry(type, entry) {
+    if (type === "AstNode") {
+      this.entries.add("AstNode", entry);
+      return;
+    }
+    for (const subtype of this.reflection.getAllSubTypes(type)) {
+      this.entries.add(subtype, entry);
+    }
+  }
+  getChecks(type, categories) {
+    let checks = stream(this.entries.get(type)).concat(this.entries.get("AstNode"));
+    if (categories) {
+      checks = checks.filter((entry) => categories.includes(entry.category));
+    }
+    return checks.map((entry) => entry.check);
+  }
+  /**
+   * Register logic which will be executed once before validating all the nodes of an AST/Langium document.
+   * This helps to prepare or initialize some information which are required or reusable for the following checks on the AstNodes.
+   *
+   * As an example, for validating unique fully-qualified names of nodes in the AST,
+   * here the map for mapping names to nodes could be established.
+   * During the usual checks on the nodes, they are put into this map with their name.
+   *
+   * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
+   * Therefore it is recommended to clear stored information
+   * _before_ validating an AST to validate each AST unaffected from other ASTs
+   * AND _after_ validating the AST to free memory by information which are no longer used.
+   *
+   * @param checkBefore a set-up function which will be called once before actually validating an AST
+   * @param thisObj Optional object to be used as `this` when calling the validation check functions.
+   */
+  registerBeforeDocument(checkBefore, thisObj = this) {
+    this.entriesBefore.push(this.wrapPreparationException(checkBefore, "An error occurred during set-up of the validation", thisObj));
+  }
+  /**
+   * Register logic which will be executed once after validating all the nodes of an AST/Langium document.
+   * This helps to finally evaluate information which are collected during the checks on the AstNodes.
+   *
+   * As an example, for validating unique fully-qualified names of nodes in the AST,
+   * here the map with all the collected nodes and their names is checked
+   * and validation hints are created for all nodes with the same name.
+   *
+   * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.
+   * Therefore it is recommended to clear stored information
+   * _before_ validating an AST to validate each AST unaffected from other ASTs
+   * AND _after_ validating the AST to free memory by information which are no longer used.
+   *
+   * @param checkBefore a set-up function which will be called once before actually validating an AST
+   * @param thisObj Optional object to be used as `this` when calling the validation check functions.
+   */
+  registerAfterDocument(checkAfter, thisObj = this) {
+    this.entriesAfter.push(this.wrapPreparationException(checkAfter, "An error occurred during tear-down of the validation", thisObj));
+  }
+  wrapPreparationException(check, messageContext, thisObj) {
+    return async (rootNode, accept, categories, cancelToken) => {
+      await this.handleException(() => check.call(thisObj, rootNode, accept, categories, cancelToken), messageContext, accept, rootNode);
+    };
+  }
+  get checksBefore() {
+    return this.entriesBefore;
+  }
+  get checksAfter() {
+    return this.entriesAfter;
+  }
+}
+export {
+  ValidationCategory,
+  ValidationRegistry,
+  diagnosticData
+};
+//# sourceMappingURL=validation-registry.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/validation/validation-registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-registry.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/validation/validation-registry.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { assertUnreachable } from '../index.js';\nimport { MultiMap } from '../utils/collections.js';\nimport { isOperationCancelled } from '../utils/promise-utils.js';\nimport { stream } from '../utils/stream.js';\n/**\n * Create DiagnosticData for a given diagnostic code. The result can be put into the `data` field of a DiagnosticInfo.\n */\nexport function diagnosticData(code) {\n    return { code };\n}\nexport var ValidationCategory;\n(function (ValidationCategory) {\n    ValidationCategory.all = ['fast', 'slow', 'built-in'];\n})(ValidationCategory || (ValidationCategory = {}));\n/**\n * Manages a set of `ValidationCheck`s to be applied when documents are validated.\n */\nexport class ValidationRegistry {\n    constructor(services) {\n        this.entries = new MultiMap();\n        this.entriesBefore = [];\n        this.entriesAfter = [];\n        this.reflection = services.shared.AstReflection;\n    }\n    /**\n     * Register a set of validation checks. Each value in the record can be either a single validation check (i.e. a function)\n     * or an array of validation checks.\n     *\n     * @param checksRecord Set of validation checks to register.\n     * @param category Optional category for the validation checks (defaults to `'fast'`).\n     * @param thisObj Optional object to be used as `this` when calling the validation check functions.\n     */\n    register(checksRecord, thisObj = this, category = 'fast') {\n        if (category === 'built-in') {\n            throw new Error(\"The 'built-in' category is reserved for lexer, parser, and linker errors.\");\n        }\n        for (const [type, ch] of Object.entries(checksRecord)) {\n            const callbacks = ch;\n            if (Array.isArray(callbacks)) {\n                for (const check of callbacks) {\n                    const entry = {\n                        check: this.wrapValidationException(check, thisObj),\n                        category\n                    };\n                    this.addEntry(type, entry);\n                }\n            }\n            else if (typeof callbacks === 'function') {\n                const entry = {\n                    check: this.wrapValidationException(callbacks, thisObj),\n                    category\n                };\n                this.addEntry(type, entry);\n            }\n            else {\n                assertUnreachable(callbacks);\n            }\n        }\n    }\n    wrapValidationException(check, thisObj) {\n        return async (node, accept, cancelToken) => {\n            await this.handleException(() => check.call(thisObj, node, accept, cancelToken), 'An error occurred during validation', accept, node);\n        };\n    }\n    async handleException(functionality, messageContext, accept, node) {\n        try {\n            await functionality();\n        }\n        catch (err) {\n            if (isOperationCancelled(err)) {\n                throw err;\n            }\n            console.error(`${messageContext}:`, err);\n            if (err instanceof Error && err.stack) {\n                console.error(err.stack);\n            }\n            const messageDetails = err instanceof Error ? err.message : String(err);\n            accept('error', `${messageContext}: ${messageDetails}`, { node });\n        }\n    }\n    addEntry(type, entry) {\n        if (type === 'AstNode') {\n            this.entries.add('AstNode', entry);\n            return;\n        }\n        for (const subtype of this.reflection.getAllSubTypes(type)) {\n            this.entries.add(subtype, entry);\n        }\n    }\n    getChecks(type, categories) {\n        let checks = stream(this.entries.get(type))\n            .concat(this.entries.get('AstNode'));\n        if (categories) {\n            checks = checks.filter(entry => categories.includes(entry.category));\n        }\n        return checks.map(entry => entry.check);\n    }\n    /**\n     * Register logic which will be executed once before validating all the nodes of an AST/Langium document.\n     * This helps to prepare or initialize some information which are required or reusable for the following checks on the AstNodes.\n     *\n     * As an example, for validating unique fully-qualified names of nodes in the AST,\n     * here the map for mapping names to nodes could be established.\n     * During the usual checks on the nodes, they are put into this map with their name.\n     *\n     * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.\n     * Therefore it is recommended to clear stored information\n     * _before_ validating an AST to validate each AST unaffected from other ASTs\n     * AND _after_ validating the AST to free memory by information which are no longer used.\n     *\n     * @param checkBefore a set-up function which will be called once before actually validating an AST\n     * @param thisObj Optional object to be used as `this` when calling the validation check functions.\n     */\n    registerBeforeDocument(checkBefore, thisObj = this) {\n        this.entriesBefore.push(this.wrapPreparationException(checkBefore, 'An error occurred during set-up of the validation', thisObj));\n    }\n    /**\n     * Register logic which will be executed once after validating all the nodes of an AST/Langium document.\n     * This helps to finally evaluate information which are collected during the checks on the AstNodes.\n     *\n     * As an example, for validating unique fully-qualified names of nodes in the AST,\n     * here the map with all the collected nodes and their names is checked\n     * and validation hints are created for all nodes with the same name.\n     *\n     * Note that this approach makes validations stateful, which is relevant e.g. when cancelling the validation.\n     * Therefore it is recommended to clear stored information\n     * _before_ validating an AST to validate each AST unaffected from other ASTs\n     * AND _after_ validating the AST to free memory by information which are no longer used.\n     *\n     * @param checkBefore a set-up function which will be called once before actually validating an AST\n     * @param thisObj Optional object to be used as `this` when calling the validation check functions.\n     */\n    registerAfterDocument(checkAfter, thisObj = this) {\n        this.entriesAfter.push(this.wrapPreparationException(checkAfter, 'An error occurred during tear-down of the validation', thisObj));\n    }\n    wrapPreparationException(check, messageContext, thisObj) {\n        return async (rootNode, accept, categories, cancelToken) => {\n            await this.handleException(() => check.call(thisObj, rootNode, accept, categories, cancelToken), messageContext, accept, rootNode);\n        };\n    }\n    get checksBefore() {\n        return this.entriesBefore;\n    }\n    get checksAfter() {\n        return this.entriesAfter;\n    }\n}\n//# sourceMappingURL=validation-registry.js.map"],"names":["ValidationCategory"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/ast-descriptions.mjs

@@ -0,0 +1,76 @@
+import { isLinkingError } from "../syntax-tree.mjs";
+import { streamAst, streamReferences, getDocument } from "../utils/ast-utils.mjs";
+import { toDocumentSegment } from "../utils/cst-utils.mjs";
+import { interruptAndCheck } from "../utils/promise-utils.mjs";
+import { UriUtils } from "../utils/uri-utils.mjs";
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+class DefaultAstNodeDescriptionProvider {
+  constructor(services) {
+    this.astNodeLocator = services.workspace.AstNodeLocator;
+    this.nameProvider = services.references.NameProvider;
+  }
+  createDescription(node, name, document) {
+    const doc = document !== null && document !== void 0 ? document : getDocument(node);
+    name !== null && name !== void 0 ? name : name = this.nameProvider.getName(node);
+    const path = this.astNodeLocator.getAstNodePath(node);
+    if (!name) {
+      throw new Error(`Node at path ${path} has no name.`);
+    }
+    let nameNodeSegment;
+    const nameSegmentGetter = () => {
+      var _a;
+      return nameNodeSegment !== null && nameNodeSegment !== void 0 ? nameNodeSegment : nameNodeSegment = toDocumentSegment((_a = this.nameProvider.getNameNode(node)) !== null && _a !== void 0 ? _a : node.$cstNode);
+    };
+    return {
+      node,
+      name,
+      get nameSegment() {
+        return nameSegmentGetter();
+      },
+      selectionSegment: toDocumentSegment(node.$cstNode),
+      type: node.$type,
+      documentUri: doc.uri,
+      path
+    };
+  }
+}
+class DefaultReferenceDescriptionProvider {
+  constructor(services) {
+    this.nodeLocator = services.workspace.AstNodeLocator;
+  }
+  async createDescriptions(document, cancelToken = cancellationExports.CancellationToken.None) {
+    const descr = [];
+    const rootNode = document.parseResult.value;
+    for (const astNode of streamAst(rootNode)) {
+      await interruptAndCheck(cancelToken);
+      streamReferences(astNode).filter((refInfo) => !isLinkingError(refInfo)).forEach((refInfo) => {
+        const description = this.createDescription(refInfo);
+        if (description) {
+          descr.push(description);
+        }
+      });
+    }
+    return descr;
+  }
+  createDescription(refInfo) {
+    const targetNodeDescr = refInfo.reference.$nodeDescription;
+    const refCstNode = refInfo.reference.$refNode;
+    if (!targetNodeDescr || !refCstNode) {
+      return void 0;
+    }
+    const docUri = getDocument(refInfo.container).uri;
+    return {
+      sourceUri: docUri,
+      sourcePath: this.nodeLocator.getAstNodePath(refInfo.container),
+      targetUri: targetNodeDescr.documentUri,
+      targetPath: targetNodeDescr.path,
+      segment: toDocumentSegment(refCstNode),
+      local: UriUtils.equals(targetNodeDescr.documentUri, docUri)
+    };
+  }
+}
+export {
+  DefaultAstNodeDescriptionProvider,
+  DefaultReferenceDescriptionProvider
+};
+//# sourceMappingURL=ast-descriptions.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/ast-descriptions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-descriptions.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/ast-descriptions.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nimport { CancellationToken } from '../utils/cancellation.js';\nimport { isLinkingError } from '../syntax-tree.js';\nimport { getDocument, streamAst, streamReferences } from '../utils/ast-utils.js';\nimport { toDocumentSegment } from '../utils/cst-utils.js';\nimport { interruptAndCheck } from '../utils/promise-utils.js';\nimport { UriUtils } from '../utils/uri-utils.js';\nexport class DefaultAstNodeDescriptionProvider {\n    constructor(services) {\n        this.astNodeLocator = services.workspace.AstNodeLocator;\n        this.nameProvider = services.references.NameProvider;\n    }\n    createDescription(node, name, document) {\n        const doc = document !== null && document !== void 0 ? document : getDocument(node);\n        name !== null && name !== void 0 ? name : (name = this.nameProvider.getName(node));\n        const path = this.astNodeLocator.getAstNodePath(node);\n        if (!name) {\n            throw new Error(`Node at path ${path} has no name.`);\n        }\n        let nameNodeSegment;\n        const nameSegmentGetter = () => { var _a; return nameNodeSegment !== null && nameNodeSegment !== void 0 ? nameNodeSegment : (nameNodeSegment = toDocumentSegment((_a = this.nameProvider.getNameNode(node)) !== null && _a !== void 0 ? _a : node.$cstNode)); };\n        return {\n            node,\n            name,\n            get nameSegment() {\n                return nameSegmentGetter();\n            },\n            selectionSegment: toDocumentSegment(node.$cstNode),\n            type: node.$type,\n            documentUri: doc.uri,\n            path\n        };\n    }\n}\nexport class DefaultReferenceDescriptionProvider {\n    constructor(services) {\n        this.nodeLocator = services.workspace.AstNodeLocator;\n    }\n    async createDescriptions(document, cancelToken = CancellationToken.None) {\n        const descr = [];\n        const rootNode = document.parseResult.value;\n        for (const astNode of streamAst(rootNode)) {\n            await interruptAndCheck(cancelToken);\n            streamReferences(astNode).filter(refInfo => !isLinkingError(refInfo)).forEach(refInfo => {\n                // TODO: Consider logging a warning or throw an exception when DocumentState is < than Linked\n                const description = this.createDescription(refInfo);\n                if (description) {\n                    descr.push(description);\n                }\n            });\n        }\n        return descr;\n    }\n    createDescription(refInfo) {\n        const targetNodeDescr = refInfo.reference.$nodeDescription;\n        const refCstNode = refInfo.reference.$refNode;\n        if (!targetNodeDescr || !refCstNode) {\n            return undefined;\n        }\n        const docUri = getDocument(refInfo.container).uri;\n        return {\n            sourceUri: docUri,\n            sourcePath: this.nodeLocator.getAstNodePath(refInfo.container),\n            targetUri: targetNodeDescr.documentUri,\n            targetPath: targetNodeDescr.path,\n            segment: toDocumentSegment(refCstNode),\n            local: UriUtils.equals(targetNodeDescr.documentUri, docUri)\n        };\n    }\n}\n//# sourceMappingURL=ast-descriptions.js.map"],"names":["CancellationToken"],"mappings":";;;;;;AAWO,MAAM,kCAAkC;AAAA,EAC3C,YAAY,UAAU;AAClB,SAAK,iBAAiB,SAAS,UAAU;AACzC,SAAK,eAAe,SAAS,WAAW;AAAA,EAC5C;AAAA,EACA,kBAAkB,MAAM,MAAM,UAAU;AACpC,UAAM,MAAM,aAAa,QAAQ,aAAa,SAAS,WAAW,YAAY,IAAI;AAClF,aAAS,QAAQ,SAAS,SAAS,OAAQ,OAAO,KAAK,aAAa,QAAQ,IAAI;AAChF,UAAM,OAAO,KAAK,eAAe,eAAe,IAAI;AACpD,QAAI,CAAC,MAAM;AACP,YAAM,IAAI,MAAM,gBAAgB,IAAI,eAAe;AAAA,IACvD;AACA,QAAI;AACJ,UAAM,oBAAoB,MAAM;AAAE,UAAI;AAAI,aAAO,oBAAoB,QAAQ,oBAAoB,SAAS,kBAAmB,kBAAkB,mBAAmB,KAAK,KAAK,aAAa,YAAY,IAAI,OAAO,QAAQ,OAAO,SAAS,KAAK,KAAK,QAAQ;AAAA,IAAI;AAC9P,WAAO;AAAA,MACH;AAAA,MACA;AAAA,MACA,IAAI,cAAc;AACd,eAAO,kBAAiB;AAAA,MAC5B;AAAA,MACA,kBAAkB,kBAAkB,KAAK,QAAQ;AAAA,MACjD,MAAM,KAAK;AAAA,MACX,aAAa,IAAI;AAAA,MACjB;AAAA,IACZ;AAAA,EACI;AACJ;AACO,MAAM,oCAAoC;AAAA,EAC7C,YAAY,UAAU;AAClB,SAAK,cAAc,SAAS,UAAU;AAAA,EAC1C;AAAA,EACA,MAAM,mBAAmB,UAAU,cAAcA,oBAAAA,kBAAkB,MAAM;AACrE,UAAM,QAAQ,CAAA;AACd,UAAM,WAAW,SAAS,YAAY;AACtC,eAAW,WAAW,UAAU,QAAQ,GAAG;AACvC,YAAM,kBAAkB,WAAW;AACnC,uBAAiB,OAAO,EAAE,OAAO,aAAW,CAAC,eAAe,OAAO,CAAC,EAAE,QAAQ,aAAW;AAErF,cAAM,cAAc,KAAK,kBAAkB,OAAO;AAClD,YAAI,aAAa;AACb,gBAAM,KAAK,WAAW;AAAA,QAC1B;AAAA,MACJ,CAAC;AAAA,IACL;AACA,WAAO;AAAA,EACX;AAAA,EACA,kBAAkB,SAAS;AACvB,UAAM,kBAAkB,QAAQ,UAAU;AAC1C,UAAM,aAAa,QAAQ,UAAU;AACrC,QAAI,CAAC,mBAAmB,CAAC,YAAY;AACjC,aAAO;AAAA,IACX;AACA,UAAM,SAAS,YAAY,QAAQ,SAAS,EAAE;AAC9C,WAAO;AAAA,MACH,WAAW;AAAA,MACX,YAAY,KAAK,YAAY,eAAe,QAAQ,SAAS;AAAA,MAC7D,WAAW,gBAAgB;AAAA,MAC3B,YAAY,gBAAgB;AAAA,MAC5B,SAAS,kBAAkB,UAAU;AAAA,MACrC,OAAO,SAAS,OAAO,gBAAgB,aAAa,MAAM;AAAA,IACtE;AAAA,EACI;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/ast-node-locator.mjs

@@ -0,0 +1,44 @@
+class DefaultAstNodeLocator {
+  constructor() {
+    this.segmentSeparator = "/";
+    this.indexSeparator = "@";
+  }
+  getAstNodePath(node) {
+    if (node.$container) {
+      const containerPath = this.getAstNodePath(node.$container);
+      const newSegment = this.getPathSegment(node);
+      const nodePath = containerPath + this.segmentSeparator + newSegment;
+      return nodePath;
+    }
+    return "";
+  }
+  getPathSegment({ $containerProperty, $containerIndex }) {
+    if (!$containerProperty) {
+      throw new Error("Missing '$containerProperty' in AST node.");
+    }
+    if ($containerIndex !== void 0) {
+      return $containerProperty + this.indexSeparator + $containerIndex;
+    }
+    return $containerProperty;
+  }
+  getAstNode(node, path) {
+    const segments = path.split(this.segmentSeparator);
+    return segments.reduce((previousValue, currentValue) => {
+      if (!previousValue || currentValue.length === 0) {
+        return previousValue;
+      }
+      const propertyIndex = currentValue.indexOf(this.indexSeparator);
+      if (propertyIndex > 0) {
+        const property = currentValue.substring(0, propertyIndex);
+        const arrayIndex = parseInt(currentValue.substring(propertyIndex + 1));
+        const array = previousValue[property];
+        return array === null || array === void 0 ? void 0 : array[arrayIndex];
+      }
+      return previousValue[currentValue];
+    }, node);
+  }
+}
+export {
+  DefaultAstNodeLocator
+};
+//# sourceMappingURL=ast-node-locator.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/ast-node-locator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-node-locator.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/workspace/ast-node-locator.js"],"sourcesContent":["/******************************************************************************\n * Copyright 2021 TypeFox GmbH\n * This program and the accompanying materials are made available under the\n * terms of the MIT License, which is available in the project root.\n ******************************************************************************/\nexport class DefaultAstNodeLocator {\n    constructor() {\n        this.segmentSeparator = '/';\n        this.indexSeparator = '@';\n    }\n    getAstNodePath(node) {\n        if (node.$container) {\n            const containerPath = this.getAstNodePath(node.$container);\n            const newSegment = this.getPathSegment(node);\n            const nodePath = containerPath + this.segmentSeparator + newSegment;\n            return nodePath;\n        }\n        return '';\n    }\n    getPathSegment({ $containerProperty, $containerIndex }) {\n        if (!$containerProperty) {\n            throw new Error(\"Missing '$containerProperty' in AST node.\");\n        }\n        if ($containerIndex !== undefined) {\n            return $containerProperty + this.indexSeparator + $containerIndex;\n        }\n        return $containerProperty;\n    }\n    getAstNode(node, path) {\n        const segments = path.split(this.segmentSeparator);\n        return segments.reduce((previousValue, currentValue) => {\n            if (!previousValue || currentValue.length === 0) {\n                return previousValue;\n            }\n            const propertyIndex = currentValue.indexOf(this.indexSeparator);\n            if (propertyIndex > 0) {\n                const property = currentValue.substring(0, propertyIndex);\n                const arrayIndex = parseInt(currentValue.substring(propertyIndex + 1));\n                const array = previousValue[property];\n                return array === null || array === void 0 ? void 0 : array[arrayIndex];\n            }\n            return previousValue[currentValue];\n        }, node);\n    }\n}\n//# sourceMappingURL=ast-node-locator.js.map"],"names":[],"mappings":"AAKO,MAAM,sBAAsB;AAAA,EAC/B,cAAc;AACV,SAAK,mBAAmB;AACxB,SAAK,iBAAiB;AAAA,EAC1B;AAAA,EACA,eAAe,MAAM;AACjB,QAAI,KAAK,YAAY;AACjB,YAAM,gBAAgB,KAAK,eAAe,KAAK,UAAU;AACzD,YAAM,aAAa,KAAK,eAAe,IAAI;AAC3C,YAAM,WAAW,gBAAgB,KAAK,mBAAmB;AACzD,aAAO;AAAA,IACX;AACA,WAAO;AAAA,EACX;AAAA,EACA,eAAe,EAAE,oBAAoB,mBAAmB;AACpD,QAAI,CAAC,oBAAoB;AACrB,YAAM,IAAI,MAAM,2CAA2C;AAAA,IAC/D;AACA,QAAI,oBAAoB,QAAW;AAC/B,aAAO,qBAAqB,KAAK,iBAAiB;AAAA,IACtD;AACA,WAAO;AAAA,EACX;AAAA,EACA,WAAW,MAAM,MAAM;AACnB,UAAM,WAAW,KAAK,MAAM,KAAK,gBAAgB;AACjD,WAAO,SAAS,OAAO,CAAC,eAAe,iBAAiB;AACpD,UAAI,CAAC,iBAAiB,aAAa,WAAW,GAAG;AAC7C,eAAO;AAAA,MACX;AACA,YAAM,gBAAgB,aAAa,QAAQ,KAAK,cAAc;AAC9D,UAAI,gBAAgB,GAAG;AACnB,cAAM,WAAW,aAAa,UAAU,GAAG,aAAa;AACxD,cAAM,aAAa,SAAS,aAAa,UAAU,gBAAgB,CAAC,CAAC;AACrE,cAAM,QAAQ,cAAc,QAAQ;AACpC,eAAO,UAAU,QAAQ,UAAU,SAAS,SAAS,MAAM,UAAU;AAAA,MACzE;AACA,aAAO,cAAc,YAAY;AAAA,IACrC,GAAG,IAAI;AAAA,EACX;AACJ;","x_google_ignoreList":[0]}