qidian-vue-ui 1.1.55 → 1.1.57

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

@@ -1,237 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,143 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,76 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,44 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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]}