@windrun-huaiin/third-ui 13.1.4 → 14.0.0

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/token-builder.mjs

@@ -1,121 +0,0 @@
-import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/parser/parser.mjs';
-import { Lexer } from '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/lexer_public.mjs';
-import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/scan/tokens_public.mjs';
-import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs';
-import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/errors_public.mjs';
-import '../../../../../chevrotain@11.1.2/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs';
-import { isTerminalRule, isAbstractParserRule, isKeyword } from '../languages/generated/ast.mjs';
-import { streamAllContents } from '../utils/ast-utils.mjs';
-import { getAllReachableRules, terminalRegex } from '../utils/grammar-utils.mjs';
-import { isWhitespace, escapeRegExp, partialMatches } from '../utils/regexp-utils.mjs';
-import { stream } from '../utils/stream.mjs';
-
-/******************************************************************************
- * 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 DefaultTokenBuilder {
-    constructor() {
-        /**
-         * The list of diagnostics stored during the lexing process of a single text.
-         */
-        this.diagnostics = [];
-    }
-    buildTokens(grammar, options) {
-        const reachableRules = stream(getAllReachableRules(grammar, false));
-        const terminalTokens = this.buildTerminalTokens(reachableRules);
-        const tokens = this.buildKeywordTokens(reachableRules, terminalTokens, options);
-        // Add all terminals tokens to the end in the order they were defined
-        // Chevrotain documentation recommends to add Whitespace-like tokens at the start
-        // However, assuming the lexer is able to optimize the tokens, it should not matter
-        tokens.push(...terminalTokens);
-        // We don't need to add the EOF token explicitly.
-        // It is automatically available at the end of the token stream.
-        return tokens;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    flushLexingReport(text) {
-        return { diagnostics: this.popDiagnostics() };
-    }
-    popDiagnostics() {
-        const diagnostics = [...this.diagnostics];
-        this.diagnostics = [];
-        return diagnostics;
-    }
-    buildTerminalTokens(rules) {
-        return rules.filter(isTerminalRule).filter(e => !e.fragment)
-            .map(terminal => this.buildTerminalToken(terminal)).toArray();
-    }
-    buildTerminalToken(terminal) {
-        const regex = terminalRegex(terminal);
-        const pattern = this.requiresCustomPattern(regex) ? this.regexPatternFunction(regex) : regex;
-        const tokenType = {
-            name: terminal.name,
-            PATTERN: pattern,
-        };
-        if (typeof pattern === 'function') {
-            tokenType.LINE_BREAKS = true;
-        }
-        if (terminal.hidden) {
-            // Only skip tokens that are able to accept whitespace
-            tokenType.GROUP = isWhitespace(regex) ? Lexer.SKIPPED : 'hidden';
-        }
-        return tokenType;
-    }
-    requiresCustomPattern(regex) {
-        if (regex.flags.includes('u') || regex.flags.includes('s')) {
-            // Unicode and dotall regexes are not supported by Chevrotain.
-            return true;
-        }
-        else {
-            return false;
-        }
-    }
-    regexPatternFunction(regex) {
-        const stickyRegex = new RegExp(regex, regex.flags + 'y');
-        return (text, offset) => {
-            stickyRegex.lastIndex = offset;
-            const execResult = stickyRegex.exec(text);
-            return execResult;
-        };
-    }
-    buildKeywordTokens(rules, terminalTokens, options) {
-        return rules
-            // We filter by parser rules, since keywords in terminal rules get transformed into regex and are not actual tokens
-            .filter(isAbstractParserRule)
-            .flatMap(rule => streamAllContents(rule).filter(isKeyword))
-            .distinct(e => e.value).toArray()
-            // Sort keywords by descending length
-            .sort((a, b) => b.value.length - a.value.length)
-            .map(keyword => this.buildKeywordToken(keyword, terminalTokens, Boolean(options?.caseInsensitive)));
-    }
-    buildKeywordToken(keyword, terminalTokens, caseInsensitive) {
-        const keywordPattern = this.buildKeywordPattern(keyword, caseInsensitive);
-        const tokenType = {
-            name: keyword.value,
-            PATTERN: keywordPattern,
-            LONGER_ALT: this.findLongerAlt(keyword, terminalTokens)
-        };
-        if (typeof keywordPattern === 'function') {
-            tokenType.LINE_BREAKS = true;
-        }
-        return tokenType;
-    }
-    buildKeywordPattern(keyword, caseInsensitive) {
-        return caseInsensitive ?
-            new RegExp(escapeRegExp(keyword.value), 'i') :
-            keyword.value;
-    }
-    findLongerAlt(keyword, terminalTokens) {
-        return terminalTokens.reduce((longerAlts, token) => {
-            const pattern = token?.PATTERN;
-            if (pattern?.source && partialMatches('^' + pattern.source + '$', keyword.value)) {
-                longerAlts.push(token);
-            }
-            return longerAlts;
-        }, []);
-    }
-}
-
-export { DefaultTokenBuilder };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/value-converter.js

@@ -1,102 +0,0 @@
-'use strict';
-
-var ast = require('../languages/generated/ast.js');
-var grammarUtils = require('../utils/grammar-utils.js');
-
-/******************************************************************************
- * 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 DefaultValueConverter {
-    convert(input, cstNode) {
-        let feature = cstNode.grammarSource;
-        if (ast.isCrossReference(feature)) {
-            feature = grammarUtils.getCrossReferenceTerminal(feature);
-        }
-        if (ast.isRuleCall(feature)) {
-            const rule = feature.rule.ref;
-            if (!rule) {
-                throw new Error('This cst node was not parsed by a rule.');
-            }
-            return this.runConverter(rule, input, cstNode);
-        }
-        return input;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    runConverter(rule, input, cstNode) {
-        switch (rule.name.toUpperCase()) {
-            case 'INT': return exports.ValueConverter.convertInt(input);
-            case 'STRING': return exports.ValueConverter.convertString(input);
-            case 'ID': return exports.ValueConverter.convertID(input);
-        }
-        switch (grammarUtils.getRuleType(rule)?.toLowerCase()) {
-            case 'number': return exports.ValueConverter.convertNumber(input);
-            case 'boolean': return exports.ValueConverter.convertBoolean(input);
-            case 'bigint': return exports.ValueConverter.convertBigint(input);
-            case 'date': return exports.ValueConverter.convertDate(input);
-            default: return input;
-        }
-    }
-}
-exports.ValueConverter = void 0;
-(function (ValueConverter) {
-    function convertString(input) {
-        let result = '';
-        for (let i = 1; i < input.length - 1; i++) {
-            const c = input.charAt(i);
-            if (c === '\\') {
-                const c1 = input.charAt(++i);
-                result += convertEscapeCharacter(c1);
-            }
-            else {
-                result += c;
-            }
-        }
-        return result;
-    }
-    ValueConverter.convertString = convertString;
-    function convertEscapeCharacter(char) {
-        switch (char) {
-            case 'b': return '\b';
-            case 'f': return '\f';
-            case 'n': return '\n';
-            case 'r': return '\r';
-            case 't': return '\t';
-            case 'v': return '\v';
-            case '0': return '\0';
-            default: return char;
-        }
-    }
-    function convertID(input) {
-        if (input.charAt(0) === '^') {
-            return input.substring(1);
-        }
-        else {
-            return input;
-        }
-    }
-    ValueConverter.convertID = convertID;
-    function convertInt(input) {
-        return parseInt(input);
-    }
-    ValueConverter.convertInt = convertInt;
-    function convertBigint(input) {
-        return BigInt(input);
-    }
-    ValueConverter.convertBigint = convertBigint;
-    function convertDate(input) {
-        return new Date(input);
-    }
-    ValueConverter.convertDate = convertDate;
-    function convertNumber(input) {
-        return Number(input);
-    }
-    ValueConverter.convertNumber = convertNumber;
-    function convertBoolean(input) {
-        return input.toLowerCase() === 'true';
-    }
-    ValueConverter.convertBoolean = convertBoolean;
-})(exports.ValueConverter || (exports.ValueConverter = {}));
-
-exports.DefaultValueConverter = DefaultValueConverter;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/value-converter.mjs

@@ -1,100 +0,0 @@
-import { isCrossReference, isRuleCall } from '../languages/generated/ast.mjs';
-import { getCrossReferenceTerminal, getRuleType } from '../utils/grammar-utils.mjs';
-
-/******************************************************************************
- * 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 DefaultValueConverter {
-    convert(input, cstNode) {
-        let feature = cstNode.grammarSource;
-        if (isCrossReference(feature)) {
-            feature = getCrossReferenceTerminal(feature);
-        }
-        if (isRuleCall(feature)) {
-            const rule = feature.rule.ref;
-            if (!rule) {
-                throw new Error('This cst node was not parsed by a rule.');
-            }
-            return this.runConverter(rule, input, cstNode);
-        }
-        return input;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    runConverter(rule, input, cstNode) {
-        switch (rule.name.toUpperCase()) {
-            case 'INT': return ValueConverter.convertInt(input);
-            case 'STRING': return ValueConverter.convertString(input);
-            case 'ID': return ValueConverter.convertID(input);
-        }
-        switch (getRuleType(rule)?.toLowerCase()) {
-            case 'number': return ValueConverter.convertNumber(input);
-            case 'boolean': return ValueConverter.convertBoolean(input);
-            case 'bigint': return ValueConverter.convertBigint(input);
-            case 'date': return ValueConverter.convertDate(input);
-            default: return input;
-        }
-    }
-}
-var ValueConverter;
-(function (ValueConverter) {
-    function convertString(input) {
-        let result = '';
-        for (let i = 1; i < input.length - 1; i++) {
-            const c = input.charAt(i);
-            if (c === '\\') {
-                const c1 = input.charAt(++i);
-                result += convertEscapeCharacter(c1);
-            }
-            else {
-                result += c;
-            }
-        }
-        return result;
-    }
-    ValueConverter.convertString = convertString;
-    function convertEscapeCharacter(char) {
-        switch (char) {
-            case 'b': return '\b';
-            case 'f': return '\f';
-            case 'n': return '\n';
-            case 'r': return '\r';
-            case 't': return '\t';
-            case 'v': return '\v';
-            case '0': return '\0';
-            default: return char;
-        }
-    }
-    function convertID(input) {
-        if (input.charAt(0) === '^') {
-            return input.substring(1);
-        }
-        else {
-            return input;
-        }
-    }
-    ValueConverter.convertID = convertID;
-    function convertInt(input) {
-        return parseInt(input);
-    }
-    ValueConverter.convertInt = convertInt;
-    function convertBigint(input) {
-        return BigInt(input);
-    }
-    ValueConverter.convertBigint = convertBigint;
-    function convertDate(input) {
-        return new Date(input);
-    }
-    ValueConverter.convertDate = convertDate;
-    function convertNumber(input) {
-        return Number(input);
-    }
-    ValueConverter.convertNumber = convertNumber;
-    function convertBoolean(input) {
-        return input.toLowerCase() === 'true';
-    }
-    ValueConverter.convertBoolean = convertBoolean;
-})(ValueConverter || (ValueConverter = {}));
-
-export { DefaultValueConverter, ValueConverter };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/references/linker.js

@@ -1,290 +0,0 @@
-'use strict';
-
-var syntaxTree = require('../syntax-tree.js');
-var astUtils = require('../utils/ast-utils.js');
-var promiseUtils = require('../utils/promise-utils.js');
-var documents = require('../workspace/documents.js');
-var cancellation = require('../../../../../../../_virtual/cancellation.js');
-
-/******************************************************************************
- * 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.
- ******************************************************************************/
-const RefResolving = Symbol('RefResolving');
-class DefaultLinker {
-    constructor(services) {
-        this.reflection = services.shared.AstReflection;
-        this.langiumDocuments = () => services.shared.workspace.LangiumDocuments;
-        this.scopeProvider = services.references.ScopeProvider;
-        this.astNodeLocator = services.workspace.AstNodeLocator;
-        this.profiler = services.shared.profilers.LangiumProfiler;
-        this.languageId = services.LanguageMetaData.languageId;
-    }
-    async link(document, cancelToken = cancellation.cancellationExports.CancellationToken.None) {
-        if (this.profiler?.isActive('linking')) {
-            const task = this.profiler.createTask('linking', this.languageId);
-            task.start();
-            try {
-                for (const node of astUtils.streamAst(document.parseResult.value)) {
-                    await promiseUtils.interruptAndCheck(cancelToken);
-                    astUtils.streamReferences(node).forEach(ref => {
-                        const name = `${node.$type}:${ref.property}`;
-                        task.startSubTask(name);
-                        try {
-                            this.doLink(ref, document);
-                        }
-                        finally {
-                            task.stopSubTask(name);
-                        }
-                    });
-                }
-            }
-            finally {
-                task.stop();
-            }
-        }
-        else {
-            for (const node of astUtils.streamAst(document.parseResult.value)) {
-                await promiseUtils.interruptAndCheck(cancelToken);
-                astUtils.streamReferences(node).forEach(ref => this.doLink(ref, document));
-            }
-        }
-    }
-    doLink(refInfo, document) {
-        const ref = refInfo.reference;
-        // The reference may already have been resolved lazily by accessing its `ref` property.
-        if ('_ref' in ref && ref._ref === undefined) {
-            ref._ref = RefResolving;
-            try {
-                const description = this.getCandidate(refInfo);
-                if (syntaxTree.isLinkingError(description)) {
-                    ref._ref = description;
-                }
-                else {
-                    ref._nodeDescription = description;
-                    const linkedNode = this.loadAstNode(description);
-                    ref._ref = linkedNode ?? this.createLinkingError(refInfo, description);
-                }
-            }
-            catch (err) {
-                console.error(`An error occurred while resolving reference to '${ref.$refText}':`, err);
-                const errorMessage = err.message ?? String(err);
-                ref._ref = {
-                    info: refInfo,
-                    message: `An error occurred while resolving reference to '${ref.$refText}': ${errorMessage}`
-                };
-            }
-            document.references.push(ref);
-        }
-        else if ('_items' in ref && ref._items === undefined) {
-            ref._items = RefResolving;
-            try {
-                const descriptions = this.getCandidates(refInfo);
-                const items = [];
-                if (syntaxTree.isLinkingError(descriptions)) {
-                    ref._linkingError = descriptions;
-                }
-                else {
-                    for (const description of descriptions) {
-                        const linkedNode = this.loadAstNode(description);
-                        if (linkedNode) {
-                            items.push({ ref: linkedNode, $nodeDescription: description });
-                        }
-                    }
-                }
-                ref._items = items;
-            }
-            catch (err) {
-                ref._linkingError = {
-                    info: refInfo,
-                    message: `An error occurred while resolving reference to '${ref.$refText}': ${err}`
-                };
-                ref._items = [];
-            }
-            document.references.push(ref);
-        }
-    }
-    unlink(document) {
-        for (const ref of document.references) {
-            if ('_ref' in ref) {
-                ref._ref = undefined;
-                delete ref._nodeDescription;
-            }
-            else if ('_items' in ref) {
-                ref._items = undefined;
-                delete ref._linkingError;
-            }
-        }
-        document.references = [];
-    }
-    getCandidate(refInfo) {
-        const scope = this.scopeProvider.getScope(refInfo);
-        const description = scope.getElement(refInfo.reference.$refText);
-        return description ?? this.createLinkingError(refInfo);
-    }
-    getCandidates(refInfo) {
-        const scope = this.scopeProvider.getScope(refInfo);
-        const descriptions = scope.getElements(refInfo.reference.$refText).distinct(desc => `${desc.documentUri}#${desc.path}`).toArray();
-        return descriptions.length > 0 ? descriptions : this.createLinkingError(refInfo);
-    }
-    buildReference(node, property, refNode, refText) {
-        // See behavior description in doc of Linker, update that on changes in here.
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const linker = this;
-        const reference = {
-            $refNode: refNode,
-            $refText: refText,
-            _ref: undefined,
-            get ref() {
-                if (syntaxTree.isAstNode(this._ref)) {
-                    // Most frequent case: the target is already resolved.
-                    return this._ref;
-                }
-                else if (syntaxTree.isAstNodeDescription(this._nodeDescription)) {
-                    // A candidate has been found before, but it is not loaded yet.
-                    const linkedNode = linker.loadAstNode(this._nodeDescription);
-                    this._ref = linkedNode ??
-                        linker.createLinkingError({ reference, container: node, property }, this._nodeDescription);
-                }
-                else if (this._ref === undefined) {
-                    // The reference has not been linked yet, so do that now.
-                    this._ref = RefResolving;
-                    const document = astUtils.findRootNode(node).$document;
-                    const refData = linker.getLinkedNode({ reference, container: node, property });
-                    if (refData.error && document && document.state < documents.DocumentState.ComputedScopes) {
-                        // Document scope is not ready, don't set `this._ref` so linker can retry later.
-                        return this._ref = undefined;
-                    }
-                    this._ref = refData.node ?? refData.error;
-                    this._nodeDescription = refData.descr;
-                    document?.references.push(this);
-                }
-                else if (this._ref === RefResolving) {
-                    linker.throwCyclicReferenceError(node, property, refText);
-                }
-                return syntaxTree.isAstNode(this._ref) ? this._ref : undefined;
-            },
-            get $nodeDescription() {
-                return this._nodeDescription;
-            },
-            get error() {
-                return syntaxTree.isLinkingError(this._ref) ? this._ref : undefined;
-            }
-        };
-        return reference;
-    }
-    buildMultiReference(node, property, refNode, refText) {
-        // See behavior description in doc of Linker, update that on changes in here.
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const linker = this;
-        const reference = {
-            $refNode: refNode,
-            $refText: refText,
-            _items: undefined,
-            get items() {
-                if (Array.isArray(this._items)) {
-                    return this._items;
-                }
-                else if (this._items === undefined) {
-                    this._items = RefResolving;
-                    const document = astUtils.findRootNode(node).$document;
-                    const descriptions = linker.getCandidates({
-                        reference,
-                        container: node,
-                        property
-                    });
-                    const items = [];
-                    if (syntaxTree.isLinkingError(descriptions)) {
-                        this._linkingError = descriptions;
-                    }
-                    else {
-                        for (const description of descriptions) {
-                            const linkedNode = linker.loadAstNode(description);
-                            if (linkedNode) {
-                                items.push({ ref: linkedNode, $nodeDescription: description });
-                            }
-                        }
-                    }
-                    this._items = items;
-                    document?.references.push(this);
-                }
-                else if (this._items === RefResolving) {
-                    linker.throwCyclicReferenceError(node, property, refText);
-                }
-                return Array.isArray(this._items) ? this._items : [];
-            },
-            get error() {
-                if (this._linkingError) {
-                    return this._linkingError;
-                }
-                const refs = this.items;
-                if (refs.length > 0) {
-                    return undefined;
-                }
-                else {
-                    return (this._linkingError = linker.createLinkingError({ reference, container: node, property }));
-                }
-            }
-        };
-        return reference;
-    }
-    throwCyclicReferenceError(node, property, refText) {
-        throw new Error(`Cyclic reference resolution detected: ${this.astNodeLocator.getAstNodePath(node)}/${property} (symbol '${refText}')`);
-    }
-    getLinkedNode(refInfo) {
-        try {
-            const description = this.getCandidate(refInfo);
-            if (syntaxTree.isLinkingError(description)) {
-                return { error: description };
-            }
-            const linkedNode = this.loadAstNode(description);
-            if (linkedNode) {
-                return { node: linkedNode, descr: description };
-            }
-            else {
-                return {
-                    descr: description,
-                    error: this.createLinkingError(refInfo, description)
-                };
-            }
-        }
-        catch (err) {
-            console.error(`An error occurred while resolving reference to '${refInfo.reference.$refText}':`, err);
-            const errorMessage = err.message ?? String(err);
-            return {
-                error: {
-                    info: refInfo,
-                    message: `An error occurred while resolving reference to '${refInfo.reference.$refText}': ${errorMessage}`
-                }
-            };
-        }
-    }
-    loadAstNode(nodeDescription) {
-        if (nodeDescription.node) {
-            return nodeDescription.node;
-        }
-        const doc = this.langiumDocuments().getDocument(nodeDescription.documentUri);
-        if (!doc) {
-            return undefined;
-        }
-        return this.astNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);
-    }
-    createLinkingError(refInfo, targetDescription) {
-        // Check whether the document is sufficiently processed by the DocumentBuilder. If not, this is a hint for a bug
-        // in the language implementation.
-        const document = astUtils.findRootNode(refInfo.container).$document;
-        if (document && document.state < documents.DocumentState.ComputedScopes) {
-            console.warn(`Attempted reference resolution before document reached ComputedScopes state (${document.uri}).`);
-        }
-        const referenceType = this.reflection.getReferenceType(refInfo);
-        return {
-            info: refInfo,
-            message: `Could not resolve reference to ${referenceType} named '${refInfo.reference.$refText}'.`,
-            targetDescription
-        };
-    }
-}
-
-exports.DefaultLinker = DefaultLinker;
-exports.RefResolving = RefResolving;