qidian-vue-ui 1.1.50 → 1.1.51

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

@@ -0,0 +1,453 @@
+import { EmbeddedActionsParser } 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 "../../../../../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 { LLkLookaheadStrategy } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.mjs";
+import { defaultParserErrorProvider } from "../../../../../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 { LLStarLookaheadStrategy } from "../../../../../chevrotain-allstar@0.3.1_chevrotain@11.0.3/node_modules/chevrotain-allstar/lib/all-star-lookahead.mjs";
+import { isKeyword, isAssignment, isCrossReference } from "../languages/generated/ast.mjs";
+import { isDataTypeRule, getExplicitRuleType } from "../utils/grammar-utils.mjs";
+import { linkContentToContainer, assignMandatoryProperties, getContainerOfType } from "../utils/ast-utils.mjs";
+import { CstNodeBuilder } from "./cst-node-builder.mjs";
+const DatatypeSymbol = Symbol("Datatype");
+function isDataTypeNode(node) {
+  return node.$type === DatatypeSymbol;
+}
+const ruleSuffix = "​";
+const withRuleSuffix = (name) => name.endsWith(ruleSuffix) ? name : name + ruleSuffix;
+class AbstractLangiumParser {
+  constructor(services) {
+    this._unorderedGroups = /* @__PURE__ */ new Map();
+    this.allRules = /* @__PURE__ */ new Map();
+    this.lexer = services.parser.Lexer;
+    const tokens = this.lexer.definition;
+    const production = services.LanguageMetaData.mode === "production";
+    this.wrapper = new ChevrotainWrapper(tokens, Object.assign(Object.assign({}, services.parser.ParserConfig), { skipValidations: production, errorMessageProvider: services.parser.ParserErrorMessageProvider }));
+  }
+  alternatives(idx, choices) {
+    this.wrapper.wrapOr(idx, choices);
+  }
+  optional(idx, callback) {
+    this.wrapper.wrapOption(idx, callback);
+  }
+  many(idx, callback) {
+    this.wrapper.wrapMany(idx, callback);
+  }
+  atLeastOne(idx, callback) {
+    this.wrapper.wrapAtLeastOne(idx, callback);
+  }
+  getRule(name) {
+    return this.allRules.get(name);
+  }
+  isRecording() {
+    return this.wrapper.IS_RECORDING;
+  }
+  get unorderedGroups() {
+    return this._unorderedGroups;
+  }
+  getRuleStack() {
+    return this.wrapper.RULE_STACK;
+  }
+  finalize() {
+    this.wrapper.wrapSelfAnalysis();
+  }
+}
+class LangiumParser extends AbstractLangiumParser {
+  get current() {
+    return this.stack[this.stack.length - 1];
+  }
+  constructor(services) {
+    super(services);
+    this.nodeBuilder = new CstNodeBuilder();
+    this.stack = [];
+    this.assignmentMap = /* @__PURE__ */ new Map();
+    this.linker = services.references.Linker;
+    this.converter = services.parser.ValueConverter;
+    this.astReflection = services.shared.AstReflection;
+  }
+  rule(rule, impl) {
+    const type = this.computeRuleType(rule);
+    const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(type, impl).bind(this));
+    this.allRules.set(rule.name, ruleMethod);
+    if (rule.entry) {
+      this.mainRule = ruleMethod;
+    }
+    return ruleMethod;
+  }
+  computeRuleType(rule) {
+    if (rule.fragment) {
+      return void 0;
+    } else if (isDataTypeRule(rule)) {
+      return DatatypeSymbol;
+    } else {
+      const explicit = getExplicitRuleType(rule);
+      return explicit !== null && explicit !== void 0 ? explicit : rule.name;
+    }
+  }
+  parse(input, options = {}) {
+    this.nodeBuilder.buildRootNode(input);
+    const lexerResult = this.lexerResult = this.lexer.tokenize(input);
+    this.wrapper.input = lexerResult.tokens;
+    const ruleMethod = options.rule ? this.allRules.get(options.rule) : this.mainRule;
+    if (!ruleMethod) {
+      throw new Error(options.rule ? `No rule found with name '${options.rule}'` : "No main rule available.");
+    }
+    const result = ruleMethod.call(this.wrapper, {});
+    this.nodeBuilder.addHiddenNodes(lexerResult.hidden);
+    this.unorderedGroups.clear();
+    this.lexerResult = void 0;
+    return {
+      value: result,
+      lexerErrors: lexerResult.errors,
+      lexerReport: lexerResult.report,
+      parserErrors: this.wrapper.errors
+    };
+  }
+  startImplementation($type, implementation) {
+    return (args) => {
+      const createNode = !this.isRecording() && $type !== void 0;
+      if (createNode) {
+        const node = { $type };
+        this.stack.push(node);
+        if ($type === DatatypeSymbol) {
+          node.value = "";
+        }
+      }
+      let result;
+      try {
+        result = implementation(args);
+      } catch (err) {
+        result = void 0;
+      }
+      if (result === void 0 && createNode) {
+        result = this.construct();
+      }
+      return result;
+    };
+  }
+  extractHiddenTokens(token) {
+    const hiddenTokens = this.lexerResult.hidden;
+    if (!hiddenTokens.length) {
+      return [];
+    }
+    const offset = token.startOffset;
+    for (let i = 0; i < hiddenTokens.length; i++) {
+      const token2 = hiddenTokens[i];
+      if (token2.startOffset > offset) {
+        return hiddenTokens.splice(0, i);
+      }
+    }
+    return hiddenTokens.splice(0, hiddenTokens.length);
+  }
+  consume(idx, tokenType, feature) {
+    const token = this.wrapper.wrapConsume(idx, tokenType);
+    if (!this.isRecording() && this.isValidToken(token)) {
+      const hiddenTokens = this.extractHiddenTokens(token);
+      this.nodeBuilder.addHiddenNodes(hiddenTokens);
+      const leafNode = this.nodeBuilder.buildLeafNode(token, feature);
+      const { assignment, isCrossRef } = this.getAssignment(feature);
+      const current = this.current;
+      if (assignment) {
+        const convertedValue = isKeyword(feature) ? token.image : this.converter.convert(token.image, leafNode);
+        this.assign(assignment.operator, assignment.feature, convertedValue, leafNode, isCrossRef);
+      } else if (isDataTypeNode(current)) {
+        let text = token.image;
+        if (!isKeyword(feature)) {
+          text = this.converter.convert(text, leafNode).toString();
+        }
+        current.value += text;
+      }
+    }
+  }
+  /**
+   * Most consumed parser tokens are valid. However there are two cases in which they are not valid:
+   *
+   * 1. They were inserted during error recovery by the parser. These tokens don't really exist and should not be further processed
+   * 2. They contain invalid token ranges. This might include the special EOF token, or other tokens produced by invalid token builders.
+   */
+  isValidToken(token) {
+    return !token.isInsertedInRecovery && !isNaN(token.startOffset) && typeof token.endOffset === "number" && !isNaN(token.endOffset);
+  }
+  subrule(idx, rule, fragment, feature, args) {
+    let cstNode;
+    if (!this.isRecording() && !fragment) {
+      cstNode = this.nodeBuilder.buildCompositeNode(feature);
+    }
+    const subruleResult = this.wrapper.wrapSubrule(idx, rule, args);
+    if (!this.isRecording() && cstNode && cstNode.length > 0) {
+      this.performSubruleAssignment(subruleResult, feature, cstNode);
+    }
+  }
+  performSubruleAssignment(result, feature, cstNode) {
+    const { assignment, isCrossRef } = this.getAssignment(feature);
+    if (assignment) {
+      this.assign(assignment.operator, assignment.feature, result, cstNode, isCrossRef);
+    } else if (!assignment) {
+      const current = this.current;
+      if (isDataTypeNode(current)) {
+        current.value += result.toString();
+      } else if (typeof result === "object" && result) {
+        const object = this.assignWithoutOverride(result, current);
+        const newItem = object;
+        this.stack.pop();
+        this.stack.push(newItem);
+      }
+    }
+  }
+  action($type, action) {
+    if (!this.isRecording()) {
+      let last = this.current;
+      if (action.feature && action.operator) {
+        last = this.construct();
+        this.nodeBuilder.removeNode(last.$cstNode);
+        const node = this.nodeBuilder.buildCompositeNode(action);
+        node.content.push(last.$cstNode);
+        const newItem = { $type };
+        this.stack.push(newItem);
+        this.assign(action.operator, action.feature, last, last.$cstNode, false);
+      } else {
+        last.$type = $type;
+      }
+    }
+  }
+  construct() {
+    if (this.isRecording()) {
+      return void 0;
+    }
+    const obj = this.current;
+    linkContentToContainer(obj);
+    this.nodeBuilder.construct(obj);
+    this.stack.pop();
+    if (isDataTypeNode(obj)) {
+      return this.converter.convert(obj.value, obj.$cstNode);
+    } else {
+      assignMandatoryProperties(this.astReflection, obj);
+    }
+    return obj;
+  }
+  getAssignment(feature) {
+    if (!this.assignmentMap.has(feature)) {
+      const assignment = getContainerOfType(feature, isAssignment);
+      this.assignmentMap.set(feature, {
+        assignment,
+        isCrossRef: assignment ? isCrossReference(assignment.terminal) : false
+      });
+    }
+    return this.assignmentMap.get(feature);
+  }
+  assign(operator, feature, value, cstNode, isCrossRef) {
+    const obj = this.current;
+    let item;
+    if (isCrossRef && typeof value === "string") {
+      item = this.linker.buildReference(obj, feature, cstNode, value);
+    } else {
+      item = value;
+    }
+    switch (operator) {
+      case "=": {
+        obj[feature] = item;
+        break;
+      }
+      case "?=": {
+        obj[feature] = true;
+        break;
+      }
+      case "+=": {
+        if (!Array.isArray(obj[feature])) {
+          obj[feature] = [];
+        }
+        obj[feature].push(item);
+      }
+    }
+  }
+  assignWithoutOverride(target, source) {
+    for (const [name, existingValue] of Object.entries(source)) {
+      const newValue = target[name];
+      if (newValue === void 0) {
+        target[name] = existingValue;
+      } else if (Array.isArray(newValue) && Array.isArray(existingValue)) {
+        existingValue.push(...newValue);
+        target[name] = existingValue;
+      }
+    }
+    const targetCstNode = target.$cstNode;
+    if (targetCstNode) {
+      targetCstNode.astNode = void 0;
+      target.$cstNode = void 0;
+    }
+    return target;
+  }
+  get definitionErrors() {
+    return this.wrapper.definitionErrors;
+  }
+}
+class AbstractParserErrorMessageProvider {
+  buildMismatchTokenMessage(options) {
+    return defaultParserErrorProvider.buildMismatchTokenMessage(options);
+  }
+  buildNotAllInputParsedMessage(options) {
+    return defaultParserErrorProvider.buildNotAllInputParsedMessage(options);
+  }
+  buildNoViableAltMessage(options) {
+    return defaultParserErrorProvider.buildNoViableAltMessage(options);
+  }
+  buildEarlyExitMessage(options) {
+    return defaultParserErrorProvider.buildEarlyExitMessage(options);
+  }
+}
+class LangiumParserErrorMessageProvider extends AbstractParserErrorMessageProvider {
+  buildMismatchTokenMessage({ expected, actual }) {
+    const expectedMsg = expected.LABEL ? "`" + expected.LABEL + "`" : expected.name.endsWith(":KW") ? `keyword '${expected.name.substring(0, expected.name.length - 3)}'` : `token of type '${expected.name}'`;
+    return `Expecting ${expectedMsg} but found \`${actual.image}\`.`;
+  }
+  buildNotAllInputParsedMessage({ firstRedundant }) {
+    return `Expecting end of file but found \`${firstRedundant.image}\`.`;
+  }
+}
+class LangiumCompletionParser extends AbstractLangiumParser {
+  constructor() {
+    super(...arguments);
+    this.tokens = [];
+    this.elementStack = [];
+    this.lastElementStack = [];
+    this.nextTokenIndex = 0;
+    this.stackSize = 0;
+  }
+  action() {
+  }
+  construct() {
+    return void 0;
+  }
+  parse(input) {
+    this.resetState();
+    const tokens = this.lexer.tokenize(input, { mode: "partial" });
+    this.tokens = tokens.tokens;
+    this.wrapper.input = [...this.tokens];
+    this.mainRule.call(this.wrapper, {});
+    this.unorderedGroups.clear();
+    return {
+      tokens: this.tokens,
+      elementStack: [...this.lastElementStack],
+      tokenIndex: this.nextTokenIndex
+    };
+  }
+  rule(rule, impl) {
+    const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(impl).bind(this));
+    this.allRules.set(rule.name, ruleMethod);
+    if (rule.entry) {
+      this.mainRule = ruleMethod;
+    }
+    return ruleMethod;
+  }
+  resetState() {
+    this.elementStack = [];
+    this.lastElementStack = [];
+    this.nextTokenIndex = 0;
+    this.stackSize = 0;
+  }
+  startImplementation(implementation) {
+    return (args) => {
+      const size = this.keepStackSize();
+      try {
+        implementation(args);
+      } finally {
+        this.resetStackSize(size);
+      }
+    };
+  }
+  removeUnexpectedElements() {
+    this.elementStack.splice(this.stackSize);
+  }
+  keepStackSize() {
+    const size = this.elementStack.length;
+    this.stackSize = size;
+    return size;
+  }
+  resetStackSize(size) {
+    this.removeUnexpectedElements();
+    this.stackSize = size;
+  }
+  consume(idx, tokenType, feature) {
+    this.wrapper.wrapConsume(idx, tokenType);
+    if (!this.isRecording()) {
+      this.lastElementStack = [...this.elementStack, feature];
+      this.nextTokenIndex = this.currIdx + 1;
+    }
+  }
+  subrule(idx, rule, fragment, feature, args) {
+    this.before(feature);
+    this.wrapper.wrapSubrule(idx, rule, args);
+    this.after(feature);
+  }
+  before(element) {
+    if (!this.isRecording()) {
+      this.elementStack.push(element);
+    }
+  }
+  after(element) {
+    if (!this.isRecording()) {
+      const index = this.elementStack.lastIndexOf(element);
+      if (index >= 0) {
+        this.elementStack.splice(index);
+      }
+    }
+  }
+  get currIdx() {
+    return this.wrapper.currIdx;
+  }
+}
+const defaultConfig = {
+  recoveryEnabled: true,
+  nodeLocationTracking: "full",
+  skipValidations: true,
+  errorMessageProvider: new LangiumParserErrorMessageProvider()
+};
+class ChevrotainWrapper extends EmbeddedActionsParser {
+  constructor(tokens, config) {
+    const useDefaultLookahead = config && "maxLookahead" in config;
+    super(tokens, Object.assign(Object.assign(Object.assign({}, defaultConfig), { lookaheadStrategy: useDefaultLookahead ? new LLkLookaheadStrategy({ maxLookahead: config.maxLookahead }) : new LLStarLookaheadStrategy({
+      // If validations are skipped, don't log the lookahead warnings
+      logging: config.skipValidations ? () => {
+      } : void 0
+    }) }), config));
+  }
+  get IS_RECORDING() {
+    return this.RECORDING_PHASE;
+  }
+  DEFINE_RULE(name, impl) {
+    return this.RULE(name, impl);
+  }
+  wrapSelfAnalysis() {
+    this.performSelfAnalysis();
+  }
+  wrapConsume(idx, tokenType) {
+    return this.consume(idx, tokenType);
+  }
+  wrapSubrule(idx, rule, args) {
+    return this.subrule(idx, rule, {
+      ARGS: [args]
+    });
+  }
+  wrapOr(idx, choices) {
+    this.or(idx, choices);
+  }
+  wrapOption(idx, callback) {
+    this.option(idx, callback);
+  }
+  wrapMany(idx, callback) {
+    this.many(idx, callback);
+  }
+  wrapAtLeastOne(idx, callback) {
+    this.atLeastOne(idx, callback);
+  }
+}
+export {
+  AbstractLangiumParser,
+  AbstractParserErrorMessageProvider,
+  DatatypeSymbol,
+  LangiumCompletionParser,
+  LangiumParser,
+  LangiumParserErrorMessageProvider
+};
+//# sourceMappingURL=langium-parser.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"langium-parser.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/langium-parser.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 { defaultParserErrorProvider, EmbeddedActionsParser, LLkLookaheadStrategy } from 'chevrotain';\nimport { LLStarLookaheadStrategy } from 'chevrotain-allstar';\nimport { isAssignment, isCrossReference, isKeyword } from '../languages/generated/ast.js';\nimport { getExplicitRuleType, isDataTypeRule } from '../utils/grammar-utils.js';\nimport { assignMandatoryProperties, getContainerOfType, linkContentToContainer } from '../utils/ast-utils.js';\nimport { CstNodeBuilder } from './cst-node-builder.js';\nexport const DatatypeSymbol = Symbol('Datatype');\nfunction isDataTypeNode(node) {\n    return node.$type === DatatypeSymbol;\n}\nconst ruleSuffix = '\\u200B';\nconst withRuleSuffix = (name) => name.endsWith(ruleSuffix) ? name : name + ruleSuffix;\nexport class AbstractLangiumParser {\n    constructor(services) {\n        this._unorderedGroups = new Map();\n        this.allRules = new Map();\n        this.lexer = services.parser.Lexer;\n        const tokens = this.lexer.definition;\n        const production = services.LanguageMetaData.mode === 'production';\n        this.wrapper = new ChevrotainWrapper(tokens, Object.assign(Object.assign({}, services.parser.ParserConfig), { skipValidations: production, errorMessageProvider: services.parser.ParserErrorMessageProvider }));\n    }\n    alternatives(idx, choices) {\n        this.wrapper.wrapOr(idx, choices);\n    }\n    optional(idx, callback) {\n        this.wrapper.wrapOption(idx, callback);\n    }\n    many(idx, callback) {\n        this.wrapper.wrapMany(idx, callback);\n    }\n    atLeastOne(idx, callback) {\n        this.wrapper.wrapAtLeastOne(idx, callback);\n    }\n    getRule(name) {\n        return this.allRules.get(name);\n    }\n    isRecording() {\n        return this.wrapper.IS_RECORDING;\n    }\n    get unorderedGroups() {\n        return this._unorderedGroups;\n    }\n    getRuleStack() {\n        return this.wrapper.RULE_STACK;\n    }\n    finalize() {\n        this.wrapper.wrapSelfAnalysis();\n    }\n}\nexport class LangiumParser extends AbstractLangiumParser {\n    get current() {\n        return this.stack[this.stack.length - 1];\n    }\n    constructor(services) {\n        super(services);\n        this.nodeBuilder = new CstNodeBuilder();\n        this.stack = [];\n        this.assignmentMap = new Map();\n        this.linker = services.references.Linker;\n        this.converter = services.parser.ValueConverter;\n        this.astReflection = services.shared.AstReflection;\n    }\n    rule(rule, impl) {\n        const type = this.computeRuleType(rule);\n        const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(type, impl).bind(this));\n        this.allRules.set(rule.name, ruleMethod);\n        if (rule.entry) {\n            this.mainRule = ruleMethod;\n        }\n        return ruleMethod;\n    }\n    computeRuleType(rule) {\n        if (rule.fragment) {\n            return undefined;\n        }\n        else if (isDataTypeRule(rule)) {\n            return DatatypeSymbol;\n        }\n        else {\n            const explicit = getExplicitRuleType(rule);\n            return explicit !== null && explicit !== void 0 ? explicit : rule.name;\n        }\n    }\n    parse(input, options = {}) {\n        this.nodeBuilder.buildRootNode(input);\n        const lexerResult = this.lexerResult = this.lexer.tokenize(input);\n        this.wrapper.input = lexerResult.tokens;\n        const ruleMethod = options.rule ? this.allRules.get(options.rule) : this.mainRule;\n        if (!ruleMethod) {\n            throw new Error(options.rule ? `No rule found with name '${options.rule}'` : 'No main rule available.');\n        }\n        const result = ruleMethod.call(this.wrapper, {});\n        this.nodeBuilder.addHiddenNodes(lexerResult.hidden);\n        this.unorderedGroups.clear();\n        this.lexerResult = undefined;\n        return {\n            value: result,\n            lexerErrors: lexerResult.errors,\n            lexerReport: lexerResult.report,\n            parserErrors: this.wrapper.errors\n        };\n    }\n    startImplementation($type, implementation) {\n        return (args) => {\n            // Only create a new AST node in case the calling rule is not a fragment rule\n            const createNode = !this.isRecording() && $type !== undefined;\n            if (createNode) {\n                const node = { $type };\n                this.stack.push(node);\n                if ($type === DatatypeSymbol) {\n                    node.value = '';\n                }\n            }\n            let result;\n            try {\n                result = implementation(args);\n            }\n            catch (err) {\n                result = undefined;\n            }\n            if (result === undefined && createNode) {\n                result = this.construct();\n            }\n            return result;\n        };\n    }\n    extractHiddenTokens(token) {\n        const hiddenTokens = this.lexerResult.hidden;\n        if (!hiddenTokens.length) {\n            return [];\n        }\n        const offset = token.startOffset;\n        for (let i = 0; i < hiddenTokens.length; i++) {\n            const token = hiddenTokens[i];\n            if (token.startOffset > offset) {\n                return hiddenTokens.splice(0, i);\n            }\n        }\n        return hiddenTokens.splice(0, hiddenTokens.length);\n    }\n    consume(idx, tokenType, feature) {\n        const token = this.wrapper.wrapConsume(idx, tokenType);\n        if (!this.isRecording() && this.isValidToken(token)) {\n            const hiddenTokens = this.extractHiddenTokens(token);\n            this.nodeBuilder.addHiddenNodes(hiddenTokens);\n            const leafNode = this.nodeBuilder.buildLeafNode(token, feature);\n            const { assignment, isCrossRef } = this.getAssignment(feature);\n            const current = this.current;\n            if (assignment) {\n                const convertedValue = isKeyword(feature) ? token.image : this.converter.convert(token.image, leafNode);\n                this.assign(assignment.operator, assignment.feature, convertedValue, leafNode, isCrossRef);\n            }\n            else if (isDataTypeNode(current)) {\n                let text = token.image;\n                if (!isKeyword(feature)) {\n                    text = this.converter.convert(text, leafNode).toString();\n                }\n                current.value += text;\n            }\n        }\n    }\n    /**\n     * Most consumed parser tokens are valid. However there are two cases in which they are not valid:\n     *\n     * 1. They were inserted during error recovery by the parser. These tokens don't really exist and should not be further processed\n     * 2. They contain invalid token ranges. This might include the special EOF token, or other tokens produced by invalid token builders.\n     */\n    isValidToken(token) {\n        return !token.isInsertedInRecovery && !isNaN(token.startOffset) && typeof token.endOffset === 'number' && !isNaN(token.endOffset);\n    }\n    subrule(idx, rule, fragment, feature, args) {\n        let cstNode;\n        if (!this.isRecording() && !fragment) {\n            // We only want to create a new CST node if the subrule actually creates a new AST node.\n            // In other cases like calls of fragment rules the current CST/AST is populated further.\n            // Note that skipping this initialization and leaving cstNode unassigned also skips the subrule assignment later on.\n            // This is intended, as fragment rules only enrich the current AST node\n            cstNode = this.nodeBuilder.buildCompositeNode(feature);\n        }\n        const subruleResult = this.wrapper.wrapSubrule(idx, rule, args);\n        if (!this.isRecording() && cstNode && cstNode.length > 0) {\n            this.performSubruleAssignment(subruleResult, feature, cstNode);\n        }\n    }\n    performSubruleAssignment(result, feature, cstNode) {\n        const { assignment, isCrossRef } = this.getAssignment(feature);\n        if (assignment) {\n            this.assign(assignment.operator, assignment.feature, result, cstNode, isCrossRef);\n        }\n        else if (!assignment) {\n            // If we call a subrule without an assignment we either:\n            // 1. append the result of the subrule (data type rule)\n            // 2. override the current object with the newly parsed object\n            // If the current element is an AST node and the result of the subrule\n            // is a data type rule, we can safely discard the results.\n            const current = this.current;\n            if (isDataTypeNode(current)) {\n                current.value += result.toString();\n            }\n            else if (typeof result === 'object' && result) {\n                const object = this.assignWithoutOverride(result, current);\n                const newItem = object;\n                this.stack.pop();\n                this.stack.push(newItem);\n            }\n        }\n    }\n    action($type, action) {\n        if (!this.isRecording()) {\n            let last = this.current;\n            if (action.feature && action.operator) {\n                last = this.construct();\n                this.nodeBuilder.removeNode(last.$cstNode);\n                const node = this.nodeBuilder.buildCompositeNode(action);\n                node.content.push(last.$cstNode);\n                const newItem = { $type };\n                this.stack.push(newItem);\n                this.assign(action.operator, action.feature, last, last.$cstNode, false);\n            }\n            else {\n                last.$type = $type;\n            }\n        }\n    }\n    construct() {\n        if (this.isRecording()) {\n            return undefined;\n        }\n        const obj = this.current;\n        linkContentToContainer(obj);\n        this.nodeBuilder.construct(obj);\n        this.stack.pop();\n        if (isDataTypeNode(obj)) {\n            return this.converter.convert(obj.value, obj.$cstNode);\n        }\n        else {\n            assignMandatoryProperties(this.astReflection, obj);\n        }\n        return obj;\n    }\n    getAssignment(feature) {\n        if (!this.assignmentMap.has(feature)) {\n            const assignment = getContainerOfType(feature, isAssignment);\n            this.assignmentMap.set(feature, {\n                assignment: assignment,\n                isCrossRef: assignment ? isCrossReference(assignment.terminal) : false\n            });\n        }\n        return this.assignmentMap.get(feature);\n    }\n    assign(operator, feature, value, cstNode, isCrossRef) {\n        const obj = this.current;\n        let item;\n        if (isCrossRef && typeof value === 'string') {\n            item = this.linker.buildReference(obj, feature, cstNode, value);\n        }\n        else {\n            item = value;\n        }\n        switch (operator) {\n            case '=': {\n                obj[feature] = item;\n                break;\n            }\n            case '?=': {\n                obj[feature] = true;\n                break;\n            }\n            case '+=': {\n                if (!Array.isArray(obj[feature])) {\n                    obj[feature] = [];\n                }\n                obj[feature].push(item);\n            }\n        }\n    }\n    assignWithoutOverride(target, source) {\n        for (const [name, existingValue] of Object.entries(source)) {\n            const newValue = target[name];\n            if (newValue === undefined) {\n                target[name] = existingValue;\n            }\n            else if (Array.isArray(newValue) && Array.isArray(existingValue)) {\n                existingValue.push(...newValue);\n                target[name] = existingValue;\n            }\n        }\n        // The target was parsed from a unassigned subrule\n        // After the subrule construction, it received a cst node\n        // This CST node will later be overriden by the cst node builder\n        // To prevent references to stale AST nodes in the CST,\n        // we need to remove the reference here\n        const targetCstNode = target.$cstNode;\n        if (targetCstNode) {\n            targetCstNode.astNode = undefined;\n            target.$cstNode = undefined;\n        }\n        return target;\n    }\n    get definitionErrors() {\n        return this.wrapper.definitionErrors;\n    }\n}\nexport class AbstractParserErrorMessageProvider {\n    buildMismatchTokenMessage(options) {\n        return defaultParserErrorProvider.buildMismatchTokenMessage(options);\n    }\n    buildNotAllInputParsedMessage(options) {\n        return defaultParserErrorProvider.buildNotAllInputParsedMessage(options);\n    }\n    buildNoViableAltMessage(options) {\n        return defaultParserErrorProvider.buildNoViableAltMessage(options);\n    }\n    buildEarlyExitMessage(options) {\n        return defaultParserErrorProvider.buildEarlyExitMessage(options);\n    }\n}\nexport class LangiumParserErrorMessageProvider extends AbstractParserErrorMessageProvider {\n    buildMismatchTokenMessage({ expected, actual }) {\n        const expectedMsg = expected.LABEL\n            ? '`' + expected.LABEL + '`'\n            : expected.name.endsWith(':KW')\n                ? `keyword '${expected.name.substring(0, expected.name.length - 3)}'`\n                : `token of type '${expected.name}'`;\n        return `Expecting ${expectedMsg} but found \\`${actual.image}\\`.`;\n    }\n    buildNotAllInputParsedMessage({ firstRedundant }) {\n        return `Expecting end of file but found \\`${firstRedundant.image}\\`.`;\n    }\n}\nexport class LangiumCompletionParser extends AbstractLangiumParser {\n    constructor() {\n        super(...arguments);\n        this.tokens = [];\n        this.elementStack = [];\n        this.lastElementStack = [];\n        this.nextTokenIndex = 0;\n        this.stackSize = 0;\n    }\n    action() {\n        // NOOP\n    }\n    construct() {\n        // NOOP\n        return undefined;\n    }\n    parse(input) {\n        this.resetState();\n        const tokens = this.lexer.tokenize(input, { mode: 'partial' });\n        this.tokens = tokens.tokens;\n        this.wrapper.input = [...this.tokens];\n        this.mainRule.call(this.wrapper, {});\n        this.unorderedGroups.clear();\n        return {\n            tokens: this.tokens,\n            elementStack: [...this.lastElementStack],\n            tokenIndex: this.nextTokenIndex\n        };\n    }\n    rule(rule, impl) {\n        const ruleMethod = this.wrapper.DEFINE_RULE(withRuleSuffix(rule.name), this.startImplementation(impl).bind(this));\n        this.allRules.set(rule.name, ruleMethod);\n        if (rule.entry) {\n            this.mainRule = ruleMethod;\n        }\n        return ruleMethod;\n    }\n    resetState() {\n        this.elementStack = [];\n        this.lastElementStack = [];\n        this.nextTokenIndex = 0;\n        this.stackSize = 0;\n    }\n    startImplementation(implementation) {\n        return (args) => {\n            const size = this.keepStackSize();\n            try {\n                implementation(args);\n            }\n            finally {\n                this.resetStackSize(size);\n            }\n        };\n    }\n    removeUnexpectedElements() {\n        this.elementStack.splice(this.stackSize);\n    }\n    keepStackSize() {\n        const size = this.elementStack.length;\n        this.stackSize = size;\n        return size;\n    }\n    resetStackSize(size) {\n        this.removeUnexpectedElements();\n        this.stackSize = size;\n    }\n    consume(idx, tokenType, feature) {\n        this.wrapper.wrapConsume(idx, tokenType);\n        if (!this.isRecording()) {\n            this.lastElementStack = [...this.elementStack, feature];\n            this.nextTokenIndex = this.currIdx + 1;\n        }\n    }\n    subrule(idx, rule, fragment, feature, args) {\n        this.before(feature);\n        this.wrapper.wrapSubrule(idx, rule, args);\n        this.after(feature);\n    }\n    before(element) {\n        if (!this.isRecording()) {\n            this.elementStack.push(element);\n        }\n    }\n    after(element) {\n        if (!this.isRecording()) {\n            const index = this.elementStack.lastIndexOf(element);\n            if (index >= 0) {\n                this.elementStack.splice(index);\n            }\n        }\n    }\n    get currIdx() {\n        return this.wrapper.currIdx;\n    }\n}\nconst defaultConfig = {\n    recoveryEnabled: true,\n    nodeLocationTracking: 'full',\n    skipValidations: true,\n    errorMessageProvider: new LangiumParserErrorMessageProvider()\n};\n/**\n * This class wraps the embedded actions parser of chevrotain and exposes protected methods.\n * This way, we can build the `LangiumParser` as a composition.\n */\nclass ChevrotainWrapper extends EmbeddedActionsParser {\n    constructor(tokens, config) {\n        const useDefaultLookahead = config && 'maxLookahead' in config;\n        super(tokens, Object.assign(Object.assign(Object.assign({}, defaultConfig), { lookaheadStrategy: useDefaultLookahead\n                ? new LLkLookaheadStrategy({ maxLookahead: config.maxLookahead })\n                : new LLStarLookaheadStrategy({\n                    // If validations are skipped, don't log the lookahead warnings\n                    logging: config.skipValidations ? () => { } : undefined\n                }) }), config));\n    }\n    get IS_RECORDING() {\n        return this.RECORDING_PHASE;\n    }\n    DEFINE_RULE(name, impl) {\n        return this.RULE(name, impl);\n    }\n    wrapSelfAnalysis() {\n        this.performSelfAnalysis();\n    }\n    wrapConsume(idx, tokenType) {\n        return this.consume(idx, tokenType);\n    }\n    wrapSubrule(idx, rule, args) {\n        return this.subrule(idx, rule, {\n            ARGS: [args]\n        });\n    }\n    wrapOr(idx, choices) {\n        this.or(idx, choices);\n    }\n    wrapOption(idx, callback) {\n        this.option(idx, callback);\n    }\n    wrapMany(idx, callback) {\n        this.many(idx, callback);\n    }\n    wrapAtLeastOne(idx, callback) {\n        this.atLeastOne(idx, callback);\n    }\n}\n//# sourceMappingURL=langium-parser.js.map"],"names":["token"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/lexer.mjs

@@ -0,0 +1,72 @@
+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 { defaultLexerErrorProvider } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_errors_public.mjs";
+class DefaultLexerErrorMessageProvider {
+  buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {
+    return defaultLexerErrorProvider.buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column);
+  }
+  buildUnableToPopLexerModeMessage(token) {
+    return defaultLexerErrorProvider.buildUnableToPopLexerModeMessage(token);
+  }
+}
+const DEFAULT_TOKENIZE_OPTIONS = { mode: "full" };
+class DefaultLexer {
+  constructor(services) {
+    this.errorMessageProvider = services.parser.LexerErrorMessageProvider;
+    this.tokenBuilder = services.parser.TokenBuilder;
+    const tokens = this.tokenBuilder.buildTokens(services.Grammar, {
+      caseInsensitive: services.LanguageMetaData.caseInsensitive
+    });
+    this.tokenTypes = this.toTokenTypeDictionary(tokens);
+    const lexerTokens = isTokenTypeDictionary(tokens) ? Object.values(tokens) : tokens;
+    const production = services.LanguageMetaData.mode === "production";
+    this.chevrotainLexer = new Lexer(lexerTokens, {
+      positionTracking: "full",
+      skipValidations: production,
+      errorMessageProvider: this.errorMessageProvider
+    });
+  }
+  get definition() {
+    return this.tokenTypes;
+  }
+  tokenize(text, _options = DEFAULT_TOKENIZE_OPTIONS) {
+    var _a, _b, _c;
+    const chevrotainResult = this.chevrotainLexer.tokenize(text);
+    return {
+      tokens: chevrotainResult.tokens,
+      errors: chevrotainResult.errors,
+      hidden: (_a = chevrotainResult.groups.hidden) !== null && _a !== void 0 ? _a : [],
+      report: (_c = (_b = this.tokenBuilder).flushLexingReport) === null || _c === void 0 ? void 0 : _c.call(_b, text)
+    };
+  }
+  toTokenTypeDictionary(buildTokens) {
+    if (isTokenTypeDictionary(buildTokens))
+      return buildTokens;
+    const tokens = isIMultiModeLexerDefinition(buildTokens) ? Object.values(buildTokens.modes).flat() : buildTokens;
+    const res = {};
+    tokens.forEach((token) => res[token.name] = token);
+    return res;
+  }
+}
+function isTokenTypeArray(tokenVocabulary) {
+  return Array.isArray(tokenVocabulary) && (tokenVocabulary.length === 0 || "name" in tokenVocabulary[0]);
+}
+function isIMultiModeLexerDefinition(tokenVocabulary) {
+  return tokenVocabulary && "modes" in tokenVocabulary && "defaultMode" in tokenVocabulary;
+}
+function isTokenTypeDictionary(tokenVocabulary) {
+  return !isTokenTypeArray(tokenVocabulary) && !isIMultiModeLexerDefinition(tokenVocabulary);
+}
+export {
+  DEFAULT_TOKENIZE_OPTIONS,
+  DefaultLexer,
+  DefaultLexerErrorMessageProvider,
+  isIMultiModeLexerDefinition,
+  isTokenTypeArray,
+  isTokenTypeDictionary
+};
+//# sourceMappingURL=lexer.mjs.map

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/lexer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexer.mjs","sources":["../../../../../../../../../../node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/lexer.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 { Lexer as ChevrotainLexer, defaultLexerErrorProvider } from 'chevrotain';\nexport class DefaultLexerErrorMessageProvider {\n    buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column) {\n        return defaultLexerErrorProvider.buildUnexpectedCharactersMessage(fullText, startOffset, length, line, column);\n    }\n    buildUnableToPopLexerModeMessage(token) {\n        return defaultLexerErrorProvider.buildUnableToPopLexerModeMessage(token);\n    }\n}\nexport const DEFAULT_TOKENIZE_OPTIONS = { mode: 'full' };\nexport class DefaultLexer {\n    constructor(services) {\n        this.errorMessageProvider = services.parser.LexerErrorMessageProvider;\n        this.tokenBuilder = services.parser.TokenBuilder;\n        const tokens = this.tokenBuilder.buildTokens(services.Grammar, {\n            caseInsensitive: services.LanguageMetaData.caseInsensitive\n        });\n        this.tokenTypes = this.toTokenTypeDictionary(tokens);\n        const lexerTokens = isTokenTypeDictionary(tokens) ? Object.values(tokens) : tokens;\n        const production = services.LanguageMetaData.mode === 'production';\n        this.chevrotainLexer = new ChevrotainLexer(lexerTokens, {\n            positionTracking: 'full',\n            skipValidations: production,\n            errorMessageProvider: this.errorMessageProvider\n        });\n    }\n    get definition() {\n        return this.tokenTypes;\n    }\n    tokenize(text, _options = DEFAULT_TOKENIZE_OPTIONS) {\n        var _a, _b, _c;\n        const chevrotainResult = this.chevrotainLexer.tokenize(text);\n        return {\n            tokens: chevrotainResult.tokens,\n            errors: chevrotainResult.errors,\n            hidden: (_a = chevrotainResult.groups.hidden) !== null && _a !== void 0 ? _a : [],\n            report: (_c = (_b = this.tokenBuilder).flushLexingReport) === null || _c === void 0 ? void 0 : _c.call(_b, text)\n        };\n    }\n    toTokenTypeDictionary(buildTokens) {\n        if (isTokenTypeDictionary(buildTokens))\n            return buildTokens;\n        const tokens = isIMultiModeLexerDefinition(buildTokens) ? Object.values(buildTokens.modes).flat() : buildTokens;\n        const res = {};\n        tokens.forEach(token => res[token.name] = token);\n        return res;\n    }\n}\n/**\n * Returns a check whether the given TokenVocabulary is TokenType array\n */\nexport function isTokenTypeArray(tokenVocabulary) {\n    return Array.isArray(tokenVocabulary) && (tokenVocabulary.length === 0 || 'name' in tokenVocabulary[0]);\n}\n/**\n * Returns a check whether the given TokenVocabulary is IMultiModeLexerDefinition\n */\nexport function isIMultiModeLexerDefinition(tokenVocabulary) {\n    return tokenVocabulary && 'modes' in tokenVocabulary && 'defaultMode' in tokenVocabulary;\n}\n/**\n * Returns a check whether the given TokenVocabulary is TokenTypeDictionary\n */\nexport function isTokenTypeDictionary(tokenVocabulary) {\n    return !isTokenTypeArray(tokenVocabulary) && !isIMultiModeLexerDefinition(tokenVocabulary);\n}\n//# sourceMappingURL=lexer.js.map"],"names":["ChevrotainLexer"],"mappings":";;;;;;;AAMO,MAAM,iCAAiC;AAAA,EAC1C,iCAAiC,UAAU,aAAa,QAAQ,MAAM,QAAQ;AAC1E,WAAO,0BAA0B,iCAAiC,UAAU,aAAa,QAAQ,MAAM,MAAM;AAAA,EACjH;AAAA,EACA,iCAAiC,OAAO;AACpC,WAAO,0BAA0B,iCAAiC,KAAK;AAAA,EAC3E;AACJ;AACY,MAAC,2BAA2B,EAAE,MAAM,OAAM;AAC/C,MAAM,aAAa;AAAA,EACtB,YAAY,UAAU;AAClB,SAAK,uBAAuB,SAAS,OAAO;AAC5C,SAAK,eAAe,SAAS,OAAO;AACpC,UAAM,SAAS,KAAK,aAAa,YAAY,SAAS,SAAS;AAAA,MAC3D,iBAAiB,SAAS,iBAAiB;AAAA,IACvD,CAAS;AACD,SAAK,aAAa,KAAK,sBAAsB,MAAM;AACnD,UAAM,cAAc,sBAAsB,MAAM,IAAI,OAAO,OAAO,MAAM,IAAI;AAC5E,UAAM,aAAa,SAAS,iBAAiB,SAAS;AACtD,SAAK,kBAAkB,IAAIA,MAAgB,aAAa;AAAA,MACpD,kBAAkB;AAAA,MAClB,iBAAiB;AAAA,MACjB,sBAAsB,KAAK;AAAA,IACvC,CAAS;AAAA,EACL;AAAA,EACA,IAAI,aAAa;AACb,WAAO,KAAK;AAAA,EAChB;AAAA,EACA,SAAS,MAAM,WAAW,0BAA0B;AAChD,QAAI,IAAI,IAAI;AACZ,UAAM,mBAAmB,KAAK,gBAAgB,SAAS,IAAI;AAC3D,WAAO;AAAA,MACH,QAAQ,iBAAiB;AAAA,MACzB,QAAQ,iBAAiB;AAAA,MACzB,SAAS,KAAK,iBAAiB,OAAO,YAAY,QAAQ,OAAO,SAAS,KAAK,CAAA;AAAA,MAC/E,SAAS,MAAM,KAAK,KAAK,cAAc,uBAAuB,QAAQ,OAAO,SAAS,SAAS,GAAG,KAAK,IAAI,IAAI;AAAA,IAC3H;AAAA,EACI;AAAA,EACA,sBAAsB,aAAa;AAC/B,QAAI,sBAAsB,WAAW;AACjC,aAAO;AACX,UAAM,SAAS,4BAA4B,WAAW,IAAI,OAAO,OAAO,YAAY,KAAK,EAAE,KAAI,IAAK;AACpG,UAAM,MAAM,CAAA;AACZ,WAAO,QAAQ,WAAS,IAAI,MAAM,IAAI,IAAI,KAAK;AAC/C,WAAO;AAAA,EACX;AACJ;AAIO,SAAS,iBAAiB,iBAAiB;AAC9C,SAAO,MAAM,QAAQ,eAAe,MAAM,gBAAgB,WAAW,KAAK,UAAU,gBAAgB,CAAC;AACzG;AAIO,SAAS,4BAA4B,iBAAiB;AACzD,SAAO,mBAAmB,WAAW,mBAAmB,iBAAiB;AAC7E;AAIO,SAAS,sBAAsB,iBAAiB;AACnD,SAAO,CAAC,iBAAiB,eAAe,KAAK,CAAC,4BAA4B,eAAe;AAC7F;","x_google_ignoreList":[0]}