@windrun-huaiin/third-ui 12.1.0 → 13.0.1

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

@@ -0,0 +1,31 @@
+'use strict';
+
+var cstUtils = require('../utils/cst-utils.js');
+var grammarUtils = require('../utils/grammar-utils.js');
+var regexpUtils = require('../utils/regexp-utils.js');
+var ast = require('./generated/ast.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.
+ ******************************************************************************/
+/**
+ * Create the default grammar configuration (used by `createDefaultModule`). This can be overridden in a
+ * language-specific module.
+ */
+function createGrammarConfig(services) {
+    const rules = [];
+    const grammar = services.Grammar;
+    for (const rule of grammar.rules) {
+        if (ast.isTerminalRule(rule) && grammarUtils.isCommentTerminal(rule) && regexpUtils.isMultilineComment(grammarUtils.terminalRegex(rule))) {
+            rules.push(rule.name);
+        }
+    }
+    return {
+        multilineCommentRules: rules,
+        nameRegexp: cstUtils.DefaultNameRegexp
+    };
+}
+
+exports.createGrammarConfig = createGrammarConfig;

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/languages/grammar-config.mjs

@@ -0,0 +1,29 @@
+import { DefaultNameRegexp } from '../utils/cst-utils.mjs';
+import { isCommentTerminal, terminalRegex } from '../utils/grammar-utils.mjs';
+import { isMultilineComment } from '../utils/regexp-utils.mjs';
+import { isTerminalRule } from './generated/ast.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.
+ ******************************************************************************/
+/**
+ * Create the default grammar configuration (used by `createDefaultModule`). This can be overridden in a
+ * language-specific module.
+ */
+function createGrammarConfig(services) {
+    const rules = [];
+    const grammar = services.Grammar;
+    for (const rule of grammar.rules) {
+        if (isTerminalRule(rule) && isCommentTerminal(rule) && isMultilineComment(terminalRegex(rule))) {
+            rules.push(rule.name);
+        }
+    }
+    return {
+        multilineCommentRules: rules,
+        nameRegexp: DefaultNameRegexp
+    };
+}
+
+export { createGrammarConfig };

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

@@ -0,0 +1,23 @@
+'use strict';
+
+/******************************************************************************
+ * 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.
+ ******************************************************************************/
+/**
+ * Default implementation of the async parser which simply wraps the sync parser in a promise.
+ *
+ * @remarks
+ * A real implementation would create worker threads or web workers to offload the parsing work.
+ */
+class DefaultAsyncParser {
+    constructor(services) {
+        this.syncParser = services.parser.LangiumParser;
+    }
+    parse(text, _cancelToken) {
+        return Promise.resolve(this.syncParser.parse(text));
+    }
+}
+
+exports.DefaultAsyncParser = DefaultAsyncParser;

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

@@ -0,0 +1,21 @@
+/******************************************************************************
+ * 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.
+ ******************************************************************************/
+/**
+ * Default implementation of the async parser which simply wraps the sync parser in a promise.
+ *
+ * @remarks
+ * A real implementation would create worker threads or web workers to offload the parsing work.
+ */
+class DefaultAsyncParser {
+    constructor(services) {
+        this.syncParser = services.parser.LangiumParser;
+    }
+    parse(text, _cancelToken) {
+        return Promise.resolve(this.syncParser.parse(text));
+    }
+}
+
+export { DefaultAsyncParser };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/completion-parser-builder.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var langiumParser = require('./langium-parser.js');
+var parserBuilderBase = require('./parser-builder-base.js');
+
+/******************************************************************************
+ * Copyright 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.
+ ******************************************************************************/
+function createCompletionParser(services) {
+    const grammar = services.Grammar;
+    const lexer = services.parser.Lexer;
+    const parser = new langiumParser.LangiumCompletionParser(services);
+    parserBuilderBase.createParser(grammar, parser, lexer.definition);
+    parser.finalize();
+    return parser;
+}
+
+exports.createCompletionParser = createCompletionParser;

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

@@ -0,0 +1,18 @@
+import { LangiumCompletionParser } from './langium-parser.mjs';
+import { createParser } from './parser-builder-base.mjs';
+
+/******************************************************************************
+ * Copyright 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.
+ ******************************************************************************/
+function createCompletionParser(services) {
+    const grammar = services.Grammar;
+    const lexer = services.parser.Lexer;
+    const parser = new LangiumCompletionParser(services);
+    createParser(grammar, parser, lexer.definition);
+    parser.finalize();
+    return parser;
+}
+
+export { createCompletionParser };

package/dist/node_modules/.pnpm/langium@4.2.1/node_modules/langium/lib/parser/cst-node-builder.js

@@ -0,0 +1,231 @@
+'use strict';
+
+var main = require('../../../../../vscode-languageserver-types@3.17.5/node_modules/vscode-languageserver-types/lib/esm/main.js');
+var cstUtils = require('../utils/cst-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 CstNodeBuilder {
+    constructor() {
+        this.nodeStack = [];
+    }
+    get current() {
+        return this.nodeStack[this.nodeStack.length - 1] ?? this.rootNode;
+    }
+    buildRootNode(input) {
+        this.rootNode = new RootCstNodeImpl(input);
+        this.rootNode.root = this.rootNode;
+        this.nodeStack = [this.rootNode];
+        return this.rootNode;
+    }
+    buildCompositeNode(feature) {
+        const compositeNode = new CompositeCstNodeImpl();
+        compositeNode.grammarSource = feature;
+        compositeNode.root = this.rootNode;
+        this.current.content.push(compositeNode);
+        this.nodeStack.push(compositeNode);
+        return compositeNode;
+    }
+    buildLeafNode(token, feature) {
+        const leafNode = new LeafCstNodeImpl(token.startOffset, token.image.length, cstUtils.tokenToRange(token), token.tokenType, !feature);
+        leafNode.grammarSource = feature;
+        leafNode.root = this.rootNode;
+        this.current.content.push(leafNode);
+        return leafNode;
+    }
+    removeNode(node) {
+        const parent = node.container;
+        if (parent) {
+            const index = parent.content.indexOf(node);
+            if (index >= 0) {
+                parent.content.splice(index, 1);
+            }
+        }
+    }
+    addHiddenNodes(tokens) {
+        const nodes = [];
+        for (const token of tokens) {
+            const leafNode = new LeafCstNodeImpl(token.startOffset, token.image.length, cstUtils.tokenToRange(token), token.tokenType, true);
+            leafNode.root = this.rootNode;
+            nodes.push(leafNode);
+        }
+        let current = this.current;
+        let added = false;
+        // If we are within a composite node, we add the hidden nodes to the content
+        if (current.content.length > 0) {
+            current.content.push(...nodes);
+            return;
+        }
+        // Otherwise we are at a newly created node
+        // Instead of adding the hidden nodes here, we search for the first parent node with content
+        while (current.container) {
+            const index = current.container.content.indexOf(current);
+            if (index > 0) {
+                // Add the hidden nodes before the current node
+                current.container.content.splice(index, 0, ...nodes);
+                added = true;
+                break;
+            }
+            current = current.container;
+        }
+        // If we arrive at the root node, we add the hidden nodes at the beginning
+        // This is the case if the hidden nodes are the first nodes in the tree
+        if (!added) {
+            this.rootNode.content.unshift(...nodes);
+        }
+    }
+    construct(item) {
+        const current = this.current;
+        // The specified item could be a datatype ($type is symbol), fragment ($type is undefined) or infix rule ($infix is true)
+        // Only if the $type is a string, we actually assign the element
+        if (typeof item.$type === 'string' && !item.$infixName) {
+            this.current.astNode = item;
+        }
+        item.$cstNode = current;
+        const node = this.nodeStack.pop();
+        // Empty composite nodes are not valid
+        // Simply remove the node from the tree
+        if (node?.content.length === 0) {
+            this.removeNode(node);
+        }
+    }
+}
+class AbstractCstNode {
+    get hidden() {
+        return false;
+    }
+    get astNode() {
+        const node = typeof this._astNode?.$type === 'string' ? this._astNode : this.container?.astNode;
+        if (!node) {
+            throw new Error('This node has no associated AST element');
+        }
+        return node;
+    }
+    set astNode(value) {
+        this._astNode = value;
+    }
+    get text() {
+        return this.root.fullText.substring(this.offset, this.end);
+    }
+}
+class LeafCstNodeImpl extends AbstractCstNode {
+    get offset() {
+        return this._offset;
+    }
+    get length() {
+        return this._length;
+    }
+    get end() {
+        return this._offset + this._length;
+    }
+    get hidden() {
+        return this._hidden;
+    }
+    get tokenType() {
+        return this._tokenType;
+    }
+    get range() {
+        return this._range;
+    }
+    constructor(offset, length, range, tokenType, hidden = false) {
+        super();
+        this._hidden = hidden;
+        this._offset = offset;
+        this._tokenType = tokenType;
+        this._length = length;
+        this._range = range;
+    }
+}
+class CompositeCstNodeImpl extends AbstractCstNode {
+    constructor() {
+        super(...arguments);
+        this.content = new CstNodeContainer(this);
+    }
+    get offset() {
+        return this.firstNonHiddenNode?.offset ?? 0;
+    }
+    get length() {
+        return this.end - this.offset;
+    }
+    get end() {
+        return this.lastNonHiddenNode?.end ?? 0;
+    }
+    get range() {
+        const firstNode = this.firstNonHiddenNode;
+        const lastNode = this.lastNonHiddenNode;
+        if (firstNode && lastNode) {
+            if (this._rangeCache === undefined) {
+                const { range: firstRange } = firstNode;
+                const { range: lastRange } = lastNode;
+                this._rangeCache = { start: firstRange.start, end: lastRange.end.line < firstRange.start.line ? firstRange.start : lastRange.end };
+            }
+            return this._rangeCache;
+        }
+        else {
+            return { start: main.Position.create(0, 0), end: main.Position.create(0, 0) };
+        }
+    }
+    get firstNonHiddenNode() {
+        for (const child of this.content) {
+            if (!child.hidden) {
+                return child;
+            }
+        }
+        return this.content[0];
+    }
+    get lastNonHiddenNode() {
+        for (let i = this.content.length - 1; i >= 0; i--) {
+            const child = this.content[i];
+            if (!child.hidden) {
+                return child;
+            }
+        }
+        return this.content[this.content.length - 1];
+    }
+}
+class CstNodeContainer extends Array {
+    constructor(parent) {
+        super();
+        this.parent = parent;
+        Object.setPrototypeOf(this, CstNodeContainer.prototype);
+    }
+    push(...items) {
+        this.addParents(items);
+        return super.push(...items);
+    }
+    unshift(...items) {
+        this.addParents(items);
+        return super.unshift(...items);
+    }
+    splice(start, count, ...items) {
+        this.addParents(items);
+        return super.splice(start, count, ...items);
+    }
+    addParents(items) {
+        for (const item of items) {
+            item.container = this.parent;
+        }
+    }
+}
+class RootCstNodeImpl extends CompositeCstNodeImpl {
+    get text() {
+        return this._text.substring(this.offset, this.end);
+    }
+    get fullText() {
+        return this._text;
+    }
+    constructor(input) {
+        super();
+        this._text = '';
+        this._text = input ?? '';
+    }
+}
+
+exports.AbstractCstNode = AbstractCstNode;
+exports.CompositeCstNodeImpl = CompositeCstNodeImpl;
+exports.CstNodeBuilder = CstNodeBuilder;
+exports.LeafCstNodeImpl = LeafCstNodeImpl;
+exports.RootCstNodeImpl = RootCstNodeImpl;

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

@@ -0,0 +1,225 @@
+import { Position } from '../../../../../vscode-languageserver-types@3.17.5/node_modules/vscode-languageserver-types/lib/esm/main.mjs';
+import { tokenToRange } from '../utils/cst-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 CstNodeBuilder {
+    constructor() {
+        this.nodeStack = [];
+    }
+    get current() {
+        return this.nodeStack[this.nodeStack.length - 1] ?? this.rootNode;
+    }
+    buildRootNode(input) {
+        this.rootNode = new RootCstNodeImpl(input);
+        this.rootNode.root = this.rootNode;
+        this.nodeStack = [this.rootNode];
+        return this.rootNode;
+    }
+    buildCompositeNode(feature) {
+        const compositeNode = new CompositeCstNodeImpl();
+        compositeNode.grammarSource = feature;
+        compositeNode.root = this.rootNode;
+        this.current.content.push(compositeNode);
+        this.nodeStack.push(compositeNode);
+        return compositeNode;
+    }
+    buildLeafNode(token, feature) {
+        const leafNode = new LeafCstNodeImpl(token.startOffset, token.image.length, tokenToRange(token), token.tokenType, !feature);
+        leafNode.grammarSource = feature;
+        leafNode.root = this.rootNode;
+        this.current.content.push(leafNode);
+        return leafNode;
+    }
+    removeNode(node) {
+        const parent = node.container;
+        if (parent) {
+            const index = parent.content.indexOf(node);
+            if (index >= 0) {
+                parent.content.splice(index, 1);
+            }
+        }
+    }
+    addHiddenNodes(tokens) {
+        const nodes = [];
+        for (const token of tokens) {
+            const leafNode = new LeafCstNodeImpl(token.startOffset, token.image.length, tokenToRange(token), token.tokenType, true);
+            leafNode.root = this.rootNode;
+            nodes.push(leafNode);
+        }
+        let current = this.current;
+        let added = false;
+        // If we are within a composite node, we add the hidden nodes to the content
+        if (current.content.length > 0) {
+            current.content.push(...nodes);
+            return;
+        }
+        // Otherwise we are at a newly created node
+        // Instead of adding the hidden nodes here, we search for the first parent node with content
+        while (current.container) {
+            const index = current.container.content.indexOf(current);
+            if (index > 0) {
+                // Add the hidden nodes before the current node
+                current.container.content.splice(index, 0, ...nodes);
+                added = true;
+                break;
+            }
+            current = current.container;
+        }
+        // If we arrive at the root node, we add the hidden nodes at the beginning
+        // This is the case if the hidden nodes are the first nodes in the tree
+        if (!added) {
+            this.rootNode.content.unshift(...nodes);
+        }
+    }
+    construct(item) {
+        const current = this.current;
+        // The specified item could be a datatype ($type is symbol), fragment ($type is undefined) or infix rule ($infix is true)
+        // Only if the $type is a string, we actually assign the element
+        if (typeof item.$type === 'string' && !item.$infixName) {
+            this.current.astNode = item;
+        }
+        item.$cstNode = current;
+        const node = this.nodeStack.pop();
+        // Empty composite nodes are not valid
+        // Simply remove the node from the tree
+        if (node?.content.length === 0) {
+            this.removeNode(node);
+        }
+    }
+}
+class AbstractCstNode {
+    get hidden() {
+        return false;
+    }
+    get astNode() {
+        const node = typeof this._astNode?.$type === 'string' ? this._astNode : this.container?.astNode;
+        if (!node) {
+            throw new Error('This node has no associated AST element');
+        }
+        return node;
+    }
+    set astNode(value) {
+        this._astNode = value;
+    }
+    get text() {
+        return this.root.fullText.substring(this.offset, this.end);
+    }
+}
+class LeafCstNodeImpl extends AbstractCstNode {
+    get offset() {
+        return this._offset;
+    }
+    get length() {
+        return this._length;
+    }
+    get end() {
+        return this._offset + this._length;
+    }
+    get hidden() {
+        return this._hidden;
+    }
+    get tokenType() {
+        return this._tokenType;
+    }
+    get range() {
+        return this._range;
+    }
+    constructor(offset, length, range, tokenType, hidden = false) {
+        super();
+        this._hidden = hidden;
+        this._offset = offset;
+        this._tokenType = tokenType;
+        this._length = length;
+        this._range = range;
+    }
+}
+class CompositeCstNodeImpl extends AbstractCstNode {
+    constructor() {
+        super(...arguments);
+        this.content = new CstNodeContainer(this);
+    }
+    get offset() {
+        return this.firstNonHiddenNode?.offset ?? 0;
+    }
+    get length() {
+        return this.end - this.offset;
+    }
+    get end() {
+        return this.lastNonHiddenNode?.end ?? 0;
+    }
+    get range() {
+        const firstNode = this.firstNonHiddenNode;
+        const lastNode = this.lastNonHiddenNode;
+        if (firstNode && lastNode) {
+            if (this._rangeCache === undefined) {
+                const { range: firstRange } = firstNode;
+                const { range: lastRange } = lastNode;
+                this._rangeCache = { start: firstRange.start, end: lastRange.end.line < firstRange.start.line ? firstRange.start : lastRange.end };
+            }
+            return this._rangeCache;
+        }
+        else {
+            return { start: Position.create(0, 0), end: Position.create(0, 0) };
+        }
+    }
+    get firstNonHiddenNode() {
+        for (const child of this.content) {
+            if (!child.hidden) {
+                return child;
+            }
+        }
+        return this.content[0];
+    }
+    get lastNonHiddenNode() {
+        for (let i = this.content.length - 1; i >= 0; i--) {
+            const child = this.content[i];
+            if (!child.hidden) {
+                return child;
+            }
+        }
+        return this.content[this.content.length - 1];
+    }
+}
+class CstNodeContainer extends Array {
+    constructor(parent) {
+        super();
+        this.parent = parent;
+        Object.setPrototypeOf(this, CstNodeContainer.prototype);
+    }
+    push(...items) {
+        this.addParents(items);
+        return super.push(...items);
+    }
+    unshift(...items) {
+        this.addParents(items);
+        return super.unshift(...items);
+    }
+    splice(start, count, ...items) {
+        this.addParents(items);
+        return super.splice(start, count, ...items);
+    }
+    addParents(items) {
+        for (const item of items) {
+            item.container = this.parent;
+        }
+    }
+}
+class RootCstNodeImpl extends CompositeCstNodeImpl {
+    get text() {
+        return this._text.substring(this.offset, this.end);
+    }
+    get fullText() {
+        return this._text;
+    }
+    constructor(input) {
+        super();
+        this._text = '';
+        this._text = input ?? '';
+    }
+}
+
+export { AbstractCstNode, CompositeCstNodeImpl, CstNodeBuilder, LeafCstNodeImpl, RootCstNodeImpl };

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

@@ -0,0 +1,32 @@
+'use strict';
+
+var langiumParser = require('./langium-parser.js');
+var parserBuilderBase = require('./parser-builder-base.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.
+ ******************************************************************************/
+/**
+ * Create and finalize a Langium parser. The parser rules are derived from the grammar, which is
+ * available at `services.Grammar`.
+ */
+function createLangiumParser(services) {
+    const parser = prepareLangiumParser(services);
+    parser.finalize();
+    return parser;
+}
+/**
+ * Create a Langium parser without finalizing it. This is used to extract more detailed error
+ * information when the parser is initially validated.
+ */
+function prepareLangiumParser(services) {
+    const grammar = services.Grammar;
+    const lexer = services.parser.Lexer;
+    const parser = new langiumParser.LangiumParser(services);
+    return parserBuilderBase.createParser(grammar, parser, lexer.definition);
+}
+
+exports.createLangiumParser = createLangiumParser;
+exports.prepareLangiumParser = prepareLangiumParser;

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

@@ -0,0 +1,29 @@
+import { LangiumParser } from './langium-parser.mjs';
+import { createParser } from './parser-builder-base.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.
+ ******************************************************************************/
+/**
+ * Create and finalize a Langium parser. The parser rules are derived from the grammar, which is
+ * available at `services.Grammar`.
+ */
+function createLangiumParser(services) {
+    const parser = prepareLangiumParser(services);
+    parser.finalize();
+    return parser;
+}
+/**
+ * Create a Langium parser without finalizing it. This is used to extract more detailed error
+ * information when the parser is initially validated.
+ */
+function prepareLangiumParser(services) {
+    const grammar = services.Grammar;
+    const lexer = services.parser.Lexer;
+    const parser = new LangiumParser(services);
+    return createParser(grammar, parser, lexer.definition);
+}
+
+export { createLangiumParser, prepareLangiumParser };