@elmethis/core 1.0.0-alpha.146 → 1.0.0-alpha.148

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/follow.mjs

@@ -0,0 +1,41 @@
+import { RestWalker } from "./rest.mjs";
+import { first } from "./first.mjs";
+import { forEach, assign } from "lodash-es";
+import { IN } from "../constants.mjs";
+import { Alternative } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
+class ResyncFollowsWalker extends RestWalker {
+  constructor(topProd) {
+    super();
+    this.topProd = topProd;
+    this.follows = {};
+  }
+  startWalking() {
+    this.walk(this.topProd);
+    return this.follows;
+  }
+  walkTerminal(terminal, currRest, prevRest) {
+  }
+  walkProdRef(refProd, currRest, prevRest) {
+    const followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.idx) + this.topProd.name;
+    const fullRest = currRest.concat(prevRest);
+    const restProd = new Alternative({ definition: fullRest });
+    const t_in_topProd_follows = first(restProd);
+    this.follows[followName] = t_in_topProd_follows;
+  }
+}
+function computeAllProdsFollows(topProductions) {
+  const reSyncFollows = {};
+  forEach(topProductions, (topProd) => {
+    const currRefsFollow = new ResyncFollowsWalker(topProd).startWalking();
+    assign(reSyncFollows, currRefsFollow);
+  });
+  return reSyncFollows;
+}
+function buildBetweenProdsFollowPrefix(inner, occurenceInParent) {
+  return inner.name + occurenceInParent + IN;
+}
+export {
+  ResyncFollowsWalker,
+  buildBetweenProdsFollowPrefix,
+  computeAllProdsFollows
+};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/gast/gast_resolver_public.mjs

@@ -0,0 +1,24 @@
+import { defaults, forEach } from "lodash-es";
+import { resolveGrammar as resolveGrammar$1 } from "../resolver.mjs";
+import { validateGrammar as validateGrammar$1 } from "../checks.mjs";
+import { defaultGrammarResolverErrorProvider, defaultGrammarValidatorErrorProvider } from "../../errors_public.mjs";
+function resolveGrammar(options) {
+  const actualOptions = defaults(options, {
+    errMsgProvider: defaultGrammarResolverErrorProvider
+  });
+  const topRulesTable = {};
+  forEach(options.rules, (rule) => {
+    topRulesTable[rule.name] = rule;
+  });
+  return resolveGrammar$1(topRulesTable, actualOptions.errMsgProvider);
+}
+function validateGrammar(options) {
+  options = defaults(options, {
+    errMsgProvider: defaultGrammarValidatorErrorProvider
+  });
+  return validateGrammar$1(options.rules, options.tokenTypes, options.errMsgProvider, options.grammarName);
+}
+export {
+  resolveGrammar,
+  validateGrammar
+};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/interpreter.mjs

@@ -0,0 +1,424 @@
+import { isEmpty, dropRight, drop, clone, forEach, last, first } from "lodash-es";
+import { first as first$1 } from "./first.mjs";
+import { RestWalker } from "./rest.mjs";
+import { Terminal, NonTerminal, Option, RepetitionMandatory, Repetition, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Alternation, Alternative, Rule } from "../../../../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
+class AbstractNextPossibleTokensWalker extends RestWalker {
+  constructor(topProd, path) {
+    super();
+    this.topProd = topProd;
+    this.path = path;
+    this.possibleTokTypes = [];
+    this.nextProductionName = "";
+    this.nextProductionOccurrence = 0;
+    this.found = false;
+    this.isAtEndOfPath = false;
+  }
+  startWalking() {
+    this.found = false;
+    if (this.path.ruleStack[0] !== this.topProd.name) {
+      throw Error("The path does not start with the walker's top Rule!");
+    }
+    this.ruleStack = clone(this.path.ruleStack).reverse();
+    this.occurrenceStack = clone(this.path.occurrenceStack).reverse();
+    this.ruleStack.pop();
+    this.occurrenceStack.pop();
+    this.updateExpectedNext();
+    this.walk(this.topProd);
+    return this.possibleTokTypes;
+  }
+  walk(prod, prevRest = []) {
+    if (!this.found) {
+      super.walk(prod, prevRest);
+    }
+  }
+  walkProdRef(refProd, currRest, prevRest) {
+    if (refProd.referencedRule.name === this.nextProductionName && refProd.idx === this.nextProductionOccurrence) {
+      const fullRest = currRest.concat(prevRest);
+      this.updateExpectedNext();
+      this.walk(refProd.referencedRule, fullRest);
+    }
+  }
+  updateExpectedNext() {
+    if (isEmpty(this.ruleStack)) {
+      this.nextProductionName = "";
+      this.nextProductionOccurrence = 0;
+      this.isAtEndOfPath = true;
+    } else {
+      this.nextProductionName = this.ruleStack.pop();
+      this.nextProductionOccurrence = this.occurrenceStack.pop();
+    }
+  }
+}
+class NextAfterTokenWalker extends AbstractNextPossibleTokensWalker {
+  constructor(topProd, path) {
+    super(topProd, path);
+    this.path = path;
+    this.nextTerminalName = "";
+    this.nextTerminalOccurrence = 0;
+    this.nextTerminalName = this.path.lastTok.name;
+    this.nextTerminalOccurrence = this.path.lastTokOccurrence;
+  }
+  walkTerminal(terminal, currRest, prevRest) {
+    if (this.isAtEndOfPath && terminal.terminalType.name === this.nextTerminalName && terminal.idx === this.nextTerminalOccurrence && !this.found) {
+      const fullRest = currRest.concat(prevRest);
+      const restProd = new Alternative({ definition: fullRest });
+      this.possibleTokTypes = first$1(restProd);
+      this.found = true;
+    }
+  }
+}
+class AbstractNextTerminalAfterProductionWalker extends RestWalker {
+  constructor(topRule, occurrence) {
+    super();
+    this.topRule = topRule;
+    this.occurrence = occurrence;
+    this.result = {
+      token: void 0,
+      occurrence: void 0,
+      isEndOfRule: void 0
+    };
+  }
+  startWalking() {
+    this.walk(this.topRule);
+    return this.result;
+  }
+}
+class NextTerminalAfterManyWalker extends AbstractNextTerminalAfterProductionWalker {
+  walkMany(manyProd, currRest, prevRest) {
+    if (manyProd.idx === this.occurrence) {
+      const firstAfterMany = first(currRest.concat(prevRest));
+      this.result.isEndOfRule = firstAfterMany === void 0;
+      if (firstAfterMany instanceof Terminal) {
+        this.result.token = firstAfterMany.terminalType;
+        this.result.occurrence = firstAfterMany.idx;
+      }
+    } else {
+      super.walkMany(manyProd, currRest, prevRest);
+    }
+  }
+}
+class NextTerminalAfterManySepWalker extends AbstractNextTerminalAfterProductionWalker {
+  walkManySep(manySepProd, currRest, prevRest) {
+    if (manySepProd.idx === this.occurrence) {
+      const firstAfterManySep = first(currRest.concat(prevRest));
+      this.result.isEndOfRule = firstAfterManySep === void 0;
+      if (firstAfterManySep instanceof Terminal) {
+        this.result.token = firstAfterManySep.terminalType;
+        this.result.occurrence = firstAfterManySep.idx;
+      }
+    } else {
+      super.walkManySep(manySepProd, currRest, prevRest);
+    }
+  }
+}
+class NextTerminalAfterAtLeastOneWalker extends AbstractNextTerminalAfterProductionWalker {
+  walkAtLeastOne(atLeastOneProd, currRest, prevRest) {
+    if (atLeastOneProd.idx === this.occurrence) {
+      const firstAfterAtLeastOne = first(currRest.concat(prevRest));
+      this.result.isEndOfRule = firstAfterAtLeastOne === void 0;
+      if (firstAfterAtLeastOne instanceof Terminal) {
+        this.result.token = firstAfterAtLeastOne.terminalType;
+        this.result.occurrence = firstAfterAtLeastOne.idx;
+      }
+    } else {
+      super.walkAtLeastOne(atLeastOneProd, currRest, prevRest);
+    }
+  }
+}
+class NextTerminalAfterAtLeastOneSepWalker extends AbstractNextTerminalAfterProductionWalker {
+  walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest) {
+    if (atleastOneSepProd.idx === this.occurrence) {
+      const firstAfterfirstAfterAtLeastOneSep = first(currRest.concat(prevRest));
+      this.result.isEndOfRule = firstAfterfirstAfterAtLeastOneSep === void 0;
+      if (firstAfterfirstAfterAtLeastOneSep instanceof Terminal) {
+        this.result.token = firstAfterfirstAfterAtLeastOneSep.terminalType;
+        this.result.occurrence = firstAfterfirstAfterAtLeastOneSep.idx;
+      }
+    } else {
+      super.walkAtLeastOneSep(atleastOneSepProd, currRest, prevRest);
+    }
+  }
+}
+function possiblePathsFrom(targetDef, maxLength, currPath = []) {
+  currPath = clone(currPath);
+  let result = [];
+  let i = 0;
+  function remainingPathWith(nextDef) {
+    return nextDef.concat(drop(targetDef, i + 1));
+  }
+  function getAlternativesForProd(definition) {
+    const alternatives = possiblePathsFrom(remainingPathWith(definition), maxLength, currPath);
+    return result.concat(alternatives);
+  }
+  while (currPath.length < maxLength && i < targetDef.length) {
+    const prod = targetDef[i];
+    if (prod instanceof Alternative) {
+      return getAlternativesForProd(prod.definition);
+    } else if (prod instanceof NonTerminal) {
+      return getAlternativesForProd(prod.definition);
+    } else if (prod instanceof Option) {
+      result = getAlternativesForProd(prod.definition);
+    } else if (prod instanceof RepetitionMandatory) {
+      const newDef = prod.definition.concat([
+        new Repetition({
+          definition: prod.definition
+        })
+      ]);
+      return getAlternativesForProd(newDef);
+    } else if (prod instanceof RepetitionMandatoryWithSeparator) {
+      const newDef = [
+        new Alternative({ definition: prod.definition }),
+        new Repetition({
+          definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition)
+        })
+      ];
+      return getAlternativesForProd(newDef);
+    } else if (prod instanceof RepetitionWithSeparator) {
+      const newDef = prod.definition.concat([
+        new Repetition({
+          definition: [new Terminal({ terminalType: prod.separator })].concat(prod.definition)
+        })
+      ]);
+      result = getAlternativesForProd(newDef);
+    } else if (prod instanceof Repetition) {
+      const newDef = prod.definition.concat([
+        new Repetition({
+          definition: prod.definition
+        })
+      ]);
+      result = getAlternativesForProd(newDef);
+    } else if (prod instanceof Alternation) {
+      forEach(prod.definition, (currAlt) => {
+        if (isEmpty(currAlt.definition) === false) {
+          result = getAlternativesForProd(currAlt.definition);
+        }
+      });
+      return result;
+    } else if (prod instanceof Terminal) {
+      currPath.push(prod.terminalType);
+    } else {
+      throw Error("non exhaustive match");
+    }
+    i++;
+  }
+  result.push({
+    partialPath: currPath,
+    suffixDef: drop(targetDef, i)
+  });
+  return result;
+}
+function nextPossibleTokensAfter(initialDef, tokenVector, tokMatcher, maxLookAhead) {
+  const EXIT_NON_TERMINAL = "EXIT_NONE_TERMINAL";
+  const EXIT_NON_TERMINAL_ARR = [EXIT_NON_TERMINAL];
+  const EXIT_ALTERNATIVE = "EXIT_ALTERNATIVE";
+  let foundCompletePath = false;
+  const tokenVectorLength = tokenVector.length;
+  const minimalAlternativesIndex = tokenVectorLength - maxLookAhead - 1;
+  const result = [];
+  const possiblePaths = [];
+  possiblePaths.push({
+    idx: -1,
+    def: initialDef,
+    ruleStack: [],
+    occurrenceStack: []
+  });
+  while (!isEmpty(possiblePaths)) {
+    const currPath = possiblePaths.pop();
+    if (currPath === EXIT_ALTERNATIVE) {
+      if (foundCompletePath && last(possiblePaths).idx <= minimalAlternativesIndex) {
+        possiblePaths.pop();
+      }
+      continue;
+    }
+    const currDef = currPath.def;
+    const currIdx = currPath.idx;
+    const currRuleStack = currPath.ruleStack;
+    const currOccurrenceStack = currPath.occurrenceStack;
+    if (isEmpty(currDef)) {
+      continue;
+    }
+    const prod = currDef[0];
+    if (prod === EXIT_NON_TERMINAL) {
+      const nextPath = {
+        idx: currIdx,
+        def: drop(currDef),
+        ruleStack: dropRight(currRuleStack),
+        occurrenceStack: dropRight(currOccurrenceStack)
+      };
+      possiblePaths.push(nextPath);
+    } else if (prod instanceof Terminal) {
+      if (currIdx < tokenVectorLength - 1) {
+        const nextIdx = currIdx + 1;
+        const actualToken = tokenVector[nextIdx];
+        if (tokMatcher(actualToken, prod.terminalType)) {
+          const nextPath = {
+            idx: nextIdx,
+            def: drop(currDef),
+            ruleStack: currRuleStack,
+            occurrenceStack: currOccurrenceStack
+          };
+          possiblePaths.push(nextPath);
+        }
+      } else if (currIdx === tokenVectorLength - 1) {
+        result.push({
+          nextTokenType: prod.terminalType,
+          nextTokenOccurrence: prod.idx,
+          ruleStack: currRuleStack,
+          occurrenceStack: currOccurrenceStack
+        });
+        foundCompletePath = true;
+      } else {
+        throw Error("non exhaustive match");
+      }
+    } else if (prod instanceof NonTerminal) {
+      const newRuleStack = clone(currRuleStack);
+      newRuleStack.push(prod.nonTerminalName);
+      const newOccurrenceStack = clone(currOccurrenceStack);
+      newOccurrenceStack.push(prod.idx);
+      const nextPath = {
+        idx: currIdx,
+        def: prod.definition.concat(EXIT_NON_TERMINAL_ARR, drop(currDef)),
+        ruleStack: newRuleStack,
+        occurrenceStack: newOccurrenceStack
+      };
+      possiblePaths.push(nextPath);
+    } else if (prod instanceof Option) {
+      const nextPathWithout = {
+        idx: currIdx,
+        def: drop(currDef),
+        ruleStack: currRuleStack,
+        occurrenceStack: currOccurrenceStack
+      };
+      possiblePaths.push(nextPathWithout);
+      possiblePaths.push(EXIT_ALTERNATIVE);
+      const nextPathWith = {
+        idx: currIdx,
+        def: prod.definition.concat(drop(currDef)),
+        ruleStack: currRuleStack,
+        occurrenceStack: currOccurrenceStack
+      };
+      possiblePaths.push(nextPathWith);
+    } else if (prod instanceof RepetitionMandatory) {
+      const secondIteration = new Repetition({
+        definition: prod.definition,
+        idx: prod.idx
+      });
+      const nextDef = prod.definition.concat([secondIteration], drop(currDef));
+      const nextPath = {
+        idx: currIdx,
+        def: nextDef,
+        ruleStack: currRuleStack,
+        occurrenceStack: currOccurrenceStack
+      };
+      possiblePaths.push(nextPath);
+    } else if (prod instanceof RepetitionMandatoryWithSeparator) {
+      const separatorGast = new Terminal({
+        terminalType: prod.separator
+      });
+      const secondIteration = new Repetition({
+        definition: [separatorGast].concat(prod.definition),
+        idx: prod.idx
+      });
+      const nextDef = prod.definition.concat([secondIteration], drop(currDef));
+      const nextPath = {
+        idx: currIdx,
+        def: nextDef,
+        ruleStack: currRuleStack,
+        occurrenceStack: currOccurrenceStack
+      };
+      possiblePaths.push(nextPath);
+    } else if (prod instanceof RepetitionWithSeparator) {
+      const nextPathWithout = {
+        idx: currIdx,
+        def: drop(currDef),
+        ruleStack: currRuleStack,
+        occurrenceStack: currOccurrenceStack
+      };
+      possiblePaths.push(nextPathWithout);
+      possiblePaths.push(EXIT_ALTERNATIVE);
+      const separatorGast = new Terminal({
+        terminalType: prod.separator
+      });
+      const nthRepetition = new Repetition({
+        definition: [separatorGast].concat(prod.definition),
+        idx: prod.idx
+      });
+      const nextDef = prod.definition.concat([nthRepetition], drop(currDef));
+      const nextPathWith = {
+        idx: currIdx,
+        def: nextDef,
+        ruleStack: currRuleStack,
+        occurrenceStack: currOccurrenceStack
+      };
+      possiblePaths.push(nextPathWith);
+    } else if (prod instanceof Repetition) {
+      const nextPathWithout = {
+        idx: currIdx,
+        def: drop(currDef),
+        ruleStack: currRuleStack,
+        occurrenceStack: currOccurrenceStack
+      };
+      possiblePaths.push(nextPathWithout);
+      possiblePaths.push(EXIT_ALTERNATIVE);
+      const nthRepetition = new Repetition({
+        definition: prod.definition,
+        idx: prod.idx
+      });
+      const nextDef = prod.definition.concat([nthRepetition], drop(currDef));
+      const nextPathWith = {
+        idx: currIdx,
+        def: nextDef,
+        ruleStack: currRuleStack,
+        occurrenceStack: currOccurrenceStack
+      };
+      possiblePaths.push(nextPathWith);
+    } else if (prod instanceof Alternation) {
+      for (let i = prod.definition.length - 1; i >= 0; i--) {
+        const currAlt = prod.definition[i];
+        const currAltPath = {
+          idx: currIdx,
+          def: currAlt.definition.concat(drop(currDef)),
+          ruleStack: currRuleStack,
+          occurrenceStack: currOccurrenceStack
+        };
+        possiblePaths.push(currAltPath);
+        possiblePaths.push(EXIT_ALTERNATIVE);
+      }
+    } else if (prod instanceof Alternative) {
+      possiblePaths.push({
+        idx: currIdx,
+        def: prod.definition.concat(drop(currDef)),
+        ruleStack: currRuleStack,
+        occurrenceStack: currOccurrenceStack
+      });
+    } else if (prod instanceof Rule) {
+      possiblePaths.push(expandTopLevelRule(prod, currIdx, currRuleStack, currOccurrenceStack));
+    } else {
+      throw Error("non exhaustive match");
+    }
+  }
+  return result;
+}
+function expandTopLevelRule(topRule, currIdx, currRuleStack, currOccurrenceStack) {
+  const newRuleStack = clone(currRuleStack);
+  newRuleStack.push(topRule.name);
+  const newCurrOccurrenceStack = clone(currOccurrenceStack);
+  newCurrOccurrenceStack.push(1);
+  return {
+    idx: currIdx,
+    def: topRule.definition,
+    ruleStack: newRuleStack,
+    occurrenceStack: newCurrOccurrenceStack
+  };
+}
+export {
+  AbstractNextPossibleTokensWalker,
+  AbstractNextTerminalAfterProductionWalker,
+  NextAfterTokenWalker,
+  NextTerminalAfterAtLeastOneSepWalker,
+  NextTerminalAfterAtLeastOneWalker,
+  NextTerminalAfterManySepWalker,
+  NextTerminalAfterManyWalker,
+  nextPossibleTokensAfter,
+  possiblePathsFrom
+};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/keys.mjs

@@ -0,0 +1,22 @@
+const BITS_FOR_METHOD_TYPE = 4;
+const BITS_FOR_OCCURRENCE_IDX = 8;
+const OR_IDX = 1 << BITS_FOR_OCCURRENCE_IDX;
+const OPTION_IDX = 2 << BITS_FOR_OCCURRENCE_IDX;
+const MANY_IDX = 3 << BITS_FOR_OCCURRENCE_IDX;
+const AT_LEAST_ONE_IDX = 4 << BITS_FOR_OCCURRENCE_IDX;
+const MANY_SEP_IDX = 5 << BITS_FOR_OCCURRENCE_IDX;
+const AT_LEAST_ONE_SEP_IDX = 6 << BITS_FOR_OCCURRENCE_IDX;
+function getKeyForAutomaticLookahead(ruleIdx, dslMethodIdx, occurrence) {
+  return occurrence | dslMethodIdx | ruleIdx;
+}
+export {
+  AT_LEAST_ONE_IDX,
+  AT_LEAST_ONE_SEP_IDX,
+  BITS_FOR_METHOD_TYPE,
+  BITS_FOR_OCCURRENCE_IDX,
+  MANY_IDX,
+  MANY_SEP_IDX,
+  OPTION_IDX,
+  OR_IDX,
+  getKeyForAutomaticLookahead
+};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/llk_lookahead.mjs

@@ -0,0 +1,48 @@
+import { isEmpty, flatMap } from "lodash-es";
+import { defaultGrammarValidatorErrorProvider } from "../errors_public.mjs";
+import { DEFAULT_PARSER_CONFIG } from "../parser/parser.mjs";
+import { validateNoLeftRecursion, validateEmptyOrAlternative, validateAmbiguousAlternationAlternatives, validateSomeNonEmptyLookaheadPath } from "./checks.mjs";
+import { buildLookaheadFuncForOr, buildLookaheadFuncForOptionalProd, getProdType, buildAlternativesLookAheadFunc, buildSingleAlternativeLookaheadFunction } from "./lookahead.mjs";
+class LLkLookaheadStrategy {
+  constructor(options) {
+    var _a;
+    this.maxLookahead = (_a = options === null || options === void 0 ? void 0 : options.maxLookahead) !== null && _a !== void 0 ? _a : DEFAULT_PARSER_CONFIG.maxLookahead;
+  }
+  validate(options) {
+    const leftRecursionErrors = this.validateNoLeftRecursion(options.rules);
+    if (isEmpty(leftRecursionErrors)) {
+      const emptyAltErrors = this.validateEmptyOrAlternatives(options.rules);
+      const ambiguousAltsErrors = this.validateAmbiguousAlternationAlternatives(options.rules, this.maxLookahead);
+      const emptyRepetitionErrors = this.validateSomeNonEmptyLookaheadPath(options.rules, this.maxLookahead);
+      const allErrors = [
+        ...leftRecursionErrors,
+        ...emptyAltErrors,
+        ...ambiguousAltsErrors,
+        ...emptyRepetitionErrors
+      ];
+      return allErrors;
+    }
+    return leftRecursionErrors;
+  }
+  validateNoLeftRecursion(rules) {
+    return flatMap(rules, (currTopRule) => validateNoLeftRecursion(currTopRule, currTopRule, defaultGrammarValidatorErrorProvider));
+  }
+  validateEmptyOrAlternatives(rules) {
+    return flatMap(rules, (currTopRule) => validateEmptyOrAlternative(currTopRule, defaultGrammarValidatorErrorProvider));
+  }
+  validateAmbiguousAlternationAlternatives(rules, maxLookahead) {
+    return flatMap(rules, (currTopRule) => validateAmbiguousAlternationAlternatives(currTopRule, maxLookahead, defaultGrammarValidatorErrorProvider));
+  }
+  validateSomeNonEmptyLookaheadPath(rules, maxLookahead) {
+    return validateSomeNonEmptyLookaheadPath(rules, maxLookahead, defaultGrammarValidatorErrorProvider);
+  }
+  buildLookaheadForAlternation(options) {
+    return buildLookaheadFuncForOr(options.prodOccurrence, options.rule, options.maxLookahead, options.hasPredicates, options.dynamicTokensEnabled, buildAlternativesLookAheadFunc);
+  }
+  buildLookaheadForOptional(options) {
+    return buildLookaheadFuncForOptionalProd(options.prodOccurrence, options.rule, options.maxLookahead, options.dynamicTokensEnabled, getProdType(options.prodType), buildSingleAlternativeLookaheadFunction);
+  }
+}
+export {
+  LLkLookaheadStrategy
+};