@windrun-huaiin/third-ui 12.0.3 → 13.0.0

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/disposable.mjs

@@ -0,0 +1,16 @@
+/******************************************************************************
+ * Copyright 2021 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+var Disposable;
+(function (Disposable) {
+    function create(callback) {
+        return {
+            dispose: async () => await callback()
+        };
+    }
+    Disposable.create = create;
+})(Disposable || (Disposable = {}));
+
+export { Disposable };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/errors.js

@@ -0,0 +1,18 @@
+'use strict';
+
+/******************************************************************************
+ * Copyright 2021 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+class ErrorWithLocation extends Error {
+    constructor(node, message) {
+        super(node ? `${message} at ${node.range.start.line}:${node.range.start.character}` : message);
+    }
+}
+function assertUnreachable(_, message = 'Error: Got unexpected value.') {
+    throw new Error(message);
+}
+
+exports.ErrorWithLocation = ErrorWithLocation;
+exports.assertUnreachable = assertUnreachable;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/errors.mjs

@@ -0,0 +1,15 @@
+/******************************************************************************
+ * Copyright 2021 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+class ErrorWithLocation extends Error {
+    constructor(node, message) {
+        super(node ? `${message} at ${node.range.start.line}:${node.range.start.character}` : message);
+    }
+}
+function assertUnreachable(_, message = 'Error: Got unexpected value.') {
+    throw new Error(message);
+}
+
+export { ErrorWithLocation, assertUnreachable };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/grammar-loader.js

@@ -0,0 +1,43 @@
+'use strict';
+
+var defaultModule = require('../default-module.js');
+var dependencyInjection = require('../dependency-injection.js');
+var ast = require('../languages/generated/ast.js');
+var fileSystemProvider = require('../workspace/file-system-provider.js');
+require('./uri-utils.js');
+var index = require('../../../../../vscode-uri@3.1.0/node_modules/vscode-uri/lib/esm/index.js');
+
+/******************************************************************************
+ * Copyright 2023 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+const minimalGrammarModule = {
+    Grammar: () => undefined,
+    LanguageMetaData: () => ({
+        caseInsensitive: false,
+        fileExtensions: ['.langium'],
+        languageId: 'langium'
+    })
+};
+const minimalSharedGrammarModule = {
+    AstReflection: () => new ast.LangiumGrammarAstReflection()
+};
+function createMinimalGrammarServices() {
+    const shared = dependencyInjection.inject(defaultModule.createDefaultSharedCoreModule(fileSystemProvider.EmptyFileSystem), minimalSharedGrammarModule);
+    const grammar = dependencyInjection.inject(defaultModule.createDefaultCoreModule({ shared }), minimalGrammarModule);
+    shared.ServiceRegistry.register(grammar);
+    return grammar;
+}
+/**
+ * Load a Langium grammar for your language from a JSON string. This is used by several services,
+ * most notably the parser builder which interprets the grammar to create a parser.
+ */
+function loadGrammarFromJson(json) {
+    const services = createMinimalGrammarServices();
+    const astNode = services.serializer.JsonSerializer.deserialize(json);
+    services.shared.workspace.LangiumDocumentFactory.fromModel(astNode, index.URI.parse(`memory:/${astNode.name ?? 'grammar'}.langium`));
+    return astNode;
+}
+
+exports.loadGrammarFromJson = loadGrammarFromJson;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/grammar-loader.mjs

@@ -0,0 +1,41 @@
+import { createDefaultSharedCoreModule, createDefaultCoreModule } from '../default-module.mjs';
+import { inject } from '../dependency-injection.mjs';
+import { LangiumGrammarAstReflection } from '../languages/generated/ast.mjs';
+import { EmptyFileSystem } from '../workspace/file-system-provider.mjs';
+import './uri-utils.mjs';
+import { URI } from '../../../../../vscode-uri@3.1.0/node_modules/vscode-uri/lib/esm/index.mjs';
+
+/******************************************************************************
+ * Copyright 2023 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+const minimalGrammarModule = {
+    Grammar: () => undefined,
+    LanguageMetaData: () => ({
+        caseInsensitive: false,
+        fileExtensions: ['.langium'],
+        languageId: 'langium'
+    })
+};
+const minimalSharedGrammarModule = {
+    AstReflection: () => new LangiumGrammarAstReflection()
+};
+function createMinimalGrammarServices() {
+    const shared = inject(createDefaultSharedCoreModule(EmptyFileSystem), minimalSharedGrammarModule);
+    const grammar = inject(createDefaultCoreModule({ shared }), minimalGrammarModule);
+    shared.ServiceRegistry.register(grammar);
+    return grammar;
+}
+/**
+ * Load a Langium grammar for your language from a JSON string. This is used by several services,
+ * most notably the parser builder which interprets the grammar to create a parser.
+ */
+function loadGrammarFromJson(json) {
+    const services = createMinimalGrammarServices();
+    const astNode = services.serializer.JsonSerializer.deserialize(json);
+    services.shared.workspace.LangiumDocumentFactory.fromModel(astNode, URI.parse(`memory:/${astNode.name ?? 'grammar'}.langium`));
+    return astNode;
+}
+
+export { loadGrammarFromJson };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/utils/grammar-utils.js

@@ -0,0 +1,501 @@
+'use strict';
+
+var errors = require('./errors.js');
+var ast = require('../languages/generated/ast.js');
+var syntaxTree = require('../syntax-tree.js');
+var astUtils = require('./ast-utils.js');
+var cstUtils = require('./cst-utils.js');
+var regexpUtils = require('./regexp-utils.js');
+
+/******************************************************************************
+ * Copyright 2021-2022 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+/**
+ * Returns the entry rule of the given grammar, if any. If the grammar file does not contain an entry rule,
+ * the result is `undefined`.
+ */
+function getEntryRule(grammar) {
+    return grammar.rules.find(e => ast.isParserRule(e) && e.entry);
+}
+/**
+ * Returns all hidden terminal rules of the given grammar, if any.
+ */
+function getHiddenRules(grammar) {
+    return grammar.rules.filter(e => ast.isTerminalRule(e) && e.hidden);
+}
+/**
+ * Returns all rules that can be reached from the topmost rules of the specified grammar (entry and hidden terminal rules).
+ *
+ * @param grammar The grammar that contains all rules
+ * @param allTerminals Whether or not to include terminals that are referenced only by other terminals
+ * @returns A list of referenced parser and terminal rules. If the grammar contains no entry rule,
+ *      this function returns all rules of the specified grammar.
+ */
+function getAllReachableRules(grammar, allTerminals) {
+    const ruleNames = new Set();
+    const entryRule = getEntryRule(grammar);
+    if (!entryRule) {
+        return new Set(grammar.rules);
+    }
+    const topMostRules = [entryRule].concat(getHiddenRules(grammar));
+    for (const rule of topMostRules) {
+        ruleDfs(rule, ruleNames, allTerminals);
+    }
+    const rules = new Set();
+    for (const rule of grammar.rules) {
+        if (ruleNames.has(rule.name) || (ast.isTerminalRule(rule) && rule.hidden)) {
+            rules.add(rule);
+        }
+    }
+    return rules;
+}
+function ruleDfs(rule, visitedSet, allTerminals) {
+    visitedSet.add(rule.name);
+    astUtils.streamAllContents(rule).forEach(node => {
+        if (ast.isRuleCall(node) || (allTerminals)) {
+            const refRule = node.rule.ref;
+            if (refRule && !visitedSet.has(refRule.name)) {
+                ruleDfs(refRule, visitedSet, allTerminals);
+            }
+        }
+    });
+}
+/**
+ * Determines the grammar expression used to parse a cross-reference (usually a reference to a terminal rule).
+ * A cross-reference can declare this expression explicitly in the form `[Type : Terminal]`, but if `Terminal`
+ * is omitted, this function attempts to infer it from the name of the referenced `Type` (using `findNameAssignment`).
+ *
+ * Returns the grammar expression used to parse the given cross-reference, or `undefined` if it is not declared
+ * and cannot be inferred.
+ */
+function getCrossReferenceTerminal(crossRef) {
+    if (crossRef.terminal) {
+        return crossRef.terminal;
+    }
+    else if (crossRef.type.ref) {
+        const nameAssigment = findNameAssignment(crossRef.type.ref);
+        return nameAssigment?.terminal;
+    }
+    return undefined;
+}
+/**
+ * Determines whether the given terminal rule represents a comment. This is true if the rule is marked
+ * as `hidden` and it does not match white space. This means every hidden token (i.e. excluded from the AST)
+ * that contains visible characters is considered a comment.
+ */
+function isCommentTerminal(terminalRule) {
+    return terminalRule.hidden && !regexpUtils.isWhitespace(terminalRegex(terminalRule));
+}
+/**
+ * Find all CST nodes within the given node that contribute to the specified property.
+ *
+ * @param node A CST node in which to look for property assignments. If this is undefined, the result is an empty array.
+ * @param property A property name of the constructed AST node. If this is undefined, the result is an empty array.
+ */
+function findNodesForProperty(node, property) {
+    if (!node || !property) {
+        return [];
+    }
+    return findNodesForPropertyInternal(node, property, node.astNode, true);
+}
+/**
+ * Find a single CST node within the given node that contributes to the specified property.
+ *
+ * @param node A CST node in which to look for property assignments. If this is undefined, the result is `undefined`.
+ * @param property A property name of the constructed AST node. If this is undefined, the result is `undefined`.
+ * @param index If no index is specified or the index is less than zero, the first found node is returned. If the
+ *        specified index exceeds the number of assignments to the property, the last found node is returned. Otherwise,
+ *        the node with the specified index is returned.
+ */
+function findNodeForProperty(node, property, index) {
+    if (!node || !property) {
+        return undefined;
+    }
+    const nodes = findNodesForPropertyInternal(node, property, node.astNode, true);
+    if (nodes.length === 0) {
+        return undefined;
+    }
+    if (index !== undefined) {
+        index = Math.max(0, Math.min(index, nodes.length - 1));
+    }
+    else {
+        index = 0;
+    }
+    return nodes[index];
+}
+function findNodesForPropertyInternal(node, property, element, first) {
+    if (!first) {
+        const nodeFeature = astUtils.getContainerOfType(node.grammarSource, ast.isAssignment);
+        if (nodeFeature && nodeFeature.feature === property) {
+            return [node];
+        }
+    }
+    if (syntaxTree.isCompositeCstNode(node) && node.astNode === element) {
+        return node.content.flatMap(e => findNodesForPropertyInternal(e, property, element, false));
+    }
+    return [];
+}
+/**
+ * Find a single CST node within the given node that corresponds to the specified keyword.
+ *
+ * @param node A CST node in which to look for keywords. If this is undefined, the result is `undefined`.
+ * @param keyword A keyword as specified in the grammar.
+ * @param index If no index is specified or the index is less than zero, the first found node is returned. If the
+ *        specified index exceeds the number of keyword occurrences, the last found node is returned. Otherwise,
+ *        the node with the specified index is returned.
+ */
+function findNodeForKeyword(node, keyword, index) {
+    if (!node) {
+        return undefined;
+    }
+    const nodes = findNodesForKeywordInternal(node, keyword, node?.astNode);
+    if (nodes.length === 0) {
+        return undefined;
+    }
+    if (index !== undefined) {
+        index = Math.max(0, Math.min(index, nodes.length - 1));
+    }
+    else {
+        index = 0;
+    }
+    return nodes[index];
+}
+function findNodesForKeywordInternal(node, keyword, element) {
+    if (node.astNode !== element) {
+        return [];
+    }
+    if (ast.isKeyword(node.grammarSource) && node.grammarSource.value === keyword) {
+        return [node];
+    }
+    const treeIterator = cstUtils.streamCst(node).iterator();
+    let result;
+    const keywordNodes = [];
+    do {
+        result = treeIterator.next();
+        if (!result.done) {
+            const childNode = result.value;
+            if (childNode.astNode === element) {
+                if (ast.isKeyword(childNode.grammarSource) && childNode.grammarSource.value === keyword) {
+                    keywordNodes.push(childNode);
+                }
+            }
+            else {
+                treeIterator.prune();
+            }
+        }
+    } while (!result.done);
+    return keywordNodes;
+}
+/**
+ * If the given CST node was parsed in the context of a property assignment, the respective `Assignment` grammar
+ * node is returned. If no assignment is found, the result is `undefined`.
+ *
+ * @param cstNode A CST node for which to find a property assignment.
+ */
+function findAssignment(cstNode) {
+    const astNode = cstNode.astNode;
+    // Only search until the ast node of the parent cst node is no longer the original ast node
+    // This would make us jump to a preceding rule call, which contains only unrelated assignments
+    while (astNode === cstNode.container?.astNode) {
+        const assignment = astUtils.getContainerOfType(cstNode.grammarSource, ast.isAssignment);
+        if (assignment) {
+            return assignment;
+        }
+        cstNode = cstNode.container;
+    }
+    return undefined;
+}
+/**
+ * Find an assignment to the `name` property for the given grammar type. This requires the `type` to be inferred
+ * from a parser rule, and that rule must contain an assignment to the `name` property. In all other cases,
+ * this function returns `undefined`.
+ */
+function findNameAssignment(type) {
+    let startNode = type;
+    if (ast.isInferredType(startNode)) {
+        // for inferred types, the location to start searching for the name-assignment is different
+        if (ast.isAction(startNode.$container)) {
+            // a type which is explicitly inferred by an action: investigate the sibling of the Action node, i.e. start searching at the Action's parent
+            startNode = startNode.$container.$container;
+        }
+        else if (ast.isAbstractParserRule(startNode.$container)) {
+            // investigate the parser rule with the explicitly inferred type
+            startNode = startNode.$container;
+        }
+        else {
+            errors.assertUnreachable(startNode.$container);
+        }
+    }
+    return findNameAssignmentInternal(type, startNode, new Map());
+}
+function findNameAssignmentInternal(type, startNode, cache) {
+    // the cache is only required to prevent infinite loops
+    function go(node, refType) {
+        let childAssignment = undefined;
+        const parentAssignment = astUtils.getContainerOfType(node, ast.isAssignment);
+        // No parent assignment implies unassigned rule call
+        if (!parentAssignment) {
+            childAssignment = findNameAssignmentInternal(refType, refType, cache);
+        }
+        cache.set(type, childAssignment);
+        return childAssignment;
+    }
+    if (cache.has(type)) {
+        return cache.get(type);
+    }
+    cache.set(type, undefined);
+    for (const node of astUtils.streamAllContents(startNode)) {
+        if (ast.isAssignment(node) && node.feature.toLowerCase() === 'name') {
+            cache.set(type, node);
+            return node;
+        }
+        else if (ast.isRuleCall(node) && ast.isParserRule(node.rule.ref)) {
+            return go(node, node.rule.ref);
+        }
+        else if (ast.isSimpleType(node) && node.typeRef?.ref) {
+            return go(node, node.typeRef.ref);
+        }
+    }
+    return undefined;
+}
+/**
+ * Determines whether the given parser rule is a _data type rule_, meaning that it has a
+ * primitive return type like `number`, `boolean`, etc.
+ */
+function isDataTypeRule(rule) {
+    return isDataTypeRuleInternal(rule, new Set());
+}
+function isDataTypeRuleInternal(rule, visited) {
+    if (visited.has(rule)) {
+        return true;
+    }
+    else {
+        visited.add(rule);
+    }
+    for (const node of astUtils.streamAllContents(rule)) {
+        if (ast.isRuleCall(node)) {
+            if (!node.rule.ref) {
+                // RuleCall to unresolved rule. Don't assume `rule` is a DataType rule.
+                return false;
+            }
+            if (ast.isParserRule(node.rule.ref) && !isDataTypeRuleInternal(node.rule.ref, visited)) {
+                return false;
+            }
+            if (ast.isInfixRule(node.rule.ref)) {
+                return false;
+            }
+        }
+        else if (ast.isAssignment(node)) {
+            return false;
+        }
+        else if (ast.isAction(node)) {
+            return false;
+        }
+    }
+    return Boolean(rule.definition);
+}
+function getExplicitRuleType(rule) {
+    if (ast.isTerminalRule(rule)) {
+        return undefined;
+    }
+    if (rule.inferredType) {
+        return rule.inferredType.name;
+    }
+    else if (rule.dataType) {
+        return rule.dataType;
+    }
+    else if (rule.returnType) {
+        const refType = rule.returnType.ref;
+        if (refType) {
+            return refType.name;
+        }
+    }
+    return undefined;
+}
+function getTypeName(type) {
+    if (ast.isAbstractParserRule(type)) {
+        return ast.isParserRule(type) && isDataTypeRule(type) ? type.name : getExplicitRuleType(type) ?? type.name;
+    }
+    else if (ast.isInterface(type) || ast.isType(type) || ast.isReturnType(type)) {
+        return type.name;
+    }
+    else if (ast.isAction(type)) {
+        const actionType = getActionType(type);
+        if (actionType) {
+            return actionType;
+        }
+    }
+    else if (ast.isInferredType(type)) {
+        return type.name;
+    }
+    throw new Error('Cannot get name of Unknown Type');
+}
+function getActionType(action) {
+    if (action.inferredType) {
+        return action.inferredType.name;
+    }
+    else if (action.type?.ref) {
+        return getTypeName(action.type.ref);
+    }
+    return undefined; // not inferring and not referencing a valid type
+}
+/**
+ * This function is used at runtime to get the actual type of the values produced by the given rule at runtime.
+ * For data type rules, the name of the declared return type of the rule is returned (if any),
+ * e.g. "INT_value returns number: MY_INT;" returns "number".
+ * @param rule the given rule
+ * @returns the name of the type of the produced values of the rule at runtime
+ */
+function getRuleType(rule) {
+    if (ast.isTerminalRule(rule)) {
+        return rule.type?.name ?? 'string';
+    }
+    else {
+        return getExplicitRuleType(rule) ?? rule.name;
+    }
+}
+function terminalRegex(terminalRule) {
+    const flags = {
+        s: false,
+        i: false,
+        u: false
+    };
+    const source = abstractElementToRegex(terminalRule.definition, flags);
+    const flagText = Object.entries(flags).filter(([, value]) => value).map(([name]) => name).join('');
+    return new RegExp(source, flagText);
+}
+// Using [\s\S]* allows to match everything, compared to . which doesn't match line terminators
+const WILDCARD = /[\s\S]/.source;
+function abstractElementToRegex(element, flags) {
+    if (ast.isTerminalAlternatives(element)) {
+        return terminalAlternativesToRegex(element);
+    }
+    else if (ast.isTerminalGroup(element)) {
+        return terminalGroupToRegex(element);
+    }
+    else if (ast.isCharacterRange(element)) {
+        return characterRangeToRegex(element);
+    }
+    else if (ast.isTerminalRuleCall(element)) {
+        const rule = element.rule.ref;
+        if (!rule) {
+            throw new Error('Missing rule reference.');
+        }
+        return withCardinality(abstractElementToRegex(rule.definition), {
+            cardinality: element.cardinality,
+            lookahead: element.lookahead,
+            parenthesized: element.parenthesized
+        });
+    }
+    else if (ast.isNegatedToken(element)) {
+        return negateTokenToRegex(element);
+    }
+    else if (ast.isUntilToken(element)) {
+        return untilTokenToRegex(element);
+    }
+    else if (ast.isRegexToken(element)) {
+        const lastSlash = element.regex.lastIndexOf('/');
+        const source = element.regex.substring(1, lastSlash);
+        const regexFlags = element.regex.substring(lastSlash + 1);
+        if (flags) {
+            flags.i = regexFlags.includes('i');
+            flags.s = regexFlags.includes('s');
+            flags.u = regexFlags.includes('u');
+        }
+        return withCardinality(source, {
+            cardinality: element.cardinality,
+            lookahead: element.lookahead,
+            parenthesized: element.parenthesized,
+            wrap: false
+        });
+    }
+    else if (ast.isWildcard(element)) {
+        return withCardinality(WILDCARD, {
+            cardinality: element.cardinality,
+            lookahead: element.lookahead,
+            parenthesized: element.parenthesized
+        });
+    }
+    else {
+        throw new Error(`Invalid terminal element: ${element?.$type}, ${element?.$cstNode?.text}`);
+    }
+}
+function terminalAlternativesToRegex(alternatives) {
+    return withCardinality(alternatives.elements.map(e => abstractElementToRegex(e)).join('|'), {
+        cardinality: alternatives.cardinality,
+        lookahead: alternatives.lookahead,
+        parenthesized: alternatives.parenthesized,
+        wrap: false // wrapping is not required for top level alternatives, and nested alternatives are already parenthesized according to the grammar
+    });
+}
+function terminalGroupToRegex(group) {
+    return withCardinality(group.elements.map(e => abstractElementToRegex(e)).join(''), {
+        cardinality: group.cardinality,
+        lookahead: group.lookahead,
+        parenthesized: group.parenthesized,
+        wrap: false // wrapping is not required for top level group, and nested group are already parenthesized according to the grammar
+    });
+}
+function untilTokenToRegex(until) {
+    return withCardinality(`${WILDCARD}*?${abstractElementToRegex(until.terminal)}`, {
+        cardinality: until.cardinality,
+        lookahead: until.lookahead,
+        parenthesized: until.parenthesized
+    });
+}
+function negateTokenToRegex(negate) {
+    return withCardinality(`(?!${abstractElementToRegex(negate.terminal)})${WILDCARD}*?`, {
+        cardinality: negate.cardinality,
+        lookahead: negate.lookahead,
+        parenthesized: negate.parenthesized
+    });
+}
+function characterRangeToRegex(range) {
+    if (range.right) {
+        return withCardinality(`[${keywordToRegex(range.left)}-${keywordToRegex(range.right)}]`, {
+            cardinality: range.cardinality,
+            lookahead: range.lookahead,
+            parenthesized: range.parenthesized,
+            wrap: false
+        });
+    }
+    return withCardinality(keywordToRegex(range.left), {
+        cardinality: range.cardinality,
+        lookahead: range.lookahead,
+        parenthesized: range.parenthesized,
+        wrap: false
+    });
+}
+function keywordToRegex(keyword) {
+    return regexpUtils.escapeRegExp(keyword.value);
+}
+function withCardinality(regex, options) {
+    if (options.parenthesized || options.lookahead || options.wrap !== false) {
+        const groupConfig = options.lookahead ?? (options.parenthesized ? '' : '?:');
+        regex = `(${groupConfig}${regex})`;
+    }
+    if (options.cardinality) {
+        return `${regex}${options.cardinality}`;
+    }
+    return regex;
+}
+
+exports.findAssignment = findAssignment;
+exports.findNameAssignment = findNameAssignment;
+exports.findNodeForKeyword = findNodeForKeyword;
+exports.findNodeForProperty = findNodeForProperty;
+exports.findNodesForKeywordInternal = findNodesForKeywordInternal;
+exports.findNodesForProperty = findNodesForProperty;
+exports.getActionType = getActionType;
+exports.getAllReachableRules = getAllReachableRules;
+exports.getCrossReferenceTerminal = getCrossReferenceTerminal;
+exports.getEntryRule = getEntryRule;
+exports.getExplicitRuleType = getExplicitRuleType;
+exports.getHiddenRules = getHiddenRules;
+exports.getRuleType = getRuleType;
+exports.getTypeName = getTypeName;
+exports.isCommentTerminal = isCommentTerminal;
+exports.isDataTypeRule = isDataTypeRule;
+exports.terminalRegex = terminalRegex;