qidian-vue-ui 1.1.55 → 1.1.57

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

@@ -1,336 +0,0 @@
-import { EMPTY_ALT } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/parser.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_public.mjs";
-import { EOF } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/errors_public.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs";
-import { isParserRule, isKeyword, isAction, isAssignment, isCrossReference, isRuleCall, isAlternatives, isUnorderedGroup, isGroup, isEndOfFile, isTerminalRule, isDisjunction, isConjunction, isNegation, isParameterReference, isBooleanLiteral } from "../languages/generated/ast.mjs";
-import { ErrorWithLocation, assertUnreachable } from "../utils/errors.mjs";
-import { stream } from "../utils/stream.mjs";
-import { getAllReachableRules, getTypeName, findNameAssignment } from "../utils/grammar-utils.mjs";
-function createParser(grammar, parser, tokens) {
-  const parserContext = {
-    parser,
-    tokens,
-    ruleNames: /* @__PURE__ */ new Map()
-  };
-  buildRules(parserContext, grammar);
-  return parser;
-}
-function buildRules(parserContext, grammar) {
-  const reachable = getAllReachableRules(grammar, false);
-  const parserRules = stream(grammar.rules).filter(isParserRule).filter((rule) => reachable.has(rule));
-  for (const rule of parserRules) {
-    const ctx = Object.assign(Object.assign({}, parserContext), { consume: 1, optional: 1, subrule: 1, many: 1, or: 1 });
-    parserContext.parser.rule(rule, buildElement(ctx, rule.definition));
-  }
-}
-function buildElement(ctx, element, ignoreGuard = false) {
-  let method;
-  if (isKeyword(element)) {
-    method = buildKeyword(ctx, element);
-  } else if (isAction(element)) {
-    method = buildAction(ctx, element);
-  } else if (isAssignment(element)) {
-    method = buildElement(ctx, element.terminal);
-  } else if (isCrossReference(element)) {
-    method = buildCrossReference(ctx, element);
-  } else if (isRuleCall(element)) {
-    method = buildRuleCall(ctx, element);
-  } else if (isAlternatives(element)) {
-    method = buildAlternatives(ctx, element);
-  } else if (isUnorderedGroup(element)) {
-    method = buildUnorderedGroup(ctx, element);
-  } else if (isGroup(element)) {
-    method = buildGroup(ctx, element);
-  } else if (isEndOfFile(element)) {
-    const idx = ctx.consume++;
-    method = () => ctx.parser.consume(idx, EOF, element);
-  } else {
-    throw new ErrorWithLocation(element.$cstNode, `Unexpected element type: ${element.$type}`);
-  }
-  return wrap(ctx, ignoreGuard ? void 0 : getGuardCondition(element), method, element.cardinality);
-}
-function buildAction(ctx, action) {
-  const actionType = getTypeName(action);
-  return () => ctx.parser.action(actionType, action);
-}
-function buildRuleCall(ctx, ruleCall) {
-  const rule = ruleCall.rule.ref;
-  if (isParserRule(rule)) {
-    const idx = ctx.subrule++;
-    const fragment = rule.fragment;
-    const predicate = ruleCall.arguments.length > 0 ? buildRuleCallPredicate(rule, ruleCall.arguments) : () => ({});
-    return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), fragment, ruleCall, predicate(args));
-  } else if (isTerminalRule(rule)) {
-    const idx = ctx.consume++;
-    const method = getToken(ctx, rule.name);
-    return () => ctx.parser.consume(idx, method, ruleCall);
-  } else if (!rule) {
-    throw new ErrorWithLocation(ruleCall.$cstNode, `Undefined rule: ${ruleCall.rule.$refText}`);
-  } else {
-    assertUnreachable();
-  }
-}
-function buildRuleCallPredicate(rule, namedArgs) {
-  const predicates = namedArgs.map((e) => buildPredicate(e.value));
-  return (args) => {
-    const ruleArgs = {};
-    for (let i = 0; i < predicates.length; i++) {
-      const ruleTarget = rule.parameters[i];
-      const predicate = predicates[i];
-      ruleArgs[ruleTarget.name] = predicate(args);
-    }
-    return ruleArgs;
-  };
-}
-function buildPredicate(condition) {
-  if (isDisjunction(condition)) {
-    const left = buildPredicate(condition.left);
-    const right = buildPredicate(condition.right);
-    return (args) => left(args) || right(args);
-  } else if (isConjunction(condition)) {
-    const left = buildPredicate(condition.left);
-    const right = buildPredicate(condition.right);
-    return (args) => left(args) && right(args);
-  } else if (isNegation(condition)) {
-    const value = buildPredicate(condition.value);
-    return (args) => !value(args);
-  } else if (isParameterReference(condition)) {
-    const name = condition.parameter.ref.name;
-    return (args) => args !== void 0 && args[name] === true;
-  } else if (isBooleanLiteral(condition)) {
-    const value = Boolean(condition.true);
-    return () => value;
-  }
-  assertUnreachable();
-}
-function buildAlternatives(ctx, alternatives) {
-  if (alternatives.elements.length === 1) {
-    return buildElement(ctx, alternatives.elements[0]);
-  } else {
-    const methods = [];
-    for (const element of alternatives.elements) {
-      const predicatedMethod = {
-        // Since we handle the guard condition in the alternative already
-        // We can ignore the group guard condition inside
-        ALT: buildElement(ctx, element, true)
-      };
-      const guard = getGuardCondition(element);
-      if (guard) {
-        predicatedMethod.GATE = buildPredicate(guard);
-      }
-      methods.push(predicatedMethod);
-    }
-    const idx = ctx.or++;
-    return (args) => ctx.parser.alternatives(idx, methods.map((method) => {
-      const alt = {
-        ALT: () => method.ALT(args)
-      };
-      const gate = method.GATE;
-      if (gate) {
-        alt.GATE = () => gate(args);
-      }
-      return alt;
-    }));
-  }
-}
-function buildUnorderedGroup(ctx, group) {
-  if (group.elements.length === 1) {
-    return buildElement(ctx, group.elements[0]);
-  }
-  const methods = [];
-  for (const element of group.elements) {
-    const predicatedMethod = {
-      // Since we handle the guard condition in the alternative already
-      // We can ignore the group guard condition inside
-      ALT: buildElement(ctx, element, true)
-    };
-    const guard = getGuardCondition(element);
-    if (guard) {
-      predicatedMethod.GATE = buildPredicate(guard);
-    }
-    methods.push(predicatedMethod);
-  }
-  const orIdx = ctx.or++;
-  const idFunc = (groupIdx, lParser) => {
-    const stackId = lParser.getRuleStack().join("-");
-    return `uGroup_${groupIdx}_${stackId}`;
-  };
-  const alternatives = (args) => ctx.parser.alternatives(orIdx, methods.map((method, idx) => {
-    const alt = { ALT: () => true };
-    const parser = ctx.parser;
-    alt.ALT = () => {
-      method.ALT(args);
-      if (!parser.isRecording()) {
-        const key = idFunc(orIdx, parser);
-        if (!parser.unorderedGroups.get(key)) {
-          parser.unorderedGroups.set(key, []);
-        }
-        const groupState = parser.unorderedGroups.get(key);
-        if (typeof (groupState === null || groupState === void 0 ? void 0 : groupState[idx]) === "undefined") {
-          groupState[idx] = true;
-        }
-      }
-    };
-    const gate = method.GATE;
-    if (gate) {
-      alt.GATE = () => gate(args);
-    } else {
-      alt.GATE = () => {
-        const trackedAlternatives = parser.unorderedGroups.get(idFunc(orIdx, parser));
-        const allow = !(trackedAlternatives === null || trackedAlternatives === void 0 ? void 0 : trackedAlternatives[idx]);
-        return allow;
-      };
-    }
-    return alt;
-  }));
-  const wrapped = wrap(ctx, getGuardCondition(group), alternatives, "*");
-  return (args) => {
-    wrapped(args);
-    if (!ctx.parser.isRecording()) {
-      ctx.parser.unorderedGroups.delete(idFunc(orIdx, ctx.parser));
-    }
-  };
-}
-function buildGroup(ctx, group) {
-  const methods = group.elements.map((e) => buildElement(ctx, e));
-  return (args) => methods.forEach((method) => method(args));
-}
-function getGuardCondition(element) {
-  if (isGroup(element)) {
-    return element.guardCondition;
-  }
-  return void 0;
-}
-function buildCrossReference(ctx, crossRef, terminal = crossRef.terminal) {
-  if (!terminal) {
-    if (!crossRef.type.ref) {
-      throw new Error("Could not resolve reference to type: " + crossRef.type.$refText);
-    }
-    const assignment = findNameAssignment(crossRef.type.ref);
-    const assignTerminal = assignment === null || assignment === void 0 ? void 0 : assignment.terminal;
-    if (!assignTerminal) {
-      throw new Error("Could not find name assignment for type: " + getTypeName(crossRef.type.ref));
-    }
-    return buildCrossReference(ctx, crossRef, assignTerminal);
-  } else if (isRuleCall(terminal) && isParserRule(terminal.rule.ref)) {
-    const rule = terminal.rule.ref;
-    const idx = ctx.subrule++;
-    return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), false, crossRef, args);
-  } else if (isRuleCall(terminal) && isTerminalRule(terminal.rule.ref)) {
-    const idx = ctx.consume++;
-    const terminalRule = getToken(ctx, terminal.rule.ref.name);
-    return () => ctx.parser.consume(idx, terminalRule, crossRef);
-  } else if (isKeyword(terminal)) {
-    const idx = ctx.consume++;
-    const keyword = getToken(ctx, terminal.value);
-    return () => ctx.parser.consume(idx, keyword, crossRef);
-  } else {
-    throw new Error("Could not build cross reference parser");
-  }
-}
-function buildKeyword(ctx, keyword) {
-  const idx = ctx.consume++;
-  const token = ctx.tokens[keyword.value];
-  if (!token) {
-    throw new Error("Could not find token for keyword: " + keyword.value);
-  }
-  return () => ctx.parser.consume(idx, token, keyword);
-}
-function wrap(ctx, guard, method, cardinality) {
-  const gate = guard && buildPredicate(guard);
-  if (!cardinality) {
-    if (gate) {
-      const idx = ctx.or++;
-      return (args) => ctx.parser.alternatives(idx, [
-        {
-          ALT: () => method(args),
-          GATE: () => gate(args)
-        },
-        {
-          ALT: EMPTY_ALT(),
-          GATE: () => !gate(args)
-        }
-      ]);
-    } else {
-      return method;
-    }
-  }
-  if (cardinality === "*") {
-    const idx = ctx.many++;
-    return (args) => ctx.parser.many(idx, {
-      DEF: () => method(args),
-      GATE: gate ? () => gate(args) : void 0
-    });
-  } else if (cardinality === "+") {
-    const idx = ctx.many++;
-    if (gate) {
-      const orIdx = ctx.or++;
-      return (args) => ctx.parser.alternatives(orIdx, [
-        {
-          ALT: () => ctx.parser.atLeastOne(idx, {
-            DEF: () => method(args)
-          }),
-          GATE: () => gate(args)
-        },
-        {
-          ALT: EMPTY_ALT(),
-          GATE: () => !gate(args)
-        }
-      ]);
-    } else {
-      return (args) => ctx.parser.atLeastOne(idx, {
-        DEF: () => method(args)
-      });
-    }
-  } else if (cardinality === "?") {
-    const idx = ctx.optional++;
-    return (args) => ctx.parser.optional(idx, {
-      DEF: () => method(args),
-      GATE: gate ? () => gate(args) : void 0
-    });
-  } else {
-    assertUnreachable();
-  }
-}
-function getRule(ctx, element) {
-  const name = getRuleName(ctx, element);
-  const rule = ctx.parser.getRule(name);
-  if (!rule)
-    throw new Error(`Rule "${name}" not found."`);
-  return rule;
-}
-function getRuleName(ctx, element) {
-  if (isParserRule(element)) {
-    return element.name;
-  } else if (ctx.ruleNames.has(element)) {
-    return ctx.ruleNames.get(element);
-  } else {
-    let item = element;
-    let parent = item.$container;
-    let ruleName = element.$type;
-    while (!isParserRule(parent)) {
-      if (isGroup(parent) || isAlternatives(parent) || isUnorderedGroup(parent)) {
-        const index = parent.elements.indexOf(item);
-        ruleName = index.toString() + ":" + ruleName;
-      }
-      item = parent;
-      parent = parent.$container;
-    }
-    const rule = parent;
-    ruleName = rule.name + ":" + ruleName;
-    ctx.ruleNames.set(element, ruleName);
-    return ruleName;
-  }
-}
-function getToken(ctx, name) {
-  const token = ctx.tokens[name];
-  if (!token)
-    throw new Error(`Token "${name}" not found."`);
-  return token;
-}
-export {
-  createParser
-};
-//# sourceMappingURL=parser-builder-base.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/parser-builder-base.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"parser-builder-base.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/parser-builder-base.js"],"sourcesContent":["/******************************************************************************\n * Copyright 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 { EMPTY_ALT, EOF } from 'chevrotain';\nimport { isAction, isAlternatives, isEndOfFile, isAssignment, isConjunction, isCrossReference, isDisjunction, isGroup, isKeyword, isNegation, isParameterReference, isParserRule, isRuleCall, isTerminalRule, isUnorderedGroup, isBooleanLiteral } from '../languages/generated/ast.js';\nimport { assertUnreachable, ErrorWithLocation } from '../utils/errors.js';\nimport { stream } from '../utils/stream.js';\nimport { findNameAssignment, getAllReachableRules, getTypeName } from '../utils/grammar-utils.js';\nexport function createParser(grammar, parser, tokens) {\n    const parserContext = {\n        parser,\n        tokens,\n        ruleNames: new Map()\n    };\n    buildRules(parserContext, grammar);\n    return parser;\n}\nfunction buildRules(parserContext, grammar) {\n    const reachable = getAllReachableRules(grammar, false);\n    const parserRules = stream(grammar.rules).filter(isParserRule).filter(rule => reachable.has(rule));\n    for (const rule of parserRules) {\n        const ctx = Object.assign(Object.assign({}, parserContext), { consume: 1, optional: 1, subrule: 1, many: 1, or: 1 });\n        parserContext.parser.rule(rule, buildElement(ctx, rule.definition));\n    }\n}\nfunction buildElement(ctx, element, ignoreGuard = false) {\n    let method;\n    if (isKeyword(element)) {\n        method = buildKeyword(ctx, element);\n    }\n    else if (isAction(element)) {\n        method = buildAction(ctx, element);\n    }\n    else if (isAssignment(element)) {\n        method = buildElement(ctx, element.terminal);\n    }\n    else if (isCrossReference(element)) {\n        method = buildCrossReference(ctx, element);\n    }\n    else if (isRuleCall(element)) {\n        method = buildRuleCall(ctx, element);\n    }\n    else if (isAlternatives(element)) {\n        method = buildAlternatives(ctx, element);\n    }\n    else if (isUnorderedGroup(element)) {\n        method = buildUnorderedGroup(ctx, element);\n    }\n    else if (isGroup(element)) {\n        method = buildGroup(ctx, element);\n    }\n    else if (isEndOfFile(element)) {\n        const idx = ctx.consume++;\n        method = () => ctx.parser.consume(idx, EOF, element);\n    }\n    else {\n        throw new ErrorWithLocation(element.$cstNode, `Unexpected element type: ${element.$type}`);\n    }\n    return wrap(ctx, ignoreGuard ? undefined : getGuardCondition(element), method, element.cardinality);\n}\nfunction buildAction(ctx, action) {\n    const actionType = getTypeName(action);\n    return () => ctx.parser.action(actionType, action);\n}\nfunction buildRuleCall(ctx, ruleCall) {\n    const rule = ruleCall.rule.ref;\n    if (isParserRule(rule)) {\n        const idx = ctx.subrule++;\n        const fragment = rule.fragment;\n        const predicate = ruleCall.arguments.length > 0 ? buildRuleCallPredicate(rule, ruleCall.arguments) : () => ({});\n        return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), fragment, ruleCall, predicate(args));\n    }\n    else if (isTerminalRule(rule)) {\n        const idx = ctx.consume++;\n        const method = getToken(ctx, rule.name);\n        return () => ctx.parser.consume(idx, method, ruleCall);\n    }\n    else if (!rule) {\n        throw new ErrorWithLocation(ruleCall.$cstNode, `Undefined rule: ${ruleCall.rule.$refText}`);\n    }\n    else {\n        assertUnreachable(rule);\n    }\n}\nfunction buildRuleCallPredicate(rule, namedArgs) {\n    const predicates = namedArgs.map(e => buildPredicate(e.value));\n    return (args) => {\n        const ruleArgs = {};\n        for (let i = 0; i < predicates.length; i++) {\n            const ruleTarget = rule.parameters[i];\n            const predicate = predicates[i];\n            ruleArgs[ruleTarget.name] = predicate(args);\n        }\n        return ruleArgs;\n    };\n}\nfunction buildPredicate(condition) {\n    if (isDisjunction(condition)) {\n        const left = buildPredicate(condition.left);\n        const right = buildPredicate(condition.right);\n        return (args) => (left(args) || right(args));\n    }\n    else if (isConjunction(condition)) {\n        const left = buildPredicate(condition.left);\n        const right = buildPredicate(condition.right);\n        return (args) => (left(args) && right(args));\n    }\n    else if (isNegation(condition)) {\n        const value = buildPredicate(condition.value);\n        return (args) => !value(args);\n    }\n    else if (isParameterReference(condition)) {\n        const name = condition.parameter.ref.name;\n        return (args) => args !== undefined && args[name] === true;\n    }\n    else if (isBooleanLiteral(condition)) {\n        const value = Boolean(condition.true);\n        return () => value;\n    }\n    assertUnreachable(condition);\n}\nfunction buildAlternatives(ctx, alternatives) {\n    if (alternatives.elements.length === 1) {\n        return buildElement(ctx, alternatives.elements[0]);\n    }\n    else {\n        const methods = [];\n        for (const element of alternatives.elements) {\n            const predicatedMethod = {\n                // Since we handle the guard condition in the alternative already\n                // We can ignore the group guard condition inside\n                ALT: buildElement(ctx, element, true)\n            };\n            const guard = getGuardCondition(element);\n            if (guard) {\n                predicatedMethod.GATE = buildPredicate(guard);\n            }\n            methods.push(predicatedMethod);\n        }\n        const idx = ctx.or++;\n        return (args) => ctx.parser.alternatives(idx, methods.map(method => {\n            const alt = {\n                ALT: () => method.ALT(args)\n            };\n            const gate = method.GATE;\n            if (gate) {\n                alt.GATE = () => gate(args);\n            }\n            return alt;\n        }));\n    }\n}\nfunction buildUnorderedGroup(ctx, group) {\n    if (group.elements.length === 1) {\n        return buildElement(ctx, group.elements[0]);\n    }\n    const methods = [];\n    for (const element of group.elements) {\n        const predicatedMethod = {\n            // Since we handle the guard condition in the alternative already\n            // We can ignore the group guard condition inside\n            ALT: buildElement(ctx, element, true)\n        };\n        const guard = getGuardCondition(element);\n        if (guard) {\n            predicatedMethod.GATE = buildPredicate(guard);\n        }\n        methods.push(predicatedMethod);\n    }\n    const orIdx = ctx.or++;\n    const idFunc = (groupIdx, lParser) => {\n        const stackId = lParser.getRuleStack().join('-');\n        return `uGroup_${groupIdx}_${stackId}`;\n    };\n    const alternatives = (args) => ctx.parser.alternatives(orIdx, methods.map((method, idx) => {\n        const alt = { ALT: () => true };\n        const parser = ctx.parser;\n        alt.ALT = () => {\n            method.ALT(args);\n            if (!parser.isRecording()) {\n                const key = idFunc(orIdx, parser);\n                if (!parser.unorderedGroups.get(key)) {\n                    // init after clear state\n                    parser.unorderedGroups.set(key, []);\n                }\n                const groupState = parser.unorderedGroups.get(key);\n                if (typeof (groupState === null || groupState === void 0 ? void 0 : groupState[idx]) === 'undefined') {\n                    // Not accessed yet\n                    groupState[idx] = true;\n                }\n            }\n        };\n        const gate = method.GATE;\n        if (gate) {\n            alt.GATE = () => gate(args);\n        }\n        else {\n            alt.GATE = () => {\n                const trackedAlternatives = parser.unorderedGroups.get(idFunc(orIdx, parser));\n                const allow = !(trackedAlternatives === null || trackedAlternatives === void 0 ? void 0 : trackedAlternatives[idx]);\n                return allow;\n            };\n        }\n        return alt;\n    }));\n    const wrapped = wrap(ctx, getGuardCondition(group), alternatives, '*');\n    return (args) => {\n        wrapped(args);\n        if (!ctx.parser.isRecording()) {\n            ctx.parser.unorderedGroups.delete(idFunc(orIdx, ctx.parser));\n        }\n    };\n}\nfunction buildGroup(ctx, group) {\n    const methods = group.elements.map(e => buildElement(ctx, e));\n    return (args) => methods.forEach(method => method(args));\n}\nfunction getGuardCondition(element) {\n    if (isGroup(element)) {\n        return element.guardCondition;\n    }\n    return undefined;\n}\nfunction buildCrossReference(ctx, crossRef, terminal = crossRef.terminal) {\n    if (!terminal) {\n        if (!crossRef.type.ref) {\n            throw new Error('Could not resolve reference to type: ' + crossRef.type.$refText);\n        }\n        const assignment = findNameAssignment(crossRef.type.ref);\n        const assignTerminal = assignment === null || assignment === void 0 ? void 0 : assignment.terminal;\n        if (!assignTerminal) {\n            throw new Error('Could not find name assignment for type: ' + getTypeName(crossRef.type.ref));\n        }\n        return buildCrossReference(ctx, crossRef, assignTerminal);\n    }\n    else if (isRuleCall(terminal) && isParserRule(terminal.rule.ref)) {\n        // The terminal is a data type rule here. Everything else will result in a validation error.\n        const rule = terminal.rule.ref;\n        const idx = ctx.subrule++;\n        return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), false, crossRef, args);\n    }\n    else if (isRuleCall(terminal) && isTerminalRule(terminal.rule.ref)) {\n        const idx = ctx.consume++;\n        const terminalRule = getToken(ctx, terminal.rule.ref.name);\n        return () => ctx.parser.consume(idx, terminalRule, crossRef);\n    }\n    else if (isKeyword(terminal)) {\n        const idx = ctx.consume++;\n        const keyword = getToken(ctx, terminal.value);\n        return () => ctx.parser.consume(idx, keyword, crossRef);\n    }\n    else {\n        throw new Error('Could not build cross reference parser');\n    }\n}\nfunction buildKeyword(ctx, keyword) {\n    const idx = ctx.consume++;\n    const token = ctx.tokens[keyword.value];\n    if (!token) {\n        throw new Error('Could not find token for keyword: ' + keyword.value);\n    }\n    return () => ctx.parser.consume(idx, token, keyword);\n}\nfunction wrap(ctx, guard, method, cardinality) {\n    const gate = guard && buildPredicate(guard);\n    if (!cardinality) {\n        if (gate) {\n            const idx = ctx.or++;\n            return (args) => ctx.parser.alternatives(idx, [\n                {\n                    ALT: () => method(args),\n                    GATE: () => gate(args)\n                },\n                {\n                    ALT: EMPTY_ALT(),\n                    GATE: () => !gate(args)\n                }\n            ]);\n        }\n        else {\n            return method;\n        }\n    }\n    if (cardinality === '*') {\n        const idx = ctx.many++;\n        return (args) => ctx.parser.many(idx, {\n            DEF: () => method(args),\n            GATE: gate ? () => gate(args) : undefined\n        });\n    }\n    else if (cardinality === '+') {\n        const idx = ctx.many++;\n        if (gate) {\n            const orIdx = ctx.or++;\n            // In the case of a guard condition for the `+` group\n            // We combine it with an empty alternative\n            // If the condition returns true, it needs to parse at least a single iteration\n            // If its false, it is not allowed to parse anything\n            return (args) => ctx.parser.alternatives(orIdx, [\n                {\n                    ALT: () => ctx.parser.atLeastOne(idx, {\n                        DEF: () => method(args)\n                    }),\n                    GATE: () => gate(args)\n                },\n                {\n                    ALT: EMPTY_ALT(),\n                    GATE: () => !gate(args)\n                }\n            ]);\n        }\n        else {\n            return (args) => ctx.parser.atLeastOne(idx, {\n                DEF: () => method(args),\n            });\n        }\n    }\n    else if (cardinality === '?') {\n        const idx = ctx.optional++;\n        return (args) => ctx.parser.optional(idx, {\n            DEF: () => method(args),\n            GATE: gate ? () => gate(args) : undefined\n        });\n    }\n    else {\n        assertUnreachable(cardinality);\n    }\n}\nfunction getRule(ctx, element) {\n    const name = getRuleName(ctx, element);\n    const rule = ctx.parser.getRule(name);\n    if (!rule)\n        throw new Error(`Rule \"${name}\" not found.\"`);\n    return rule;\n}\nfunction getRuleName(ctx, element) {\n    if (isParserRule(element)) {\n        return element.name;\n    }\n    else if (ctx.ruleNames.has(element)) {\n        return ctx.ruleNames.get(element);\n    }\n    else {\n        let item = element;\n        let parent = item.$container;\n        let ruleName = element.$type;\n        while (!isParserRule(parent)) {\n            if (isGroup(parent) || isAlternatives(parent) || isUnorderedGroup(parent)) {\n                const index = parent.elements.indexOf(item);\n                ruleName = index.toString() + ':' + ruleName;\n            }\n            item = parent;\n            parent = parent.$container;\n        }\n        const rule = parent;\n        ruleName = rule.name + ':' + ruleName;\n        ctx.ruleNames.set(element, ruleName);\n        return ruleName;\n    }\n}\nfunction getToken(ctx, name) {\n    const token = ctx.tokens[name];\n    if (!token)\n        throw new Error(`Token \"${name}\" not found.\"`);\n    return token;\n}\n//# sourceMappingURL=parser-builder-base.js.map"],"names":[],"mappings":";;;;;;;;;;AAUO,SAAS,aAAa,SAAS,QAAQ,QAAQ;AAClD,QAAM,gBAAgB;AAAA,IAClB;AAAA,IACA;AAAA,IACA,WAAW,oBAAI,IAAG;AAAA,EAC1B;AACI,aAAW,eAAe,OAAO;AACjC,SAAO;AACX;AACA,SAAS,WAAW,eAAe,SAAS;AACxC,QAAM,YAAY,qBAAqB,SAAS,KAAK;AACrD,QAAM,cAAc,OAAO,QAAQ,KAAK,EAAE,OAAO,YAAY,EAAE,OAAO,UAAQ,UAAU,IAAI,IAAI,CAAC;AACjG,aAAW,QAAQ,aAAa;AAC5B,UAAM,MAAM,OAAO,OAAO,OAAO,OAAO,CAAA,GAAI,aAAa,GAAG,EAAE,SAAS,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,GAAG;AACnH,kBAAc,OAAO,KAAK,MAAM,aAAa,KAAK,KAAK,UAAU,CAAC;AAAA,EACtE;AACJ;AACA,SAAS,aAAa,KAAK,SAAS,cAAc,OAAO;AACrD,MAAI;AACJ,MAAI,UAAU,OAAO,GAAG;AACpB,aAAS,aAAa,KAAK,OAAO;AAAA,EACtC,WACS,SAAS,OAAO,GAAG;AACxB,aAAS,YAAY,KAAK,OAAO;AAAA,EACrC,WACS,aAAa,OAAO,GAAG;AAC5B,aAAS,aAAa,KAAK,QAAQ,QAAQ;AAAA,EAC/C,WACS,iBAAiB,OAAO,GAAG;AAChC,aAAS,oBAAoB,KAAK,OAAO;AAAA,EAC7C,WACS,WAAW,OAAO,GAAG;AAC1B,aAAS,cAAc,KAAK,OAAO;AAAA,EACvC,WACS,eAAe,OAAO,GAAG;AAC9B,aAAS,kBAAkB,KAAK,OAAO;AAAA,EAC3C,WACS,iBAAiB,OAAO,GAAG;AAChC,aAAS,oBAAoB,KAAK,OAAO;AAAA,EAC7C,WACS,QAAQ,OAAO,GAAG;AACvB,aAAS,WAAW,KAAK,OAAO;AAAA,EACpC,WACS,YAAY,OAAO,GAAG;AAC3B,UAAM,MAAM,IAAI;AAChB,aAAS,MAAM,IAAI,OAAO,QAAQ,KAAK,KAAK,OAAO;AAAA,EACvD,OACK;AACD,UAAM,IAAI,kBAAkB,QAAQ,UAAU,4BAA4B,QAAQ,KAAK,EAAE;AAAA,EAC7F;AACA,SAAO,KAAK,KAAK,cAAc,SAAY,kBAAkB,OAAO,GAAG,QAAQ,QAAQ,WAAW;AACtG;AACA,SAAS,YAAY,KAAK,QAAQ;AAC9B,QAAM,aAAa,YAAY,MAAM;AACrC,SAAO,MAAM,IAAI,OAAO,OAAO,YAAY,MAAM;AACrD;AACA,SAAS,cAAc,KAAK,UAAU;AAClC,QAAM,OAAO,SAAS,KAAK;AAC3B,MAAI,aAAa,IAAI,GAAG;AACpB,UAAM,MAAM,IAAI;AAChB,UAAM,WAAW,KAAK;AACtB,UAAM,YAAY,SAAS,UAAU,SAAS,IAAI,uBAAuB,MAAM,SAAS,SAAS,IAAI,OAAO,CAAA;AAC5G,WAAO,CAAC,SAAS,IAAI,OAAO,QAAQ,KAAK,QAAQ,KAAK,IAAI,GAAG,UAAU,UAAU,UAAU,IAAI,CAAC;AAAA,EACpG,WACS,eAAe,IAAI,GAAG;AAC3B,UAAM,MAAM,IAAI;AAChB,UAAM,SAAS,SAAS,KAAK,KAAK,IAAI;AACtC,WAAO,MAAM,IAAI,OAAO,QAAQ,KAAK,QAAQ,QAAQ;AAAA,EACzD,WACS,CAAC,MAAM;AACZ,UAAM,IAAI,kBAAkB,SAAS,UAAU,mBAAmB,SAAS,KAAK,QAAQ,EAAE;AAAA,EAC9F,OACK;AACD,sBAAsB;AAAA,EAC1B;AACJ;AACA,SAAS,uBAAuB,MAAM,WAAW;AAC7C,QAAM,aAAa,UAAU,IAAI,OAAK,eAAe,EAAE,KAAK,CAAC;AAC7D,SAAO,CAAC,SAAS;AACb,UAAM,WAAW,CAAA;AACjB,aAAS,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;AACxC,YAAM,aAAa,KAAK,WAAW,CAAC;AACpC,YAAM,YAAY,WAAW,CAAC;AAC9B,eAAS,WAAW,IAAI,IAAI,UAAU,IAAI;AAAA,IAC9C;AACA,WAAO;AAAA,EACX;AACJ;AACA,SAAS,eAAe,WAAW;AAC/B,MAAI,cAAc,SAAS,GAAG;AAC1B,UAAM,OAAO,eAAe,UAAU,IAAI;AAC1C,UAAM,QAAQ,eAAe,UAAU,KAAK;AAC5C,WAAO,CAAC,SAAU,KAAK,IAAI,KAAK,MAAM,IAAI;AAAA,EAC9C,WACS,cAAc,SAAS,GAAG;AAC/B,UAAM,OAAO,eAAe,UAAU,IAAI;AAC1C,UAAM,QAAQ,eAAe,UAAU,KAAK;AAC5C,WAAO,CAAC,SAAU,KAAK,IAAI,KAAK,MAAM,IAAI;AAAA,EAC9C,WACS,WAAW,SAAS,GAAG;AAC5B,UAAM,QAAQ,eAAe,UAAU,KAAK;AAC5C,WAAO,CAAC,SAAS,CAAC,MAAM,IAAI;AAAA,EAChC,WACS,qBAAqB,SAAS,GAAG;AACtC,UAAM,OAAO,UAAU,UAAU,IAAI;AACrC,WAAO,CAAC,SAAS,SAAS,UAAa,KAAK,IAAI,MAAM;AAAA,EAC1D,WACS,iBAAiB,SAAS,GAAG;AAClC,UAAM,QAAQ,QAAQ,UAAU,IAAI;AACpC,WAAO,MAAM;AAAA,EACjB;AACA,oBAA2B;AAC/B;AACA,SAAS,kBAAkB,KAAK,cAAc;AAC1C,MAAI,aAAa,SAAS,WAAW,GAAG;AACpC,WAAO,aAAa,KAAK,aAAa,SAAS,CAAC,CAAC;AAAA,EACrD,OACK;AACD,UAAM,UAAU,CAAA;AAChB,eAAW,WAAW,aAAa,UAAU;AACzC,YAAM,mBAAmB;AAAA;AAAA;AAAA,QAGrB,KAAK,aAAa,KAAK,SAAS,IAAI;AAAA,MACpD;AACY,YAAM,QAAQ,kBAAkB,OAAO;AACvC,UAAI,OAAO;AACP,yBAAiB,OAAO,eAAe,KAAK;AAAA,MAChD;AACA,cAAQ,KAAK,gBAAgB;AAAA,IACjC;AACA,UAAM,MAAM,IAAI;AAChB,WAAO,CAAC,SAAS,IAAI,OAAO,aAAa,KAAK,QAAQ,IAAI,YAAU;AAChE,YAAM,MAAM;AAAA,QACR,KAAK,MAAM,OAAO,IAAI,IAAI;AAAA,MAC1C;AACY,YAAM,OAAO,OAAO;AACpB,UAAI,MAAM;AACN,YAAI,OAAO,MAAM,KAAK,IAAI;AAAA,MAC9B;AACA,aAAO;AAAA,IACX,CAAC,CAAC;AAAA,EACN;AACJ;AACA,SAAS,oBAAoB,KAAK,OAAO;AACrC,MAAI,MAAM,SAAS,WAAW,GAAG;AAC7B,WAAO,aAAa,KAAK,MAAM,SAAS,CAAC,CAAC;AAAA,EAC9C;AACA,QAAM,UAAU,CAAA;AAChB,aAAW,WAAW,MAAM,UAAU;AAClC,UAAM,mBAAmB;AAAA;AAAA;AAAA,MAGrB,KAAK,aAAa,KAAK,SAAS,IAAI;AAAA,IAChD;AACQ,UAAM,QAAQ,kBAAkB,OAAO;AACvC,QAAI,OAAO;AACP,uBAAiB,OAAO,eAAe,KAAK;AAAA,IAChD;AACA,YAAQ,KAAK,gBAAgB;AAAA,EACjC;AACA,QAAM,QAAQ,IAAI;AAClB,QAAM,SAAS,CAAC,UAAU,YAAY;AAClC,UAAM,UAAU,QAAQ,aAAY,EAAG,KAAK,GAAG;AAC/C,WAAO,UAAU,QAAQ,IAAI,OAAO;AAAA,EACxC;AACA,QAAM,eAAe,CAAC,SAAS,IAAI,OAAO,aAAa,OAAO,QAAQ,IAAI,CAAC,QAAQ,QAAQ;AACvF,UAAM,MAAM,EAAE,KAAK,MAAM,KAAI;AAC7B,UAAM,SAAS,IAAI;AACnB,QAAI,MAAM,MAAM;AACZ,aAAO,IAAI,IAAI;AACf,UAAI,CAAC,OAAO,eAAe;AACvB,cAAM,MAAM,OAAO,OAAO,MAAM;AAChC,YAAI,CAAC,OAAO,gBAAgB,IAAI,GAAG,GAAG;AAElC,iBAAO,gBAAgB,IAAI,KAAK,CAAA,CAAE;AAAA,QACtC;AACA,cAAM,aAAa,OAAO,gBAAgB,IAAI,GAAG;AACjD,YAAI,QAAQ,eAAe,QAAQ,eAAe,SAAS,SAAS,WAAW,GAAG,OAAO,aAAa;AAElG,qBAAW,GAAG,IAAI;AAAA,QACtB;AAAA,MACJ;AAAA,IACJ;AACA,UAAM,OAAO,OAAO;AACpB,QAAI,MAAM;AACN,UAAI,OAAO,MAAM,KAAK,IAAI;AAAA,IAC9B,OACK;AACD,UAAI,OAAO,MAAM;AACb,cAAM,sBAAsB,OAAO,gBAAgB,IAAI,OAAO,OAAO,MAAM,CAAC;AAC5E,cAAM,QAAQ,EAAE,wBAAwB,QAAQ,wBAAwB,SAAS,SAAS,oBAAoB,GAAG;AACjH,eAAO;AAAA,MACX;AAAA,IACJ;AACA,WAAO;AAAA,EACX,CAAC,CAAC;AACF,QAAM,UAAU,KAAK,KAAK,kBAAkB,KAAK,GAAG,cAAc,GAAG;AACrE,SAAO,CAAC,SAAS;AACb,YAAQ,IAAI;AACZ,QAAI,CAAC,IAAI,OAAO,eAAe;AAC3B,UAAI,OAAO,gBAAgB,OAAO,OAAO,OAAO,IAAI,MAAM,CAAC;AAAA,IAC/D;AAAA,EACJ;AACJ;AACA,SAAS,WAAW,KAAK,OAAO;AAC5B,QAAM,UAAU,MAAM,SAAS,IAAI,OAAK,aAAa,KAAK,CAAC,CAAC;AAC5D,SAAO,CAAC,SAAS,QAAQ,QAAQ,YAAU,OAAO,IAAI,CAAC;AAC3D;AACA,SAAS,kBAAkB,SAAS;AAChC,MAAI,QAAQ,OAAO,GAAG;AAClB,WAAO,QAAQ;AAAA,EACnB;AACA,SAAO;AACX;AACA,SAAS,oBAAoB,KAAK,UAAU,WAAW,SAAS,UAAU;AACtE,MAAI,CAAC,UAAU;AACX,QAAI,CAAC,SAAS,KAAK,KAAK;AACpB,YAAM,IAAI,MAAM,0CAA0C,SAAS,KAAK,QAAQ;AAAA,IACpF;AACA,UAAM,aAAa,mBAAmB,SAAS,KAAK,GAAG;AACvD,UAAM,iBAAiB,eAAe,QAAQ,eAAe,SAAS,SAAS,WAAW;AAC1F,QAAI,CAAC,gBAAgB;AACjB,YAAM,IAAI,MAAM,8CAA8C,YAAY,SAAS,KAAK,GAAG,CAAC;AAAA,IAChG;AACA,WAAO,oBAAoB,KAAK,UAAU,cAAc;AAAA,EAC5D,WACS,WAAW,QAAQ,KAAK,aAAa,SAAS,KAAK,GAAG,GAAG;AAE9D,UAAM,OAAO,SAAS,KAAK;AAC3B,UAAM,MAAM,IAAI;AAChB,WAAO,CAAC,SAAS,IAAI,OAAO,QAAQ,KAAK,QAAQ,KAAK,IAAI,GAAG,OAAO,UAAU,IAAI;AAAA,EACtF,WACS,WAAW,QAAQ,KAAK,eAAe,SAAS,KAAK,GAAG,GAAG;AAChE,UAAM,MAAM,IAAI;AAChB,UAAM,eAAe,SAAS,KAAK,SAAS,KAAK,IAAI,IAAI;AACzD,WAAO,MAAM,IAAI,OAAO,QAAQ,KAAK,cAAc,QAAQ;AAAA,EAC/D,WACS,UAAU,QAAQ,GAAG;AAC1B,UAAM,MAAM,IAAI;AAChB,UAAM,UAAU,SAAS,KAAK,SAAS,KAAK;AAC5C,WAAO,MAAM,IAAI,OAAO,QAAQ,KAAK,SAAS,QAAQ;AAAA,EAC1D,OACK;AACD,UAAM,IAAI,MAAM,wCAAwC;AAAA,EAC5D;AACJ;AACA,SAAS,aAAa,KAAK,SAAS;AAChC,QAAM,MAAM,IAAI;AAChB,QAAM,QAAQ,IAAI,OAAO,QAAQ,KAAK;AACtC,MAAI,CAAC,OAAO;AACR,UAAM,IAAI,MAAM,uCAAuC,QAAQ,KAAK;AAAA,EACxE;AACA,SAAO,MAAM,IAAI,OAAO,QAAQ,KAAK,OAAO,OAAO;AACvD;AACA,SAAS,KAAK,KAAK,OAAO,QAAQ,aAAa;AAC3C,QAAM,OAAO,SAAS,eAAe,KAAK;AAC1C,MAAI,CAAC,aAAa;AACd,QAAI,MAAM;AACN,YAAM,MAAM,IAAI;AAChB,aAAO,CAAC,SAAS,IAAI,OAAO,aAAa,KAAK;AAAA,QAC1C;AAAA,UACI,KAAK,MAAM,OAAO,IAAI;AAAA,UACtB,MAAM,MAAM,KAAK,IAAI;AAAA,QACzC;AAAA,QACgB;AAAA,UACI,KAAK,UAAS;AAAA,UACd,MAAM,MAAM,CAAC,KAAK,IAAI;AAAA,QAC1C;AAAA,MACA,CAAa;AAAA,IACL,OACK;AACD,aAAO;AAAA,IACX;AAAA,EACJ;AACA,MAAI,gBAAgB,KAAK;AACrB,UAAM,MAAM,IAAI;AAChB,WAAO,CAAC,SAAS,IAAI,OAAO,KAAK,KAAK;AAAA,MAClC,KAAK,MAAM,OAAO,IAAI;AAAA,MACtB,MAAM,OAAO,MAAM,KAAK,IAAI,IAAI;AAAA,IAC5C,CAAS;AAAA,EACL,WACS,gBAAgB,KAAK;AAC1B,UAAM,MAAM,IAAI;AAChB,QAAI,MAAM;AACN,YAAM,QAAQ,IAAI;AAKlB,aAAO,CAAC,SAAS,IAAI,OAAO,aAAa,OAAO;AAAA,QAC5C;AAAA,UACI,KAAK,MAAM,IAAI,OAAO,WAAW,KAAK;AAAA,YAClC,KAAK,MAAM,OAAO,IAAI;AAAA,UAC9C,CAAqB;AAAA,UACD,MAAM,MAAM,KAAK,IAAI;AAAA,QACzC;AAAA,QACgB;AAAA,UACI,KAAK,UAAS;AAAA,UACd,MAAM,MAAM,CAAC,KAAK,IAAI;AAAA,QAC1C;AAAA,MACA,CAAa;AAAA,IACL,OACK;AACD,aAAO,CAAC,SAAS,IAAI,OAAO,WAAW,KAAK;AAAA,QACxC,KAAK,MAAM,OAAO,IAAI;AAAA,MACtC,CAAa;AAAA,IACL;AAAA,EACJ,WACS,gBAAgB,KAAK;AAC1B,UAAM,MAAM,IAAI;AAChB,WAAO,CAAC,SAAS,IAAI,OAAO,SAAS,KAAK;AAAA,MACtC,KAAK,MAAM,OAAO,IAAI;AAAA,MACtB,MAAM,OAAO,MAAM,KAAK,IAAI,IAAI;AAAA,IAC5C,CAAS;AAAA,EACL,OACK;AACD,sBAA6B;AAAA,EACjC;AACJ;AACA,SAAS,QAAQ,KAAK,SAAS;AAC3B,QAAM,OAAO,YAAY,KAAK,OAAO;AACrC,QAAM,OAAO,IAAI,OAAO,QAAQ,IAAI;AACpC,MAAI,CAAC;AACD,UAAM,IAAI,MAAM,SAAS,IAAI,eAAe;AAChD,SAAO;AACX;AACA,SAAS,YAAY,KAAK,SAAS;AAC/B,MAAI,aAAa,OAAO,GAAG;AACvB,WAAO,QAAQ;AAAA,EACnB,WACS,IAAI,UAAU,IAAI,OAAO,GAAG;AACjC,WAAO,IAAI,UAAU,IAAI,OAAO;AAAA,EACpC,OACK;AACD,QAAI,OAAO;AACX,QAAI,SAAS,KAAK;AAClB,QAAI,WAAW,QAAQ;AACvB,WAAO,CAAC,aAAa,MAAM,GAAG;AAC1B,UAAI,QAAQ,MAAM,KAAK,eAAe,MAAM,KAAK,iBAAiB,MAAM,GAAG;AACvE,cAAM,QAAQ,OAAO,SAAS,QAAQ,IAAI;AAC1C,mBAAW,MAAM,SAAQ,IAAK,MAAM;AAAA,MACxC;AACA,aAAO;AACP,eAAS,OAAO;AAAA,IACpB;AACA,UAAM,OAAO;AACb,eAAW,KAAK,OAAO,MAAM;AAC7B,QAAI,UAAU,IAAI,SAAS,QAAQ;AACnC,WAAO;AAAA,EACX;AACJ;AACA,SAAS,SAAS,KAAK,MAAM;AACzB,QAAM,QAAQ,IAAI,OAAO,IAAI;AAC7B,MAAI,CAAC;AACD,UAAM,IAAI,MAAM,UAAU,IAAI,eAAe;AACjD,SAAO;AACX;","x_google_ignoreList":[0]}

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

@@ -1,105 +0,0 @@
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/parser.mjs";
-import { Lexer } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_public.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/errors_public.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs";
-import { isTerminalRule, isParserRule, isKeyword } from "../languages/generated/ast.mjs";
-import { streamAllContents } from "../utils/ast-utils.mjs";
-import { getAllReachableRules, terminalRegex } from "../utils/grammar-utils.mjs";
-import { isWhitespace, getCaseInsensitivePattern, partialMatches } from "../utils/regexp-utils.mjs";
-import { stream } from "../utils/stream.mjs";
-class DefaultTokenBuilder {
-  constructor() {
-    this.diagnostics = [];
-  }
-  buildTokens(grammar, options) {
-    const reachableRules = stream(getAllReachableRules(grammar, false));
-    const terminalTokens = this.buildTerminalTokens(reachableRules);
-    const tokens = this.buildKeywordTokens(reachableRules, terminalTokens, options);
-    terminalTokens.forEach((terminalToken) => {
-      const pattern = terminalToken.PATTERN;
-      if (typeof pattern === "object" && pattern && "test" in pattern && isWhitespace(pattern)) {
-        tokens.unshift(terminalToken);
-      } else {
-        tokens.push(terminalToken);
-      }
-    });
-    return tokens;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  flushLexingReport(text) {
-    return { diagnostics: this.popDiagnostics() };
-  }
-  popDiagnostics() {
-    const diagnostics = [...this.diagnostics];
-    this.diagnostics = [];
-    return diagnostics;
-  }
-  buildTerminalTokens(rules) {
-    return rules.filter(isTerminalRule).filter((e) => !e.fragment).map((terminal) => this.buildTerminalToken(terminal)).toArray();
-  }
-  buildTerminalToken(terminal) {
-    const regex = terminalRegex(terminal);
-    const pattern = this.requiresCustomPattern(regex) ? this.regexPatternFunction(regex) : regex;
-    const tokenType = {
-      name: terminal.name,
-      PATTERN: pattern
-    };
-    if (typeof pattern === "function") {
-      tokenType.LINE_BREAKS = true;
-    }
-    if (terminal.hidden) {
-      tokenType.GROUP = isWhitespace(regex) ? Lexer.SKIPPED : "hidden";
-    }
-    return tokenType;
-  }
-  requiresCustomPattern(regex) {
-    if (regex.flags.includes("u") || regex.flags.includes("s")) {
-      return true;
-    } else if (regex.source.includes("?<=") || regex.source.includes("?<!")) {
-      return true;
-    } else {
-      return false;
-    }
-  }
-  regexPatternFunction(regex) {
-    const stickyRegex = new RegExp(regex, regex.flags + "y");
-    return (text, offset) => {
-      stickyRegex.lastIndex = offset;
-      const execResult = stickyRegex.exec(text);
-      return execResult;
-    };
-  }
-  buildKeywordTokens(rules, terminalTokens, options) {
-    return rules.filter(isParserRule).flatMap((rule) => streamAllContents(rule).filter(isKeyword)).distinct((e) => e.value).toArray().sort((a, b) => b.value.length - a.value.length).map((keyword) => this.buildKeywordToken(keyword, terminalTokens, Boolean(options === null || options === void 0 ? void 0 : options.caseInsensitive)));
-  }
-  buildKeywordToken(keyword, terminalTokens, caseInsensitive) {
-    const keywordPattern = this.buildKeywordPattern(keyword, caseInsensitive);
-    const tokenType = {
-      name: keyword.value,
-      PATTERN: keywordPattern,
-      LONGER_ALT: this.findLongerAlt(keyword, terminalTokens)
-    };
-    if (typeof keywordPattern === "function") {
-      tokenType.LINE_BREAKS = true;
-    }
-    return tokenType;
-  }
-  buildKeywordPattern(keyword, caseInsensitive) {
-    return caseInsensitive ? new RegExp(getCaseInsensitivePattern(keyword.value)) : keyword.value;
-  }
-  findLongerAlt(keyword, terminalTokens) {
-    return terminalTokens.reduce((longerAlts, token) => {
-      const pattern = token === null || token === void 0 ? void 0 : token.PATTERN;
-      if ((pattern === null || pattern === void 0 ? void 0 : pattern.source) && partialMatches("^" + pattern.source + "$", keyword.value)) {
-        longerAlts.push(token);
-      }
-      return longerAlts;
-    }, []);
-  }
-}
-export {
-  DefaultTokenBuilder
-};
-//# sourceMappingURL=token-builder.mjs.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"token-builder.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/token-builder.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 { Lexer } from 'chevrotain';\nimport { isKeyword, isParserRule, isTerminalRule } from '../languages/generated/ast.js';\nimport { streamAllContents } from '../utils/ast-utils.js';\nimport { getAllReachableRules, terminalRegex } from '../utils/grammar-utils.js';\nimport { getCaseInsensitivePattern, isWhitespace, partialMatches } from '../utils/regexp-utils.js';\nimport { stream } from '../utils/stream.js';\nexport class DefaultTokenBuilder {\n    constructor() {\n        /**\n         * The list of diagnostics stored during the lexing process of a single text.\n         */\n        this.diagnostics = [];\n    }\n    buildTokens(grammar, options) {\n        const reachableRules = stream(getAllReachableRules(grammar, false));\n        const terminalTokens = this.buildTerminalTokens(reachableRules);\n        const tokens = this.buildKeywordTokens(reachableRules, terminalTokens, options);\n        terminalTokens.forEach(terminalToken => {\n            const pattern = terminalToken.PATTERN;\n            if (typeof pattern === 'object' && pattern && 'test' in pattern && isWhitespace(pattern)) {\n                tokens.unshift(terminalToken);\n            }\n            else {\n                tokens.push(terminalToken);\n            }\n        });\n        // We don't need to add the EOF token explicitly.\n        // It is automatically available at the end of the token stream.\n        return tokens;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    flushLexingReport(text) {\n        return { diagnostics: this.popDiagnostics() };\n    }\n    popDiagnostics() {\n        const diagnostics = [...this.diagnostics];\n        this.diagnostics = [];\n        return diagnostics;\n    }\n    buildTerminalTokens(rules) {\n        return rules.filter(isTerminalRule).filter(e => !e.fragment)\n            .map(terminal => this.buildTerminalToken(terminal)).toArray();\n    }\n    buildTerminalToken(terminal) {\n        const regex = terminalRegex(terminal);\n        const pattern = this.requiresCustomPattern(regex) ? this.regexPatternFunction(regex) : regex;\n        const tokenType = {\n            name: terminal.name,\n            PATTERN: pattern,\n        };\n        if (typeof pattern === 'function') {\n            tokenType.LINE_BREAKS = true;\n        }\n        if (terminal.hidden) {\n            // Only skip tokens that are able to accept whitespace\n            tokenType.GROUP = isWhitespace(regex) ? Lexer.SKIPPED : 'hidden';\n        }\n        return tokenType;\n    }\n    requiresCustomPattern(regex) {\n        if (regex.flags.includes('u') || regex.flags.includes('s')) {\n            // Unicode and dotall regexes are not supported by Chevrotain.\n            return true;\n        }\n        else if (regex.source.includes('?<=') || regex.source.includes('?<!')) {\n            // Negative and positive lookbehind are not supported by Chevrotain yet.\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n    regexPatternFunction(regex) {\n        const stickyRegex = new RegExp(regex, regex.flags + 'y');\n        return (text, offset) => {\n            stickyRegex.lastIndex = offset;\n            const execResult = stickyRegex.exec(text);\n            return execResult;\n        };\n    }\n    buildKeywordTokens(rules, terminalTokens, options) {\n        return rules\n            // We filter by parser rules, since keywords in terminal rules get transformed into regex and are not actual tokens\n            .filter(isParserRule)\n            .flatMap(rule => streamAllContents(rule).filter(isKeyword))\n            .distinct(e => e.value).toArray()\n            // Sort keywords by descending length\n            .sort((a, b) => b.value.length - a.value.length)\n            .map(keyword => this.buildKeywordToken(keyword, terminalTokens, Boolean(options === null || options === void 0 ? void 0 : options.caseInsensitive)));\n    }\n    buildKeywordToken(keyword, terminalTokens, caseInsensitive) {\n        const keywordPattern = this.buildKeywordPattern(keyword, caseInsensitive);\n        const tokenType = {\n            name: keyword.value,\n            PATTERN: keywordPattern,\n            LONGER_ALT: this.findLongerAlt(keyword, terminalTokens)\n        };\n        if (typeof keywordPattern === 'function') {\n            tokenType.LINE_BREAKS = true;\n        }\n        return tokenType;\n    }\n    buildKeywordPattern(keyword, caseInsensitive) {\n        return caseInsensitive ?\n            new RegExp(getCaseInsensitivePattern(keyword.value)) :\n            keyword.value;\n    }\n    findLongerAlt(keyword, terminalTokens) {\n        return terminalTokens.reduce((longerAlts, token) => {\n            const pattern = token === null || token === void 0 ? void 0 : token.PATTERN;\n            if ((pattern === null || pattern === void 0 ? void 0 : pattern.source) && partialMatches('^' + pattern.source + '$', keyword.value)) {\n                longerAlts.push(token);\n            }\n            return longerAlts;\n        }, []);\n    }\n}\n//# sourceMappingURL=token-builder.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"value-converter.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/value-converter.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 { isCrossReference, isRuleCall } from '../languages/generated/ast.js';\nimport { getCrossReferenceTerminal, getRuleType } from '../utils/grammar-utils.js';\nexport class DefaultValueConverter {\n    convert(input, cstNode) {\n        let feature = cstNode.grammarSource;\n        if (isCrossReference(feature)) {\n            feature = getCrossReferenceTerminal(feature);\n        }\n        if (isRuleCall(feature)) {\n            const rule = feature.rule.ref;\n            if (!rule) {\n                throw new Error('This cst node was not parsed by a rule.');\n            }\n            return this.runConverter(rule, input, cstNode);\n        }\n        return input;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    runConverter(rule, input, cstNode) {\n        var _a;\n        switch (rule.name.toUpperCase()) {\n            case 'INT': return ValueConverter.convertInt(input);\n            case 'STRING': return ValueConverter.convertString(input);\n            case 'ID': return ValueConverter.convertID(input);\n        }\n        switch ((_a = getRuleType(rule)) === null || _a === void 0 ? void 0 : _a.toLowerCase()) {\n            case 'number': return ValueConverter.convertNumber(input);\n            case 'boolean': return ValueConverter.convertBoolean(input);\n            case 'bigint': return ValueConverter.convertBigint(input);\n            case 'date': return ValueConverter.convertDate(input);\n            default: return input;\n        }\n    }\n}\nexport var ValueConverter;\n(function (ValueConverter) {\n    function convertString(input) {\n        let result = '';\n        for (let i = 1; i < input.length - 1; i++) {\n            const c = input.charAt(i);\n            if (c === '\\\\') {\n                const c1 = input.charAt(++i);\n                result += convertEscapeCharacter(c1);\n            }\n            else {\n                result += c;\n            }\n        }\n        return result;\n    }\n    ValueConverter.convertString = convertString;\n    function convertEscapeCharacter(char) {\n        switch (char) {\n            case 'b': return '\\b';\n            case 'f': return '\\f';\n            case 'n': return '\\n';\n            case 'r': return '\\r';\n            case 't': return '\\t';\n            case 'v': return '\\v';\n            case '0': return '\\0';\n            default: return char;\n        }\n    }\n    function convertID(input) {\n        if (input.charAt(0) === '^') {\n            return input.substring(1);\n        }\n        else {\n            return input;\n        }\n    }\n    ValueConverter.convertID = convertID;\n    function convertInt(input) {\n        return parseInt(input);\n    }\n    ValueConverter.convertInt = convertInt;\n    function convertBigint(input) {\n        return BigInt(input);\n    }\n    ValueConverter.convertBigint = convertBigint;\n    function convertDate(input) {\n        return new Date(input);\n    }\n    ValueConverter.convertDate = convertDate;\n    function convertNumber(input) {\n        return Number(input);\n    }\n    ValueConverter.convertNumber = convertNumber;\n    function convertBoolean(input) {\n        return input.toLowerCase() === 'true';\n    }\n    ValueConverter.convertBoolean = convertBoolean;\n})(ValueConverter || (ValueConverter = {}));\n//# sourceMappingURL=value-converter.js.map"],"names":["ValueConverter"],"mappings":";;AAOO,MAAM,sBAAsB;AAAA,EAC/B,QAAQ,OAAO,SAAS;AACpB,QAAI,UAAU,QAAQ;AACtB,QAAI,iBAAiB,OAAO,GAAG;AAC3B,gBAAU,0BAA0B,OAAO;AAAA,IAC/C;AACA,QAAI,WAAW,OAAO,GAAG;AACrB,YAAM,OAAO,QAAQ,KAAK;AAC1B,UAAI,CAAC,MAAM;AACP,cAAM,IAAI,MAAM,yCAAyC;AAAA,MAC7D;AACA,aAAO,KAAK,aAAa,MAAM,OAAO,OAAO;AAAA,IACjD;AACA,WAAO;AAAA,EACX;AAAA;AAAA,EAEA,aAAa,MAAM,OAAO,SAAS;AAC/B,QAAI;AACJ,YAAQ,KAAK,KAAK,YAAW,GAAE;AAAA,MAC3B,KAAK;AAAO,eAAO,eAAe,WAAW,KAAK;AAAA,MAClD,KAAK;AAAU,eAAO,eAAe,cAAc,KAAK;AAAA,MACxD,KAAK;AAAM,eAAO,eAAe,UAAU,KAAK;AAAA,IAC5D;AACQ,aAAS,KAAK,YAAY,IAAI,OAAO,QAAQ,OAAO,SAAS,SAAS,GAAG,YAAW,GAAE;AAAA,MAClF,KAAK;AAAU,eAAO,eAAe,cAAc,KAAK;AAAA,MACxD,KAAK;AAAW,eAAO,eAAe,eAAe,KAAK;AAAA,MAC1D,KAAK;AAAU,eAAO,eAAe,cAAc,KAAK;AAAA,MACxD,KAAK;AAAQ,eAAO,eAAe,YAAY,KAAK;AAAA,MACpD;AAAS,eAAO;AAAA,IAC5B;AAAA,EACI;AACJ;AACU,IAAC;AAAA,CACV,SAAUA,iBAAgB;AACvB,WAAS,cAAc,OAAO;AAC1B,QAAI,SAAS;AACb,aAAS,IAAI,GAAG,IAAI,MAAM,SAAS,GAAG,KAAK;AACvC,YAAM,IAAI,MAAM,OAAO,CAAC;AACxB,UAAI,MAAM,MAAM;AACZ,cAAM,KAAK,MAAM,OAAO,EAAE,CAAC;AAC3B,kBAAU,uBAAuB,EAAE;AAAA,MACvC,OACK;AACD,kBAAU;AAAA,MACd;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AACA,EAAAA,gBAAe,gBAAgB;AAC/B,WAAS,uBAAuB,MAAM;AAClC,YAAQ,MAAI;AAAA,MACR,KAAK;AAAK,eAAO;AAAA,MACjB,KAAK;AAAK,eAAO;AAAA,MACjB,KAAK;AAAK,eAAO;AAAA,MACjB,KAAK;AAAK,eAAO;AAAA,MACjB,KAAK;AAAK,eAAO;AAAA,MACjB,KAAK;AAAK,eAAO;AAAA,MACjB,KAAK;AAAK,eAAO;AAAA,MACjB;AAAS,eAAO;AAAA,IAC5B;AAAA,EACI;AACA,WAAS,UAAU,OAAO;AACtB,QAAI,MAAM,OAAO,CAAC,MAAM,KAAK;AACzB,aAAO,MAAM,UAAU,CAAC;AAAA,IAC5B,OACK;AACD,aAAO;AAAA,IACX;AAAA,EACJ;AACA,EAAAA,gBAAe,YAAY;AAC3B,WAAS,WAAW,OAAO;AACvB,WAAO,SAAS,KAAK;AAAA,EACzB;AACA,EAAAA,gBAAe,aAAa;AAC5B,WAAS,cAAc,OAAO;AAC1B,WAAO,OAAO,KAAK;AAAA,EACvB;AACA,EAAAA,gBAAe,gBAAgB;AAC/B,WAAS,YAAY,OAAO;AACxB,WAAO,IAAI,KAAK,KAAK;AAAA,EACzB;AACA,EAAAA,gBAAe,cAAc;AAC7B,WAAS,cAAc,OAAO;AAC1B,WAAO,OAAO,KAAK;AAAA,EACvB;AACA,EAAAA,gBAAe,gBAAgB;AAC/B,WAAS,eAAe,OAAO;AAC3B,WAAO,MAAM,YAAW,MAAO;AAAA,EACnC;AACA,EAAAA,gBAAe,iBAAiB;AACpC,GAAG,mBAAmB,iBAAiB,CAAA,EAAG;","x_google_ignoreList":[0]}