qidian-vue-ui 1.1.50 → 1.1.51

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/grammar-utils.mjs.map

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

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/promise-utils.mjs

@@ -0,0 +1,57 @@
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+function delayNextTick() {
+  return new Promise((resolve) => {
+    if (typeof setImmediate === "undefined") {
+      setTimeout(resolve, 0);
+    } else {
+      setImmediate(resolve);
+    }
+  });
+}
+let lastTick = 0;
+let globalInterruptionPeriod = 10;
+function startCancelableOperation() {
+  lastTick = performance.now();
+  return new cancellationExports.CancellationTokenSource();
+}
+const OperationCancelled = Symbol("OperationCancelled");
+function isOperationCancelled(err) {
+  return err === OperationCancelled;
+}
+async function interruptAndCheck(token) {
+  if (token === cancellationExports.CancellationToken.None) {
+    return;
+  }
+  const current = performance.now();
+  if (current - lastTick >= globalInterruptionPeriod) {
+    lastTick = current;
+    await delayNextTick();
+    lastTick = performance.now();
+  }
+  if (token.isCancellationRequested) {
+    throw OperationCancelled;
+  }
+}
+class Deferred {
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = (arg) => {
+        resolve(arg);
+        return this;
+      };
+      this.reject = (err) => {
+        reject(err);
+        return this;
+      };
+    });
+  }
+}
+export {
+  Deferred,
+  OperationCancelled,
+  delayNextTick,
+  interruptAndCheck,
+  isOperationCancelled,
+  startCancelableOperation
+};
+//# sourceMappingURL=promise-utils.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/promise-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-utils.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/promise-utils.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, CancellationTokenSource } from '../utils/cancellation.js';\n/**\n * Delays the execution of the current code to the next tick of the event loop.\n * Don't call this method directly in a tight loop to prevent too many promises from being created.\n */\nexport function delayNextTick() {\n    return new Promise(resolve => {\n        // In case we are running in a non-node environment, `setImmediate` isn't available.\n        // Using `setTimeout` of the browser API accomplishes the same result.\n        if (typeof setImmediate === 'undefined') {\n            setTimeout(resolve, 0);\n        }\n        else {\n            setImmediate(resolve);\n        }\n    });\n}\nlet lastTick = 0;\nlet globalInterruptionPeriod = 10;\n/**\n * Reset the global interruption period and create a cancellation token source.\n */\nexport function startCancelableOperation() {\n    lastTick = performance.now();\n    return new CancellationTokenSource();\n}\n/**\n * Change the period duration for `interruptAndCheck` to the given number of milliseconds.\n * The default value is 10ms.\n */\nexport function setInterruptionPeriod(period) {\n    globalInterruptionPeriod = period;\n}\n/**\n * This symbol may be thrown in an asynchronous context by any Langium service that receives\n * a `CancellationToken`. This means that the promise returned by such a service is rejected with\n * this symbol as rejection reason.\n */\nexport const OperationCancelled = Symbol('OperationCancelled');\n/**\n * Use this in a `catch` block to check whether the thrown object indicates that the operation\n * has been cancelled.\n */\nexport function isOperationCancelled(err) {\n    return err === OperationCancelled;\n}\n/**\n * This function does two things:\n *  1. Check the elapsed time since the last call to this function or to `startCancelableOperation`. If the predefined\n *     period (configured with `setInterruptionPeriod`) is exceeded, execution is delayed with `delayNextTick`.\n *  2. If the predefined period is not met yet or execution is resumed after an interruption, the given cancellation\n *     token is checked, and if cancellation is requested, `OperationCanceled` is thrown.\n *\n * All services in Langium that receive a `CancellationToken` may potentially call this function, so the\n * `CancellationToken` must be caught (with an `async` try-catch block or a `catch` callback attached to\n * the promise) to avoid that event being exposed as an error.\n */\nexport async function interruptAndCheck(token) {\n    if (token === CancellationToken.None) {\n        // Early exit in case cancellation was disabled by the caller\n        return;\n    }\n    const current = performance.now();\n    if (current - lastTick >= globalInterruptionPeriod) {\n        lastTick = current;\n        await delayNextTick();\n        // prevent calling delayNextTick every iteration of loop\n        // where delayNextTick takes up the majority or all of the\n        // globalInterruptionPeriod itself\n        lastTick = performance.now();\n    }\n    if (token.isCancellationRequested) {\n        throw OperationCancelled;\n    }\n}\n/**\n * Simple implementation of the deferred pattern.\n * An object that exposes a promise and functions to resolve and reject it.\n */\nexport class Deferred {\n    constructor() {\n        this.promise = new Promise((resolve, reject) => {\n            this.resolve = (arg) => {\n                resolve(arg);\n                return this;\n            };\n            this.reject = (err) => {\n                reject(err);\n                return this;\n            };\n        });\n    }\n}\n//# sourceMappingURL=promise-utils.js.map"],"names":["CancellationTokenSource","CancellationToken"],"mappings":";AAUO,SAAS,gBAAgB;AAC5B,SAAO,IAAI,QAAQ,aAAW;AAG1B,QAAI,OAAO,iBAAiB,aAAa;AACrC,iBAAW,SAAS,CAAC;AAAA,IACzB,OACK;AACD,mBAAa,OAAO;AAAA,IACxB;AAAA,EACJ,CAAC;AACL;AACA,IAAI,WAAW;AACf,IAAI,2BAA2B;AAIxB,SAAS,2BAA2B;AACvC,aAAW,YAAY,IAAG;AAC1B,SAAO,IAAIA,oBAAAA,wBAAuB;AACtC;AAaY,MAAC,qBAAqB,OAAO,oBAAoB;AAKtD,SAAS,qBAAqB,KAAK;AACtC,SAAO,QAAQ;AACnB;AAYO,eAAe,kBAAkB,OAAO;AAC3C,MAAI,UAAUC,oBAAAA,kBAAkB,MAAM;AAElC;AAAA,EACJ;AACA,QAAM,UAAU,YAAY,IAAG;AAC/B,MAAI,UAAU,YAAY,0BAA0B;AAChD,eAAW;AACX,UAAM,cAAa;AAInB,eAAW,YAAY,IAAG;AAAA,EAC9B;AACA,MAAI,MAAM,yBAAyB;AAC/B,UAAM;AAAA,EACV;AACJ;AAKO,MAAM,SAAS;AAAA,EAClB,cAAc;AACV,SAAK,UAAU,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC5C,WAAK,UAAU,CAAC,QAAQ;AACpB,gBAAQ,GAAG;AACX,eAAO;AAAA,MACX;AACA,WAAK,SAAS,CAAC,QAAQ;AACnB,eAAO,GAAG;AACV,eAAO;AAAA,MACX;AAAA,IACJ,CAAC;AAAA,EACL;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/regexp-utils.mjs

@@ -0,0 +1,240 @@
+import { RegExpParser } from "../../../../../@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.mjs";
+import { BaseRegExpVisitor } from "../../../../../@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.mjs";
+const NEWLINE_REGEXP = /\r?\n/gm;
+const regexpParser = new RegExpParser();
+class TerminalRegExpVisitor extends BaseRegExpVisitor {
+  constructor() {
+    super(...arguments);
+    this.isStarting = true;
+    this.endRegexpStack = [];
+    this.multiline = false;
+  }
+  get endRegex() {
+    return this.endRegexpStack.join("");
+  }
+  reset(regex) {
+    this.multiline = false;
+    this.regex = regex;
+    this.startRegexp = "";
+    this.isStarting = true;
+    this.endRegexpStack = [];
+  }
+  visitGroup(node) {
+    if (node.quantifier) {
+      this.isStarting = false;
+      this.endRegexpStack = [];
+    }
+  }
+  visitCharacter(node) {
+    const char = String.fromCharCode(node.value);
+    if (!this.multiline && char === "\n") {
+      this.multiline = true;
+    }
+    if (node.quantifier) {
+      this.isStarting = false;
+      this.endRegexpStack = [];
+    } else {
+      const escapedChar = escapeRegExp(char);
+      this.endRegexpStack.push(escapedChar);
+      if (this.isStarting) {
+        this.startRegexp += escapedChar;
+      }
+    }
+  }
+  visitSet(node) {
+    if (!this.multiline) {
+      const set = this.regex.substring(node.loc.begin, node.loc.end);
+      const regex = new RegExp(set);
+      this.multiline = Boolean("\n".match(regex));
+    }
+    if (node.quantifier) {
+      this.isStarting = false;
+      this.endRegexpStack = [];
+    } else {
+      const set = this.regex.substring(node.loc.begin, node.loc.end);
+      this.endRegexpStack.push(set);
+      if (this.isStarting) {
+        this.startRegexp += set;
+      }
+    }
+  }
+  visitChildren(node) {
+    if (node.type === "Group") {
+      const group = node;
+      if (group.quantifier) {
+        return;
+      }
+    }
+    super.visitChildren(node);
+  }
+}
+const visitor = new TerminalRegExpVisitor();
+function isMultilineComment(regexp) {
+  try {
+    if (typeof regexp === "string") {
+      regexp = new RegExp(regexp);
+    }
+    regexp = regexp.toString();
+    visitor.reset(regexp);
+    visitor.visit(regexpParser.pattern(regexp));
+    return visitor.multiline;
+  } catch (_a) {
+    return false;
+  }
+}
+const whitespaceCharacters = "\f\n\r	\v              \u2028\u2029  　\uFEFF".split("");
+function isWhitespace(value) {
+  const regexp = typeof value === "string" ? new RegExp(value) : value;
+  return whitespaceCharacters.some((ws) => regexp.test(ws));
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getCaseInsensitivePattern(keyword) {
+  return Array.prototype.map.call(keyword, (letter) => /\w/.test(letter) ? `[${letter.toLowerCase()}${letter.toUpperCase()}]` : escapeRegExp(letter)).join("");
+}
+function partialMatches(regex, input) {
+  const partial = partialRegExp(regex);
+  const match = input.match(partial);
+  return !!match && match[0].length > 0;
+}
+function partialRegExp(regex) {
+  if (typeof regex === "string") {
+    regex = new RegExp(regex);
+  }
+  const re = regex, source = regex.source;
+  let i = 0;
+  function process() {
+    let result = "", tmp;
+    function appendRaw(nbChars) {
+      result += source.substr(i, nbChars);
+      i += nbChars;
+    }
+    function appendOptional(nbChars) {
+      result += "(?:" + source.substr(i, nbChars) + "|$)";
+      i += nbChars;
+    }
+    while (i < source.length) {
+      switch (source[i]) {
+        case "\\":
+          switch (source[i + 1]) {
+            case "c":
+              appendOptional(3);
+              break;
+            case "x":
+              appendOptional(4);
+              break;
+            case "u":
+              if (re.unicode) {
+                if (source[i + 2] === "{") {
+                  appendOptional(source.indexOf("}", i) - i + 1);
+                } else {
+                  appendOptional(6);
+                }
+              } else {
+                appendOptional(2);
+              }
+              break;
+            case "p":
+            case "P":
+              if (re.unicode) {
+                appendOptional(source.indexOf("}", i) - i + 1);
+              } else {
+                appendOptional(2);
+              }
+              break;
+            case "k":
+              appendOptional(source.indexOf(">", i) - i + 1);
+              break;
+            default:
+              appendOptional(2);
+              break;
+          }
+          break;
+        case "[":
+          tmp = /\[(?:\\.|.)*?\]/g;
+          tmp.lastIndex = i;
+          tmp = tmp.exec(source) || [];
+          appendOptional(tmp[0].length);
+          break;
+        case "|":
+        case "^":
+        case "$":
+        case "*":
+        case "+":
+        case "?":
+          appendRaw(1);
+          break;
+        case "{":
+          tmp = /\{\d+,?\d*\}/g;
+          tmp.lastIndex = i;
+          tmp = tmp.exec(source);
+          if (tmp) {
+            appendRaw(tmp[0].length);
+          } else {
+            appendOptional(1);
+          }
+          break;
+        case "(":
+          if (source[i + 1] === "?") {
+            switch (source[i + 2]) {
+              case ":":
+                result += "(?:";
+                i += 3;
+                result += process() + "|$)";
+                break;
+              case "=":
+                result += "(?=";
+                i += 3;
+                result += process() + ")";
+                break;
+              case "!":
+                tmp = i;
+                i += 3;
+                process();
+                result += source.substr(tmp, i - tmp);
+                break;
+              case "<":
+                switch (source[i + 3]) {
+                  case "=":
+                  case "!":
+                    tmp = i;
+                    i += 4;
+                    process();
+                    result += source.substr(tmp, i - tmp);
+                    break;
+                  default:
+                    appendRaw(source.indexOf(">", i) - i + 1);
+                    result += process() + "|$)";
+                    break;
+                }
+                break;
+            }
+          } else {
+            appendRaw(1);
+            result += process() + "|$)";
+          }
+          break;
+        case ")":
+          ++i;
+          return result;
+        default:
+          appendOptional(1);
+          break;
+      }
+    }
+    return result;
+  }
+  return new RegExp(process(), regex.flags);
+}
+export {
+  NEWLINE_REGEXP,
+  escapeRegExp,
+  getCaseInsensitivePattern,
+  isMultilineComment,
+  isWhitespace,
+  partialMatches,
+  partialRegExp,
+  whitespaceCharacters
+};
+//# sourceMappingURL=regexp-utils.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/regexp-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"regexp-utils.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/regexp-utils.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 { RegExpParser, BaseRegExpVisitor } from '@chevrotain/regexp-to-ast';\nexport const NEWLINE_REGEXP = /\\r?\\n/gm;\nconst regexpParser = new RegExpParser();\n/**\n * This class is in charge of heuristically identifying start/end tokens of terminals.\n *\n * The way this works is by doing the following:\n * 1. Traverse the regular expression in the \"start state\"\n * 2. Add any encountered sets/single characters to the \"start regexp\"\n * 3. Once we encounter any variable-length content (i.e. with quantifiers such as +/?/*), we enter the \"end state\"\n * 4. In the end state, any sets/single characters are added to an \"end stack\".\n * 5. If we re-encounter any variable-length content we reset the end stack\n * 6. We continue visiting the regex until the end, reseting the end stack and rebuilding it as necessary\n *\n * After traversing a regular expression the `startRegexp/endRegexp` properties allow access to the stored start/end of the terminal\n */\nclass TerminalRegExpVisitor extends BaseRegExpVisitor {\n    constructor() {\n        super(...arguments);\n        this.isStarting = true;\n        this.endRegexpStack = [];\n        this.multiline = false;\n    }\n    get endRegex() {\n        return this.endRegexpStack.join('');\n    }\n    reset(regex) {\n        this.multiline = false;\n        this.regex = regex;\n        this.startRegexp = '';\n        this.isStarting = true;\n        this.endRegexpStack = [];\n    }\n    visitGroup(node) {\n        if (node.quantifier) {\n            this.isStarting = false;\n            this.endRegexpStack = [];\n        }\n    }\n    visitCharacter(node) {\n        const char = String.fromCharCode(node.value);\n        if (!this.multiline && char === '\\n') {\n            this.multiline = true;\n        }\n        if (node.quantifier) {\n            this.isStarting = false;\n            this.endRegexpStack = [];\n        }\n        else {\n            const escapedChar = escapeRegExp(char);\n            this.endRegexpStack.push(escapedChar);\n            if (this.isStarting) {\n                this.startRegexp += escapedChar;\n            }\n        }\n    }\n    visitSet(node) {\n        if (!this.multiline) {\n            const set = this.regex.substring(node.loc.begin, node.loc.end);\n            const regex = new RegExp(set);\n            this.multiline = Boolean('\\n'.match(regex));\n        }\n        if (node.quantifier) {\n            this.isStarting = false;\n            this.endRegexpStack = [];\n        }\n        else {\n            const set = this.regex.substring(node.loc.begin, node.loc.end);\n            this.endRegexpStack.push(set);\n            if (this.isStarting) {\n                this.startRegexp += set;\n            }\n        }\n    }\n    visitChildren(node) {\n        if (node.type === 'Group') {\n            // Ignore children of groups with quantifier (+/*/?)\n            // These groups are unrelated to start/end tokens of terminals\n            const group = node;\n            if (group.quantifier) {\n                return;\n            }\n        }\n        super.visitChildren(node);\n    }\n}\nconst visitor = new TerminalRegExpVisitor();\nexport function getTerminalParts(regexp) {\n    try {\n        if (typeof regexp !== 'string') {\n            regexp = regexp.source;\n        }\n        regexp = `/${regexp}/`;\n        const pattern = regexpParser.pattern(regexp);\n        const parts = [];\n        for (const alternative of pattern.value.value) {\n            visitor.reset(regexp);\n            visitor.visit(alternative);\n            parts.push({\n                start: visitor.startRegexp,\n                end: visitor.endRegex\n            });\n        }\n        return parts;\n    }\n    catch (_a) {\n        return [];\n    }\n}\nexport function isMultilineComment(regexp) {\n    try {\n        if (typeof regexp === 'string') {\n            regexp = new RegExp(regexp);\n        }\n        regexp = regexp.toString();\n        visitor.reset(regexp);\n        // Parsing the pattern might fail (since it's user code)\n        visitor.visit(regexpParser.pattern(regexp));\n        return visitor.multiline;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n/**\n * A set of all characters that are considered whitespace by the '\\s' RegExp character class.\n * Taken from [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Character_classes).\n */\nexport const whitespaceCharacters = ('\\f\\n\\r\\t\\v\\u0020\\u00a0\\u1680\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007' +\n    '\\u2008\\u2009\\u200a\\u2028\\u2029\\u202f\\u205f\\u3000\\ufeff').split('');\nexport function isWhitespace(value) {\n    const regexp = typeof value === 'string' ? new RegExp(value) : value;\n    return whitespaceCharacters.some((ws) => regexp.test(ws));\n}\nexport function escapeRegExp(value) {\n    return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\nexport function getCaseInsensitivePattern(keyword) {\n    return Array.prototype.map.call(keyword, letter => /\\w/.test(letter) ? `[${letter.toLowerCase()}${letter.toUpperCase()}]` : escapeRegExp(letter)).join('');\n}\n/**\n * Determines whether the given input has a partial match with the specified regex.\n * @param regex The regex to partially match against\n * @param input The input string\n * @returns Whether any match exists.\n */\nexport function partialMatches(regex, input) {\n    const partial = partialRegExp(regex);\n    const match = input.match(partial);\n    return !!match && match[0].length > 0;\n}\n/**\n * Builds a partial regex from the input regex. A partial regex is able to match incomplete input strings. E.g.\n * a partial regex constructed from `/ab/` is able to match the string `a` without needing a following `b` character. However it won't match `b` alone.\n * @param regex The input regex to be converted.\n * @returns A partial regex constructed from the input regex.\n */\nexport function partialRegExp(regex) {\n    if (typeof regex === 'string') {\n        regex = new RegExp(regex);\n    }\n    const re = regex, source = regex.source;\n    let i = 0;\n    function process() {\n        let result = '', tmp;\n        function appendRaw(nbChars) {\n            result += source.substr(i, nbChars);\n            i += nbChars;\n        }\n        function appendOptional(nbChars) {\n            result += '(?:' + source.substr(i, nbChars) + '|$)';\n            i += nbChars;\n        }\n        while (i < source.length) {\n            switch (source[i]) {\n                case '\\\\':\n                    switch (source[i + 1]) {\n                        case 'c':\n                            appendOptional(3);\n                            break;\n                        case 'x':\n                            appendOptional(4);\n                            break;\n                        case 'u':\n                            if (re.unicode) {\n                                if (source[i + 2] === '{') {\n                                    appendOptional(source.indexOf('}', i) - i + 1);\n                                }\n                                else {\n                                    appendOptional(6);\n                                }\n                            }\n                            else {\n                                appendOptional(2);\n                            }\n                            break;\n                        case 'p':\n                        case 'P':\n                            if (re.unicode) {\n                                appendOptional(source.indexOf('}', i) - i + 1);\n                            }\n                            else {\n                                appendOptional(2);\n                            }\n                            break;\n                        case 'k':\n                            appendOptional(source.indexOf('>', i) - i + 1);\n                            break;\n                        default:\n                            appendOptional(2);\n                            break;\n                    }\n                    break;\n                case '[':\n                    tmp = /\\[(?:\\\\.|.)*?\\]/g;\n                    tmp.lastIndex = i;\n                    tmp = tmp.exec(source) || [];\n                    appendOptional(tmp[0].length);\n                    break;\n                case '|':\n                case '^':\n                case '$':\n                case '*':\n                case '+':\n                case '?':\n                    appendRaw(1);\n                    break;\n                case '{':\n                    tmp = /\\{\\d+,?\\d*\\}/g;\n                    tmp.lastIndex = i;\n                    tmp = tmp.exec(source);\n                    if (tmp) {\n                        appendRaw(tmp[0].length);\n                    }\n                    else {\n                        appendOptional(1);\n                    }\n                    break;\n                case '(':\n                    if (source[i + 1] === '?') {\n                        switch (source[i + 2]) {\n                            case ':':\n                                result += '(?:';\n                                i += 3;\n                                result += process() + '|$)';\n                                break;\n                            case '=':\n                                result += '(?=';\n                                i += 3;\n                                result += process() + ')';\n                                break;\n                            case '!':\n                                tmp = i;\n                                i += 3;\n                                process();\n                                result += source.substr(tmp, i - tmp);\n                                break;\n                            case '<':\n                                switch (source[i + 3]) {\n                                    case '=':\n                                    case '!':\n                                        tmp = i;\n                                        i += 4;\n                                        process();\n                                        result += source.substr(tmp, i - tmp);\n                                        break;\n                                    default:\n                                        appendRaw(source.indexOf('>', i) - i + 1);\n                                        result += process() + '|$)';\n                                        break;\n                                }\n                                break;\n                        }\n                    }\n                    else {\n                        appendRaw(1);\n                        result += process() + '|$)';\n                    }\n                    break;\n                case ')':\n                    ++i;\n                    return result;\n                default:\n                    appendOptional(1);\n                    break;\n            }\n        }\n        return result;\n    }\n    return new RegExp(process(), regex.flags);\n}\n//# sourceMappingURL=regexp-utils.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}