@elmethis/core 1.0.0-alpha.149 → 1.0.0-alpha.150

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

@@ -1,41 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,424 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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
-};