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

package/dist/node_modules/.pnpm/chevrotain-allstar@0.3.1_chevrotain@11.0.3/node_modules/chevrotain-allstar/lib/atn.mjs

@@ -1,393 +0,0 @@
-import map from "../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
-import filter from "../../../../lodash-es@4.17.21/node_modules/lodash-es/filter.mjs";
-import "../../../../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 "lodash-es";
-import "../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/errors_public.mjs";
-import { Terminal, NonTerminal, Alternation, Option, Repetition, RepetitionWithSeparator, RepetitionMandatory, RepetitionMandatoryWithSeparator } from "../../../../@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs";
-import "../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs";
-function buildATNKey(rule, type, occurrence) {
-  return `${rule.name}_${type}_${occurrence}`;
-}
-const ATN_BASIC = 1;
-const ATN_RULE_START = 2;
-const ATN_PLUS_BLOCK_START = 4;
-const ATN_STAR_BLOCK_START = 5;
-const ATN_RULE_STOP = 7;
-const ATN_BLOCK_END = 8;
-const ATN_STAR_LOOP_BACK = 9;
-const ATN_STAR_LOOP_ENTRY = 10;
-const ATN_PLUS_LOOP_BACK = 11;
-const ATN_LOOP_END = 12;
-class AbstractTransition {
-  constructor(target) {
-    this.target = target;
-  }
-  isEpsilon() {
-    return false;
-  }
-}
-class AtomTransition extends AbstractTransition {
-  constructor(target, tokenType) {
-    super(target);
-    this.tokenType = tokenType;
-  }
-}
-class EpsilonTransition extends AbstractTransition {
-  constructor(target) {
-    super(target);
-  }
-  isEpsilon() {
-    return true;
-  }
-}
-class RuleTransition extends AbstractTransition {
-  constructor(ruleStart, rule, followState) {
-    super(ruleStart);
-    this.rule = rule;
-    this.followState = followState;
-  }
-  isEpsilon() {
-    return true;
-  }
-}
-function createATN(rules) {
-  const atn = {
-    decisionMap: {},
-    decisionStates: [],
-    ruleToStartState: /* @__PURE__ */ new Map(),
-    ruleToStopState: /* @__PURE__ */ new Map(),
-    states: []
-  };
-  createRuleStartAndStopATNStates(atn, rules);
-  const ruleLength = rules.length;
-  for (let i = 0; i < ruleLength; i++) {
-    const rule = rules[i];
-    const ruleBlock = block(atn, rule, rule);
-    if (ruleBlock === void 0) {
-      continue;
-    }
-    buildRuleHandle(atn, rule, ruleBlock);
-  }
-  return atn;
-}
-function createRuleStartAndStopATNStates(atn, rules) {
-  const ruleLength = rules.length;
-  for (let i = 0; i < ruleLength; i++) {
-    const rule = rules[i];
-    const start = newState(atn, rule, void 0, {
-      type: ATN_RULE_START
-    });
-    const stop = newState(atn, rule, void 0, {
-      type: ATN_RULE_STOP
-    });
-    start.stop = stop;
-    atn.ruleToStartState.set(rule, start);
-    atn.ruleToStopState.set(rule, stop);
-  }
-}
-function atom(atn, rule, production) {
-  if (production instanceof Terminal) {
-    return tokenRef(atn, rule, production.terminalType, production);
-  } else if (production instanceof NonTerminal) {
-    return ruleRef(atn, rule, production);
-  } else if (production instanceof Alternation) {
-    return alternation(atn, rule, production);
-  } else if (production instanceof Option) {
-    return option(atn, rule, production);
-  } else if (production instanceof Repetition) {
-    return repetition(atn, rule, production);
-  } else if (production instanceof RepetitionWithSeparator) {
-    return repetitionSep(atn, rule, production);
-  } else if (production instanceof RepetitionMandatory) {
-    return repetitionMandatory(atn, rule, production);
-  } else if (production instanceof RepetitionMandatoryWithSeparator) {
-    return repetitionMandatorySep(atn, rule, production);
-  } else {
-    return block(atn, rule, production);
-  }
-}
-function repetition(atn, rule, repetition2) {
-  const starState = newState(atn, rule, repetition2, {
-    type: ATN_STAR_BLOCK_START
-  });
-  defineDecisionState(atn, starState);
-  const handle = makeAlts(atn, rule, starState, repetition2, block(atn, rule, repetition2));
-  return star(atn, rule, repetition2, handle);
-}
-function repetitionSep(atn, rule, repetition2) {
-  const starState = newState(atn, rule, repetition2, {
-    type: ATN_STAR_BLOCK_START
-  });
-  defineDecisionState(atn, starState);
-  const handle = makeAlts(atn, rule, starState, repetition2, block(atn, rule, repetition2));
-  const sep = tokenRef(atn, rule, repetition2.separator, repetition2);
-  return star(atn, rule, repetition2, handle, sep);
-}
-function repetitionMandatory(atn, rule, repetition2) {
-  const plusState = newState(atn, rule, repetition2, {
-    type: ATN_PLUS_BLOCK_START
-  });
-  defineDecisionState(atn, plusState);
-  const handle = makeAlts(atn, rule, plusState, repetition2, block(atn, rule, repetition2));
-  return plus(atn, rule, repetition2, handle);
-}
-function repetitionMandatorySep(atn, rule, repetition2) {
-  const plusState = newState(atn, rule, repetition2, {
-    type: ATN_PLUS_BLOCK_START
-  });
-  defineDecisionState(atn, plusState);
-  const handle = makeAlts(atn, rule, plusState, repetition2, block(atn, rule, repetition2));
-  const sep = tokenRef(atn, rule, repetition2.separator, repetition2);
-  return plus(atn, rule, repetition2, handle, sep);
-}
-function alternation(atn, rule, alternation2) {
-  const start = newState(atn, rule, alternation2, {
-    type: ATN_BASIC
-  });
-  defineDecisionState(atn, start);
-  const alts = map(alternation2.definition, (e) => atom(atn, rule, e));
-  const handle = makeAlts(atn, rule, start, alternation2, ...alts);
-  return handle;
-}
-function option(atn, rule, option2) {
-  const start = newState(atn, rule, option2, {
-    type: ATN_BASIC
-  });
-  defineDecisionState(atn, start);
-  const handle = makeAlts(atn, rule, start, option2, block(atn, rule, option2));
-  return optional(atn, rule, option2, handle);
-}
-function block(atn, rule, block2) {
-  const handles = filter(map(block2.definition, (e) => atom(atn, rule, e)), (e) => e !== void 0);
-  if (handles.length === 1) {
-    return handles[0];
-  } else if (handles.length === 0) {
-    return void 0;
-  } else {
-    return makeBlock(atn, handles);
-  }
-}
-function plus(atn, rule, plus2, handle, sep) {
-  const blkStart = handle.left;
-  const blkEnd = handle.right;
-  const loop = newState(atn, rule, plus2, {
-    type: ATN_PLUS_LOOP_BACK
-  });
-  defineDecisionState(atn, loop);
-  const end = newState(atn, rule, plus2, {
-    type: ATN_LOOP_END
-  });
-  blkStart.loopback = loop;
-  end.loopback = loop;
-  atn.decisionMap[buildATNKey(rule, sep ? "RepetitionMandatoryWithSeparator" : "RepetitionMandatory", plus2.idx)] = loop;
-  epsilon(blkEnd, loop);
-  if (sep === void 0) {
-    epsilon(loop, blkStart);
-    epsilon(loop, end);
-  } else {
-    epsilon(loop, end);
-    epsilon(loop, sep.left);
-    epsilon(sep.right, blkStart);
-  }
-  return {
-    left: blkStart,
-    right: end
-  };
-}
-function star(atn, rule, star2, handle, sep) {
-  const start = handle.left;
-  const end = handle.right;
-  const entry = newState(atn, rule, star2, {
-    type: ATN_STAR_LOOP_ENTRY
-  });
-  defineDecisionState(atn, entry);
-  const loopEnd = newState(atn, rule, star2, {
-    type: ATN_LOOP_END
-  });
-  const loop = newState(atn, rule, star2, {
-    type: ATN_STAR_LOOP_BACK
-  });
-  entry.loopback = loop;
-  loopEnd.loopback = loop;
-  epsilon(entry, start);
-  epsilon(entry, loopEnd);
-  epsilon(end, loop);
-  if (sep !== void 0) {
-    epsilon(loop, loopEnd);
-    epsilon(loop, sep.left);
-    epsilon(sep.right, start);
-  } else {
-    epsilon(loop, entry);
-  }
-  atn.decisionMap[buildATNKey(rule, sep ? "RepetitionWithSeparator" : "Repetition", star2.idx)] = entry;
-  return {
-    left: entry,
-    right: loopEnd
-  };
-}
-function optional(atn, rule, optional2, handle) {
-  const start = handle.left;
-  const end = handle.right;
-  epsilon(start, end);
-  atn.decisionMap[buildATNKey(rule, "Option", optional2.idx)] = start;
-  return handle;
-}
-function defineDecisionState(atn, state) {
-  atn.decisionStates.push(state);
-  state.decision = atn.decisionStates.length - 1;
-  return state.decision;
-}
-function makeAlts(atn, rule, start, production, ...alts) {
-  const end = newState(atn, rule, production, {
-    type: ATN_BLOCK_END,
-    start
-  });
-  start.end = end;
-  for (const alt of alts) {
-    if (alt !== void 0) {
-      epsilon(start, alt.left);
-      epsilon(alt.right, end);
-    } else {
-      epsilon(start, end);
-    }
-  }
-  const handle = {
-    left: start,
-    right: end
-  };
-  atn.decisionMap[buildATNKey(rule, getProdType(production), production.idx)] = start;
-  return handle;
-}
-function getProdType(production) {
-  if (production instanceof Alternation) {
-    return "Alternation";
-  } else if (production instanceof Option) {
-    return "Option";
-  } else if (production instanceof Repetition) {
-    return "Repetition";
-  } else if (production instanceof RepetitionWithSeparator) {
-    return "RepetitionWithSeparator";
-  } else if (production instanceof RepetitionMandatory) {
-    return "RepetitionMandatory";
-  } else if (production instanceof RepetitionMandatoryWithSeparator) {
-    return "RepetitionMandatoryWithSeparator";
-  } else {
-    throw new Error("Invalid production type encountered");
-  }
-}
-function makeBlock(atn, alts) {
-  const altsLength = alts.length;
-  for (let i = 0; i < altsLength - 1; i++) {
-    const handle = alts[i];
-    let transition;
-    if (handle.left.transitions.length === 1) {
-      transition = handle.left.transitions[0];
-    }
-    const isRuleTransition = transition instanceof RuleTransition;
-    const ruleTransition = transition;
-    const next = alts[i + 1].left;
-    if (handle.left.type === ATN_BASIC && handle.right.type === ATN_BASIC && transition !== void 0 && (isRuleTransition && ruleTransition.followState === handle.right || transition.target === handle.right)) {
-      if (isRuleTransition) {
-        ruleTransition.followState = next;
-      } else {
-        transition.target = next;
-      }
-      removeState(atn, handle.right);
-    } else {
-      epsilon(handle.right, next);
-    }
-  }
-  const first = alts[0];
-  const last = alts[altsLength - 1];
-  return {
-    left: first.left,
-    right: last.right
-  };
-}
-function tokenRef(atn, rule, tokenType, production) {
-  const left = newState(atn, rule, production, {
-    type: ATN_BASIC
-  });
-  const right = newState(atn, rule, production, {
-    type: ATN_BASIC
-  });
-  addTransition(left, new AtomTransition(right, tokenType));
-  return {
-    left,
-    right
-  };
-}
-function ruleRef(atn, currentRule, nonTerminal) {
-  const rule = nonTerminal.referencedRule;
-  const start = atn.ruleToStartState.get(rule);
-  const left = newState(atn, currentRule, nonTerminal, {
-    type: ATN_BASIC
-  });
-  const right = newState(atn, currentRule, nonTerminal, {
-    type: ATN_BASIC
-  });
-  const call = new RuleTransition(start, rule, right);
-  addTransition(left, call);
-  return {
-    left,
-    right
-  };
-}
-function buildRuleHandle(atn, rule, block2) {
-  const start = atn.ruleToStartState.get(rule);
-  epsilon(start, block2.left);
-  const stop = atn.ruleToStopState.get(rule);
-  epsilon(block2.right, stop);
-  const handle = {
-    left: start,
-    right: stop
-  };
-  return handle;
-}
-function epsilon(a, b) {
-  const transition = new EpsilonTransition(b);
-  addTransition(a, transition);
-}
-function newState(atn, rule, production, partial) {
-  const t = Object.assign({
-    atn,
-    production,
-    epsilonOnlyTransitions: false,
-    rule,
-    transitions: [],
-    nextTokenWithinRule: [],
-    stateNumber: atn.states.length
-  }, partial);
-  atn.states.push(t);
-  return t;
-}
-function addTransition(state, transition) {
-  if (state.transitions.length === 0) {
-    state.epsilonOnlyTransitions = transition.isEpsilon();
-  }
-  state.transitions.push(transition);
-}
-function removeState(atn, state) {
-  atn.states.splice(atn.states.indexOf(state), 1);
-}
-export {
-  ATN_BASIC,
-  ATN_BLOCK_END,
-  ATN_LOOP_END,
-  ATN_PLUS_BLOCK_START,
-  ATN_PLUS_LOOP_BACK,
-  ATN_RULE_START,
-  ATN_RULE_STOP,
-  ATN_STAR_BLOCK_START,
-  ATN_STAR_LOOP_BACK,
-  ATN_STAR_LOOP_ENTRY,
-  AbstractTransition,
-  AtomTransition,
-  EpsilonTransition,
-  RuleTransition,
-  buildATNKey,
-  createATN
-};

package/dist/node_modules/.pnpm/chevrotain-allstar@0.3.1_chevrotain@11.0.3/node_modules/chevrotain-allstar/lib/dfa.mjs

@@ -1,42 +0,0 @@
-import map from "../../../../lodash-es@4.17.21/node_modules/lodash-es/map.mjs";
-const DFA_ERROR = {};
-class ATNConfigSet {
-  constructor() {
-    this.map = {};
-    this.configs = [];
-  }
-  get size() {
-    return this.configs.length;
-  }
-  finalize() {
-    this.map = {};
-  }
-  add(config) {
-    const key = getATNConfigKey(config);
-    if (!(key in this.map)) {
-      this.map[key] = this.configs.length;
-      this.configs.push(config);
-    }
-  }
-  get elements() {
-    return this.configs;
-  }
-  get alts() {
-    return map(this.configs, (e) => e.alt);
-  }
-  get key() {
-    let value = "";
-    for (const k in this.map) {
-      value += k + ":";
-    }
-    return value;
-  }
-}
-function getATNConfigKey(config, alt = true) {
-  return `${alt ? `a${config.alt}` : ""}s${config.state.stateNumber}:${config.stack.map((e) => e.stateNumber.toString()).join("_")}`;
-}
-export {
-  ATNConfigSet,
-  DFA_ERROR,
-  getATNConfigKey
-};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/lang/lang_extensions.mjs

@@ -1,12 +0,0 @@
-const NAME = "name";
-function defineNameProp(obj, nameValue) {
-  Object.defineProperty(obj, NAME, {
-    enumerable: false,
-    configurable: true,
-    writable: false,
-    value: nameValue
-  });
-}
-export {
-  defineNameProp
-};

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

@@ -1,4 +0,0 @@
-const IN = "_~IN~_";
-export {
-  IN
-};

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

@@ -1,42 +0,0 @@
-function setNodeLocationOnlyOffset(currNodeLocation, newLocationInfo) {
-  if (isNaN(currNodeLocation.startOffset) === true) {
-    currNodeLocation.startOffset = newLocationInfo.startOffset;
-    currNodeLocation.endOffset = newLocationInfo.endOffset;
-  } else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {
-    currNodeLocation.endOffset = newLocationInfo.endOffset;
-  }
-}
-function setNodeLocationFull(currNodeLocation, newLocationInfo) {
-  if (isNaN(currNodeLocation.startOffset) === true) {
-    currNodeLocation.startOffset = newLocationInfo.startOffset;
-    currNodeLocation.startColumn = newLocationInfo.startColumn;
-    currNodeLocation.startLine = newLocationInfo.startLine;
-    currNodeLocation.endOffset = newLocationInfo.endOffset;
-    currNodeLocation.endColumn = newLocationInfo.endColumn;
-    currNodeLocation.endLine = newLocationInfo.endLine;
-  } else if (currNodeLocation.endOffset < newLocationInfo.endOffset === true) {
-    currNodeLocation.endOffset = newLocationInfo.endOffset;
-    currNodeLocation.endColumn = newLocationInfo.endColumn;
-    currNodeLocation.endLine = newLocationInfo.endLine;
-  }
-}
-function addTerminalToCst(node, token, tokenTypeName) {
-  if (node.children[tokenTypeName] === void 0) {
-    node.children[tokenTypeName] = [token];
-  } else {
-    node.children[tokenTypeName].push(token);
-  }
-}
-function addNoneTerminalToCst(node, ruleName, ruleResult) {
-  if (node.children[ruleName] === void 0) {
-    node.children[ruleName] = [ruleResult];
-  } else {
-    node.children[ruleName].push(ruleResult);
-  }
-}
-export {
-  addNoneTerminalToCst,
-  addTerminalToCst,
-  setNodeLocationFull,
-  setNodeLocationOnlyOffset
-};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/cst/cst_visitor.mjs

@@ -1,87 +0,0 @@
-import { forEach, isEmpty, map, isArray, isUndefined, keys, filter, isFunction, compact } from "lodash-es";
-import { defineNameProp } from "../../lang/lang_extensions.mjs";
-function defaultVisit(ctx, param) {
-  const childrenNames = keys(ctx);
-  const childrenNamesLength = childrenNames.length;
-  for (let i = 0; i < childrenNamesLength; i++) {
-    const currChildName = childrenNames[i];
-    const currChildArray = ctx[currChildName];
-    const currChildArrayLength = currChildArray.length;
-    for (let j = 0; j < currChildArrayLength; j++) {
-      const currChild = currChildArray[j];
-      if (currChild.tokenTypeIdx === void 0) {
-        this[currChild.name](currChild.children, param);
-      }
-    }
-  }
-}
-function createBaseSemanticVisitorConstructor(grammarName, ruleNames) {
-  const derivedConstructor = function() {
-  };
-  defineNameProp(derivedConstructor, grammarName + "BaseSemantics");
-  const semanticProto = {
-    visit: function(cstNode, param) {
-      if (isArray(cstNode)) {
-        cstNode = cstNode[0];
-      }
-      if (isUndefined(cstNode)) {
-        return void 0;
-      }
-      return this[cstNode.name](cstNode.children, param);
-    },
-    validateVisitor: function() {
-      const semanticDefinitionErrors = validateVisitor(this, ruleNames);
-      if (!isEmpty(semanticDefinitionErrors)) {
-        const errorMessages = map(semanticDefinitionErrors, (currDefError) => currDefError.msg);
-        throw Error(`Errors Detected in CST Visitor <${this.constructor.name}>:
-	${errorMessages.join("\n\n").replace(/\n/g, "\n	")}`);
-      }
-    }
-  };
-  derivedConstructor.prototype = semanticProto;
-  derivedConstructor.prototype.constructor = derivedConstructor;
-  derivedConstructor._RULE_NAMES = ruleNames;
-  return derivedConstructor;
-}
-function createBaseVisitorConstructorWithDefaults(grammarName, ruleNames, baseConstructor) {
-  const derivedConstructor = function() {
-  };
-  defineNameProp(derivedConstructor, grammarName + "BaseSemanticsWithDefaults");
-  const withDefaultsProto = Object.create(baseConstructor.prototype);
-  forEach(ruleNames, (ruleName) => {
-    withDefaultsProto[ruleName] = defaultVisit;
-  });
-  derivedConstructor.prototype = withDefaultsProto;
-  derivedConstructor.prototype.constructor = derivedConstructor;
-  return derivedConstructor;
-}
-var CstVisitorDefinitionError;
-(function(CstVisitorDefinitionError2) {
-  CstVisitorDefinitionError2[CstVisitorDefinitionError2["REDUNDANT_METHOD"] = 0] = "REDUNDANT_METHOD";
-  CstVisitorDefinitionError2[CstVisitorDefinitionError2["MISSING_METHOD"] = 1] = "MISSING_METHOD";
-})(CstVisitorDefinitionError || (CstVisitorDefinitionError = {}));
-function validateVisitor(visitorInstance, ruleNames) {
-  const missingErrors = validateMissingCstMethods(visitorInstance, ruleNames);
-  return missingErrors;
-}
-function validateMissingCstMethods(visitorInstance, ruleNames) {
-  const missingRuleNames = filter(ruleNames, (currRuleName) => {
-    return isFunction(visitorInstance[currRuleName]) === false;
-  });
-  const errors = map(missingRuleNames, (currRuleName) => {
-    return {
-      msg: `Missing visitor method: <${currRuleName}> on ${visitorInstance.constructor.name} CST Visitor.`,
-      type: CstVisitorDefinitionError.MISSING_METHOD,
-      methodName: currRuleName
-    };
-  });
-  return compact(errors);
-}
-export {
-  CstVisitorDefinitionError,
-  createBaseSemanticVisitorConstructor,
-  createBaseVisitorConstructorWithDefaults,
-  defaultVisit,
-  validateMissingCstMethods,
-  validateVisitor
-};