@plumile/ui 0.1.113 → 0.1.114

package/lib/esm/node_modules/langium/lib/utils/grammar-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"grammar-utils.js","names":["ast.isParserRule","ast.isTerminalRule","ast.isRuleCall","ast.isTerminalRuleCall","ast.isAssignment","ast.isKeyword","ast.isInferredType","ast.isAction","ast.isAbstractParserRule","ast.isSimpleType","ast.isInfixRule","ast.isInterface","ast.isType","ast.isReturnType","ast.isTerminalAlternatives","ast.isTerminalGroup","ast.isCharacterRange","ast.isNegatedToken","ast.isUntilToken","ast.isRegexToken","ast.isWildcard"],"sources":["../../../../../../../../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 * Returns all parser rules which provide types which are used in the grammar as type in cross-references.\n * @param grammar the grammar to investigate\n * @returns the set of parser rules whose contributed types are used as type in cross-references\n */\nexport function getAllRulesUsedForCrossReferences(grammar) {\n    const result = new Set();\n    streamAllContents(grammar).forEach(node => {\n        if (ast.isCrossReference(node)) {\n            // the cross-reference refers directly to a parser rule (without \"returns\", without \"infers\")\n            if (ast.isParserRule(node.type.ref)) {\n                result.add(node.type.ref);\n            }\n            // the cross-reference refers to the explicitly inferred type of a parser rule\n            if (ast.isInferredType(node.type.ref) && ast.isParserRule(node.type.ref.$container)) {\n                result.add(node.type.ref.$container);\n            }\n        }\n    });\n    return result;\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?.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?.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?.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    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 === cstNode.container?.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 sibling of the Action node, i.e. start searching at the Action's parent\n            startNode = startNode.$container.$container;\n        }\n        else if (ast.isAbstractParserRule(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    // 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) && node.typeRef?.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            if (ast.isInfixRule(node.rule.ref)) {\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 (ast.isTerminalRule(rule)) {\n        return undefined;\n    }\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            return refType.name;\n        }\n    }\n    return undefined;\n}\nexport function getTypeName(type) {\n    if (ast.isAbstractParserRule(type)) {\n        return ast.isParserRule(type) && isDataTypeRule(type) ? type.name : getExplicitRuleType(type) ?? 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    if (action.inferredType) {\n        return action.inferredType.name;\n    }\n    else if (action.type?.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    if (ast.isTerminalRule(rule)) {\n        return rule.type?.name ?? 'string';\n    }\n    else {\n        return ast.isParserRule(rule) && isDataTypeRule(rule) ? rule.name : getExplicitRuleType(rule) ?? 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    if (ast.isTerminalRule(rule)) {\n        return rule.type?.name ?? 'string';\n    }\n    else {\n        return getExplicitRuleType(rule) ?? 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            parenthesized: element.parenthesized\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            parenthesized: element.parenthesized,\n            wrap: false\n        });\n    }\n    else if (ast.isWildcard(element)) {\n        return withCardinality(WILDCARD, {\n            cardinality: element.cardinality,\n            lookahead: element.lookahead,\n            parenthesized: element.parenthesized\n        });\n    }\n    else {\n        throw new Error(`Invalid terminal element: ${element?.$type}, ${element?.$cstNode?.text}`);\n    }\n}\nfunction terminalAlternativesToRegex(alternatives) {\n    return withCardinality(alternatives.elements.map(e => abstractElementToRegex(e)).join('|'), {\n        cardinality: alternatives.cardinality,\n        lookahead: alternatives.lookahead,\n        parenthesized: alternatives.parenthesized,\n        wrap: false // wrapping is not required for top level alternatives, and nested alternatives are already parenthesized according to the grammar\n    });\n}\nfunction terminalGroupToRegex(group) {\n    return withCardinality(group.elements.map(e => abstractElementToRegex(e)).join(''), {\n        cardinality: group.cardinality,\n        lookahead: group.lookahead,\n        parenthesized: group.parenthesized,\n        wrap: false // wrapping is not required for top level group, and nested group are already parenthesized according to the grammar\n    });\n}\nfunction untilTokenToRegex(until) {\n    return withCardinality(`${WILDCARD}*?${abstractElementToRegex(until.terminal)}`, {\n        cardinality: until.cardinality,\n        lookahead: until.lookahead,\n        parenthesized: until.parenthesized\n    });\n}\nfunction negateTokenToRegex(negate) {\n    return withCardinality(`(?!${abstractElementToRegex(negate.terminal)})${WILDCARD}*?`, {\n        cardinality: negate.cardinality,\n        lookahead: negate.lookahead,\n        parenthesized: negate.parenthesized\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            parenthesized: range.parenthesized,\n            wrap: false\n        });\n    }\n    return withCardinality(keywordToRegex(range.left), {\n        cardinality: range.cardinality,\n        lookahead: range.lookahead,\n        parenthesized: range.parenthesized,\n        wrap: false\n    });\n}\nfunction keywordToRegex(keyword) {\n    return escapeRegExp(keyword.value);\n}\nfunction withCardinality(regex, options) {\n    if (options.parenthesized || options.lookahead || options.wrap !== false) {\n        const groupConfig = options.lookahead ?? (options.parenthesized ? '' : '?:');\n        regex = `(${groupConfig}${regex})`;\n    }\n    if (options.cardinality) {\n        return `${regex}${options.cardinality}`;\n    }\n    return regex;\n}\n//# sourceMappingURL=grammar-utils.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/lib/esm/node_modules/langium/lib/utils/promise-utils.js

@@ -1,31 +0,0 @@
-import { cancellation_exports as e } from "./cancellation.js";
-//#region ../../node_modules/langium/lib/utils/promise-utils.js
-function t() {
-	return new Promise((e) => {
-		typeof setImmediate > "u" ? setTimeout(e, 0) : setImmediate(e);
-	});
-}
-var n = 0, r = 10;
-function i() {
-	return n = performance.now(), new e.CancellationTokenSource();
-}
-var a = Symbol("OperationCancelled");
-function o(e) {
-	return e === a;
-}
-async function s(i) {
-	if (i === e.CancellationToken.None) return;
-	let o = performance.now();
-	if (o - n >= r && (n = o, await t(), n = performance.now()), i.isCancellationRequested) throw a;
-}
-var c = class {
-	constructor() {
-		this.promise = new Promise((e, t) => {
-			this.resolve = (t) => (e(t), this), this.reject = (e) => (t(e), this);
-		});
-	}
-};
-//#endregion
-export { c as Deferred, a as OperationCancelled, s as interruptAndCheck, o as isOperationCancelled, i as startCancelableOperation };
-
-//# sourceMappingURL=promise-utils.js.map

package/lib/esm/node_modules/langium/lib/utils/promise-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"promise-utils.js","names":["CancellationTokenSource","CancellationToken"],"sources":["../../../../../../../../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"],"x_google_ignoreList":[0],"mappings":";;AAUA,SAAgB,IAAgB;CAC5B,OAAO,IAAI,SAAQ,MAAW;EAG1B,AAAI,OAAO,eAAiB,MACxB,WAAW,GAAS,EAAE,GAGtB,aAAa,EAAQ;GAE3B;;AAEN,IAAI,IAAW,GACX,IAA2B;AAI/B,SAAgB,IAA2B;CAEvC,OADA,IAAW,YAAY,KAAK,EACrB,IAAIA,EAAAA,yBAAyB;;AAcxC,IAAa,IAAqB,OAAO,qBAAqB;AAK9D,SAAgB,EAAqB,GAAK;CACtC,OAAO,MAAQ;;AAanB,eAAsB,EAAkB,GAAO;CAC3C,IAAI,MAAUC,EAAAA,kBAAkB,MAE5B;CAEJ,IAAM,IAAU,YAAY,KAAK;CASjC,IARI,IAAU,KAAY,MACtB,IAAW,GACX,MAAM,GAAe,EAIrB,IAAW,YAAY,KAAK,GAE5B,EAAM,yBACN,MAAM;;AAOd,IAAa,IAAb,MAAsB;CAClB,cAAc;EACV,KAAK,UAAU,IAAI,SAAS,GAAS,MAAW;GAK5C,AAJA,KAAK,WAAW,OACZ,EAAQ,EAAI,EACL,OAEX,KAAK,UAAU,OACX,EAAO,EAAI,EACJ;IAEb"}

package/lib/esm/node_modules/langium/lib/utils/regexp-utils.js

@@ -1,146 +0,0 @@
-import { RegExpParser as e } from "../../../@chevrotain/regexp-to-ast/lib/src/regexp-parser.js";
-import { BaseRegExpVisitor as t } from "../../../@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js";
-import "../../../@chevrotain/regexp-to-ast/lib/src/api.js";
-//#region ../../node_modules/langium/lib/utils/regexp-utils.js
-var n = /\r?\n/gm, r = new e(), i = new class extends t {
-	constructor() {
-		super(...arguments), this.isStarting = !0, this.endRegexpStack = [], this.multiline = !1;
-	}
-	get endRegex() {
-		return this.endRegexpStack.join("");
-	}
-	reset(e) {
-		this.multiline = !1, this.regex = e, this.startRegexp = "", this.isStarting = !0, this.endRegexpStack = [];
-	}
-	visitGroup(e) {
-		e.quantifier && (this.isStarting = !1, this.endRegexpStack = []);
-	}
-	visitCharacter(e) {
-		let t = String.fromCharCode(e.value);
-		if (!this.multiline && t === "\n" && (this.multiline = !0), e.quantifier) this.isStarting = !1, this.endRegexpStack = [];
-		else {
-			let e = c(t);
-			this.endRegexpStack.push(e), this.isStarting && (this.startRegexp += e);
-		}
-	}
-	visitSet(e) {
-		if (!this.multiline) {
-			let t = this.regex.substring(e.loc.begin, e.loc.end), n = new RegExp(t);
-			this.multiline = !!"\n".match(n);
-		}
-		if (e.quantifier) this.isStarting = !1, this.endRegexpStack = [];
-		else {
-			let t = this.regex.substring(e.loc.begin, e.loc.end);
-			this.endRegexpStack.push(t), this.isStarting && (this.startRegexp += t);
-		}
-	}
-	visitChildren(e) {
-		e.type === "Group" && e.quantifier || super.visitChildren(e);
-	}
-}();
-function a(e) {
-	try {
-		return typeof e == "string" && (e = new RegExp(e)), e = e.toString(), i.reset(e), i.visit(r.pattern(e)), i.multiline;
-	} catch {
-		return !1;
-	}
-}
-var o = "\f\n\r	\v \xA0            \u2028\u2029  　".split("");
-function s(e) {
-	let t = typeof e == "string" ? new RegExp(e) : e;
-	return o.some((e) => t.test(e));
-}
-function c(e) {
-	return e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function l(e, t) {
-	let n = u(e), r = t.match(n);
-	return !!r && r[0].length > 0;
-}
-function u(e) {
-	typeof e == "string" && (e = new RegExp(e));
-	let t = e, n = e.source, r = 0;
-	function i() {
-		let e = "", a;
-		function o(t) {
-			e += n.substr(r, t), r += t;
-		}
-		function s(t) {
-			e += "(?:" + n.substr(r, t) + "|$)", r += t;
-		}
-		for (; r < n.length;) switch (n[r]) {
-			case "\\":
-				switch (n[r + 1]) {
-					case "c":
-						s(3);
-						break;
-					case "x":
-						s(4);
-						break;
-					case "u":
-						t.unicode ? n[r + 2] === "{" ? s(n.indexOf("}", r) - r + 1) : s(6) : s(2);
-						break;
-					case "p":
-					case "P":
-						t.unicode ? s(n.indexOf("}", r) - r + 1) : s(2);
-						break;
-					case "k":
-						s(n.indexOf(">", r) - r + 1);
-						break;
-					default:
-						s(2);
-						break;
-				}
-				break;
-			case "[":
-				a = /\[(?:\\.|.)*?\]/g, a.lastIndex = r, a = a.exec(n) || [], s(a[0].length);
-				break;
-			case "|":
-			case "^":
-			case "$":
-			case "*":
-			case "+":
-			case "?":
-				o(1);
-				break;
-			case "{":
-				a = /\{\d+,?\d*\}/g, a.lastIndex = r, a = a.exec(n), a ? o(a[0].length) : s(1);
-				break;
-			case "(":
-				if (n[r + 1] === "?") switch (n[r + 2]) {
-					case ":":
-						e += "(?:", r += 3, e += i() + "|$)";
-						break;
-					case "=":
-						e += "(?=", r += 3, e += i() + ")";
-						break;
-					case "!":
-						a = r, r += 3, i(), e += n.substr(a, r - a);
-						break;
-					case "<":
-						switch (n[r + 3]) {
-							case "=":
-							case "!":
-								a = r, r += 4, i(), e += n.substr(a, r - a);
-								break;
-							default:
-								o(n.indexOf(">", r) - r + 1), e += i() + "|$)";
-								break;
-						}
-						break;
-				}
-				else o(1), e += i() + "|$)";
-				break;
-			case ")": return ++r, e;
-			default:
-				s(1);
-				break;
-		}
-		return e;
-	}
-	return new RegExp(i(), e.flags);
-}
-//#endregion
-export { n as NEWLINE_REGEXP, c as escapeRegExp, a as isMultilineComment, s as isWhitespace, l as partialMatches };
-
-//# sourceMappingURL=regexp-utils.js.map

package/lib/esm/node_modules/langium/lib/utils/regexp-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"regexp-utils.js","names":["group"],"sources":["../../../../../../../../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 {\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 {\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}\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"],"x_google_ignoreList":[0],"mappings":";;;;AAMA,IAAa,IAAiB,WACxB,IAAe,IAAI,GAAc,EAoFjC,IAAU,IAAI,cAtEgB,EAAkB;CAClD,cAAc;EAIV,AAHA,MAAM,GAAG,UAAU,EACnB,KAAK,aAAa,IAClB,KAAK,iBAAiB,EAAE,EACxB,KAAK,YAAY;;CAErB,IAAI,WAAW;EACX,OAAO,KAAK,eAAe,KAAK,GAAG;;CAEvC,MAAM,GAAO;EAKT,AAJA,KAAK,YAAY,IACjB,KAAK,QAAQ,GACb,KAAK,cAAc,IACnB,KAAK,aAAa,IAClB,KAAK,iBAAiB,EAAE;;CAE5B,WAAW,GAAM;EACb,AAAI,EAAK,eACL,KAAK,aAAa,IAClB,KAAK,iBAAiB,EAAE;;CAGhC,eAAe,GAAM;EACjB,IAAM,IAAO,OAAO,aAAa,EAAK,MAAM;EAI5C,IAHI,CAAC,KAAK,aAAa,MAAS,SAC5B,KAAK,YAAY,KAEjB,EAAK,YAEL,AADA,KAAK,aAAa,IAClB,KAAK,iBAAiB,EAAE;OAEvB;GACD,IAAM,IAAc,EAAa,EAAK;GAEtC,AADA,KAAK,eAAe,KAAK,EAAY,EACjC,KAAK,eACL,KAAK,eAAe;;;CAIhC,SAAS,GAAM;EACX,IAAI,CAAC,KAAK,WAAW;GACjB,IAAM,IAAM,KAAK,MAAM,UAAU,EAAK,IAAI,OAAO,EAAK,IAAI,IAAI,EACxD,IAAQ,IAAI,OAAO,EAAI;GAC7B,KAAK,YAAY,EAAQ,KAAK,MAAM,EAAM;;EAE9C,IAAI,EAAK,YAEL,AADA,KAAK,aAAa,IAClB,KAAK,iBAAiB,EAAE;OAEvB;GACD,IAAM,IAAM,KAAK,MAAM,UAAU,EAAK,IAAI,OAAO,EAAK,IAAI,IAAI;GAE9D,AADA,KAAK,eAAe,KAAK,EAAI,EACzB,KAAK,eACL,KAAK,eAAe;;;CAIhC,cAAc,GAAM;EACZ,EAAK,SAAS,WAIVA,EAAM,cAId,MAAM,cAAc,EAAK;;GAGU;AAuB3C,SAAgB,EAAmB,GAAQ;CACvC,IAAI;EAQA,OAPI,OAAO,KAAW,aAClB,IAAS,IAAI,OAAO,EAAO,GAE/B,IAAS,EAAO,UAAU,EAC1B,EAAQ,MAAM,EAAO,EAErB,EAAQ,MAAM,EAAa,QAAQ,EAAO,CAAC,EACpC,EAAQ;SAEb;EACF,OAAO;;;AAOf,IAAa,IAAwB,6CACyB,MAAM,GAAG;AACvE,SAAgB,EAAa,GAAO;CAChC,IAAM,IAAS,OAAO,KAAU,WAAW,IAAI,OAAO,EAAM,GAAG;CAC/D,OAAO,EAAqB,MAAM,MAAO,EAAO,KAAK,EAAG,CAAC;;AAE7D,SAAgB,EAAa,GAAO;CAChC,OAAO,EAAM,QAAQ,uBAAuB,OAAO;;AAQvD,SAAgB,EAAe,GAAO,GAAO;CACzC,IAAM,IAAU,EAAc,EAAM,EAC9B,IAAQ,EAAM,MAAM,EAAQ;CAClC,OAAO,CAAC,CAAC,KAAS,EAAM,GAAG,SAAS;;AAQxC,SAAgB,EAAc,GAAO;CACjC,AAAI,OAAO,KAAU,aACjB,IAAQ,IAAI,OAAO,EAAM;CAE7B,IAAM,IAAK,GAAO,IAAS,EAAM,QAC7B,IAAI;CACR,SAAS,IAAU;EACf,IAAI,IAAS,IAAI;EACjB,SAAS,EAAU,GAAS;GAExB,AADA,KAAU,EAAO,OAAO,GAAG,EAAQ,EACnC,KAAK;;EAET,SAAS,EAAe,GAAS;GAE7B,AADA,KAAU,QAAQ,EAAO,OAAO,GAAG,EAAQ,GAAG,OAC9C,KAAK;;EAET,OAAO,IAAI,EAAO,SACd,QAAQ,EAAO,IAAf;GACI,KAAK;IACD,QAAQ,EAAO,IAAI,IAAnB;KACI,KAAK;MACD,EAAe,EAAE;MACjB;KACJ,KAAK;MACD,EAAe,EAAE;MACjB;KACJ,KAAK;MACD,AAAI,EAAG,UACC,EAAO,IAAI,OAAO,MAClB,EAAe,EAAO,QAAQ,KAAK,EAAE,GAAG,IAAI,EAAE,GAG9C,EAAe,EAAE,GAIrB,EAAe,EAAE;MAErB;KACJ,KAAK;KACL,KAAK;MACD,AAAI,EAAG,UACH,EAAe,EAAO,QAAQ,KAAK,EAAE,GAAG,IAAI,EAAE,GAG9C,EAAe,EAAE;MAErB;KACJ,KAAK;MACD,EAAe,EAAO,QAAQ,KAAK,EAAE,GAAG,IAAI,EAAE;MAC9C;KACJ;MACI,EAAe,EAAE;MACjB;;IAER;GACJ,KAAK;IAID,AAHA,IAAM,oBACN,EAAI,YAAY,GAChB,IAAM,EAAI,KAAK,EAAO,IAAI,EAAE,EAC5B,EAAe,EAAI,GAAG,OAAO;IAC7B;GACJ,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;GACL,KAAK;IACD,EAAU,EAAE;IACZ;GACJ,KAAK;IAID,AAHA,IAAM,iBACN,EAAI,YAAY,GAChB,IAAM,EAAI,KAAK,EAAO,EAClB,IACA,EAAU,EAAI,GAAG,OAAO,GAGxB,EAAe,EAAE;IAErB;GACJ,KAAK;IACD,IAAI,EAAO,IAAI,OAAO,KAClB,QAAQ,EAAO,IAAI,IAAnB;KACI,KAAK;MAGD,AAFA,KAAU,OACV,KAAK,GACL,KAAU,GAAS,GAAG;MACtB;KACJ,KAAK;MAGD,AAFA,KAAU,OACV,KAAK,GACL,KAAU,GAAS,GAAG;MACtB;KACJ,KAAK;MAID,AAHA,IAAM,GACN,KAAK,GACL,GAAS,EACT,KAAU,EAAO,OAAO,GAAK,IAAI,EAAI;MACrC;KACJ,KAAK;MACD,QAAQ,EAAO,IAAI,IAAnB;OACI,KAAK;OACL,KAAK;QAID,AAHA,IAAM,GACN,KAAK,GACL,GAAS,EACT,KAAU,EAAO,OAAO,GAAK,IAAI,EAAI;QACrC;OACJ;QAEI,AADA,EAAU,EAAO,QAAQ,KAAK,EAAE,GAAG,IAAI,EAAE,EACzC,KAAU,GAAS,GAAG;QACtB;;MAER;;SAKR,AADA,EAAU,EAAE,EACZ,KAAU,GAAS,GAAG;IAE1B;GACJ,KAAK,KAED,OADA,EAAE,GACK;GACX;IACI,EAAe,EAAE;IACjB;;EAGZ,OAAO;;CAEX,OAAO,IAAI,OAAO,GAAS,EAAE,EAAM,MAAM"}

package/lib/esm/node_modules/langium/lib/utils/stream.js

@@ -1,331 +0,0 @@
-//#region ../../node_modules/langium/lib/utils/stream.js
-var e = class e {
-	constructor(e, t) {
-		this.startFn = e, this.nextFn = t;
-	}
-	iterator() {
-		let e = {
-			state: this.startFn(),
-			next: () => this.nextFn(e.state),
-			[Symbol.iterator]: () => e
-		};
-		return e;
-	}
-	[Symbol.iterator]() {
-		return this.iterator();
-	}
-	isEmpty() {
-		return !!this.iterator().next().done;
-	}
-	count() {
-		let e = this.iterator(), t = 0, n = e.next();
-		for (; !n.done;) t++, n = e.next();
-		return t;
-	}
-	toArray() {
-		let e = [], t = this.iterator(), n;
-		do
-			n = t.next(), n.value !== void 0 && e.push(n.value);
-		while (!n.done);
-		return e;
-	}
-	toSet() {
-		return new Set(this);
-	}
-	toMap(e, t) {
-		let n = this.map((n) => [e ? e(n) : n, t ? t(n) : n]);
-		return new Map(n);
-	}
-	toString() {
-		return this.join();
-	}
-	concat(t) {
-		return new e(() => ({
-			first: this.startFn(),
-			firstDone: !1,
-			iterator: t[Symbol.iterator]()
-		}), (e) => {
-			let t;
-			if (!e.firstDone) {
-				do
-					if (t = this.nextFn(e.first), !t.done) return t;
-				while (!t.done);
-				e.firstDone = !0;
-			}
-			do
-				if (t = e.iterator.next(), !t.done) return t;
-			while (!t.done);
-			return i;
-		});
-	}
-	join(e = ",") {
-		let n = this.iterator(), r = "", i, a = !1;
-		do
-			i = n.next(), i.done || (a && (r += e), r += t(i.value)), a = !0;
-		while (!i.done);
-		return r;
-	}
-	indexOf(e, t = 0) {
-		let n = this.iterator(), r = 0, i = n.next();
-		for (; !i.done;) {
-			if (r >= t && i.value === e) return r;
-			i = n.next(), r++;
-		}
-		return -1;
-	}
-	every(e) {
-		let t = this.iterator(), n = t.next();
-		for (; !n.done;) {
-			if (!e(n.value)) return !1;
-			n = t.next();
-		}
-		return !0;
-	}
-	some(e) {
-		let t = this.iterator(), n = t.next();
-		for (; !n.done;) {
-			if (e(n.value)) return !0;
-			n = t.next();
-		}
-		return !1;
-	}
-	forEach(e) {
-		let t = this.iterator(), n = 0, r = t.next();
-		for (; !r.done;) e(r.value, n), r = t.next(), n++;
-	}
-	map(t) {
-		return new e(this.startFn, (e) => {
-			let { done: n, value: r } = this.nextFn(e);
-			return n ? i : {
-				done: !1,
-				value: t(r)
-			};
-		});
-	}
-	filter(t) {
-		return new e(this.startFn, (e) => {
-			let n;
-			do
-				if (n = this.nextFn(e), !n.done && t(n.value)) return n;
-			while (!n.done);
-			return i;
-		});
-	}
-	nonNullable() {
-		return this.filter((e) => e != null);
-	}
-	reduce(e, t) {
-		let n = this.iterator(), r = t, i = n.next();
-		for (; !i.done;) r = r === void 0 ? i.value : e(r, i.value), i = n.next();
-		return r;
-	}
-	reduceRight(e, t) {
-		return this.recursiveReduce(this.iterator(), e, t);
-	}
-	recursiveReduce(e, t, n) {
-		let r = e.next();
-		if (r.done) return n;
-		let i = this.recursiveReduce(e, t, n);
-		return i === void 0 ? r.value : t(i, r.value);
-	}
-	find(e) {
-		let t = this.iterator(), n = t.next();
-		for (; !n.done;) {
-			if (e(n.value)) return n.value;
-			n = t.next();
-		}
-	}
-	findIndex(e) {
-		let t = this.iterator(), n = 0, r = t.next();
-		for (; !r.done;) {
-			if (e(r.value)) return n;
-			r = t.next(), n++;
-		}
-		return -1;
-	}
-	includes(e) {
-		let t = this.iterator(), n = t.next();
-		for (; !n.done;) {
-			if (n.value === e) return !0;
-			n = t.next();
-		}
-		return !1;
-	}
-	flatMap(t) {
-		return new e(() => ({ this: this.startFn() }), (e) => {
-			do {
-				if (e.iterator) {
-					let t = e.iterator.next();
-					if (t.done) e.iterator = void 0;
-					else return t;
-				}
-				let { done: r, value: i } = this.nextFn(e.this);
-				if (!r) {
-					let r = t(i);
-					if (n(r)) e.iterator = r[Symbol.iterator]();
-					else return {
-						done: !1,
-						value: r
-					};
-				}
-			} while (e.iterator);
-			return i;
-		});
-	}
-	flat(t) {
-		if (t === void 0 && (t = 1), t <= 0) return this;
-		let r = t > 1 ? this.flat(t - 1) : this;
-		return new e(() => ({ this: r.startFn() }), (e) => {
-			do {
-				if (e.iterator) {
-					let t = e.iterator.next();
-					if (t.done) e.iterator = void 0;
-					else return t;
-				}
-				let { done: t, value: i } = r.nextFn(e.this);
-				if (!t) if (n(i)) e.iterator = i[Symbol.iterator]();
-				else return {
-					done: !1,
-					value: i
-				};
-			} while (e.iterator);
-			return i;
-		});
-	}
-	head() {
-		let e = this.iterator().next();
-		if (!e.done) return e.value;
-	}
-	tail(t = 1) {
-		return new e(() => {
-			let e = this.startFn();
-			for (let n = 0; n < t; n++) if (this.nextFn(e).done) return e;
-			return e;
-		}, this.nextFn);
-	}
-	limit(t) {
-		return new e(() => ({
-			size: 0,
-			state: this.startFn()
-		}), (e) => (e.size++, e.size > t ? i : this.nextFn(e.state)));
-	}
-	distinct(t) {
-		return new e(() => ({
-			set: /* @__PURE__ */ new Set(),
-			internalState: this.startFn()
-		}), (e) => {
-			let n;
-			do
-				if (n = this.nextFn(e.internalState), !n.done) {
-					let r = t ? t(n.value) : n.value;
-					if (!e.set.has(r)) return e.set.add(r), n;
-				}
-			while (!n.done);
-			return i;
-		});
-	}
-	exclude(e, t) {
-		let n = /* @__PURE__ */ new Set();
-		for (let r of e) {
-			let e = t ? t(r) : r;
-			n.add(e);
-		}
-		return this.filter((e) => {
-			let r = t ? t(e) : e;
-			return !n.has(r);
-		});
-	}
-};
-function t(e) {
-	return typeof e == "string" ? e : e === void 0 ? "undefined" : typeof e.toString == "function" ? e.toString() : Object.prototype.toString.call(e);
-}
-function n(e) {
-	return !!e && typeof e[Symbol.iterator] == "function";
-}
-var r = new e(() => void 0, () => i), i = Object.freeze({
-	done: !0,
-	value: void 0
-});
-function a(...t) {
-	if (t.length === 1) {
-		let r = t[0];
-		if (r instanceof e) return r;
-		if (n(r)) return new e(() => r[Symbol.iterator](), (e) => e.next());
-		if (typeof r.length == "number") return new e(() => ({ index: 0 }), (e) => e.index < r.length ? {
-			done: !1,
-			value: r[e.index++]
-		} : i);
-	}
-	return t.length > 1 ? new e(() => ({
-		collIndex: 0,
-		arrIndex: 0
-	}), (e) => {
-		do {
-			if (e.iterator) {
-				let t = e.iterator.next();
-				if (!t.done) return t;
-				e.iterator = void 0;
-			}
-			if (e.array) {
-				if (e.arrIndex < e.array.length) return {
-					done: !1,
-					value: e.array[e.arrIndex++]
-				};
-				e.array = void 0, e.arrIndex = 0;
-			}
-			if (e.collIndex < t.length) {
-				let r = t[e.collIndex++];
-				n(r) ? e.iterator = r[Symbol.iterator]() : r && typeof r.length == "number" && (e.array = r);
-			}
-		} while (e.iterator || e.array || e.collIndex < t.length);
-		return i;
-	}) : r;
-}
-var o = class extends e {
-	constructor(e, t, n) {
-		super(() => ({
-			iterators: n?.includeRoot ? [[e][Symbol.iterator]()] : [t(e)[Symbol.iterator]()],
-			pruned: !1
-		}), (e) => {
-			for (e.pruned &&= (e.iterators.pop(), !1); e.iterators.length > 0;) {
-				let n = e.iterators[e.iterators.length - 1].next();
-				if (n.done) e.iterators.pop();
-				else return e.iterators.push(t(n.value)[Symbol.iterator]()), n;
-			}
-			return i;
-		});
-	}
-	iterator() {
-		let e = {
-			state: this.startFn(),
-			next: () => this.nextFn(e.state),
-			prune: () => {
-				e.state.pruned = !0;
-			},
-			[Symbol.iterator]: () => e
-		};
-		return e;
-	}
-}, s;
-(function(e) {
-	function t(e) {
-		return e.reduce((e, t) => e + t, 0);
-	}
-	e.sum = t;
-	function n(e) {
-		return e.reduce((e, t) => e * t, 0);
-	}
-	e.product = n;
-	function r(e) {
-		return e.reduce((e, t) => Math.min(e, t));
-	}
-	e.min = r;
-	function i(e) {
-		return e.reduce((e, t) => Math.max(e, t));
-	}
-	e.max = i;
-})(s ||= {});
-//#endregion
-export { i as DONE_RESULT, r as EMPTY_STREAM, s as Reduction, e as StreamImpl, o as TreeStreamImpl, a as stream };
-
-//# sourceMappingURL=stream.js.map