@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/scan/reg_exp.mjs

@@ -1,214 +0,0 @@
-import "../../../../../../@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.mjs";
-import { BaseRegExpVisitor } from "../../../../../../@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.mjs";
-import { find, includes, forEach, values, every, isArray } from "lodash-es";
-import { PRINT_WARNING, PRINT_ERROR } from "../../../../../../@chevrotain_utils@11.0.3/node_modules/@chevrotain/utils/lib/src/print.mjs";
-import { getRegExpAst } from "./reg_exp_parser.mjs";
-import { minOptimizationVal, charCodeToOptimizedIndex } from "./lexer.mjs";
-const complementErrorMessage = "Complement Sets are not supported for first char optimization";
-const failedOptimizationPrefixMsg = 'Unable to use "first char" lexer optimizations:\n';
-function getOptimizedStartCodesIndices(regExp, ensureOptimizations = false) {
-  try {
-    const ast = getRegExpAst(regExp);
-    const firstChars = firstCharOptimizedIndices(ast.value, {}, ast.flags.ignoreCase);
-    return firstChars;
-  } catch (e) {
-    if (e.message === complementErrorMessage) {
-      if (ensureOptimizations) {
-        PRINT_WARNING(`${failedOptimizationPrefixMsg}	Unable to optimize: < ${regExp.toString()} >
-	Complement Sets cannot be automatically optimized.
-	This will disable the lexer's first char optimizations.
-	See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.`);
-      }
-    } else {
-      let msgSuffix = "";
-      if (ensureOptimizations) {
-        msgSuffix = "\n	This will disable the lexer's first char optimizations.\n	See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details.";
-      }
-      PRINT_ERROR(`${failedOptimizationPrefixMsg}
-	Failed parsing: < ${regExp.toString()} >
-	Using the @chevrotain/regexp-to-ast library
-	Please open an issue at: https://github.com/chevrotain/chevrotain/issues` + msgSuffix);
-    }
-  }
-  return [];
-}
-function firstCharOptimizedIndices(ast, result, ignoreCase) {
-  switch (ast.type) {
-    case "Disjunction":
-      for (let i = 0; i < ast.value.length; i++) {
-        firstCharOptimizedIndices(ast.value[i], result, ignoreCase);
-      }
-      break;
-    case "Alternative":
-      const terms = ast.value;
-      for (let i = 0; i < terms.length; i++) {
-        const term = terms[i];
-        switch (term.type) {
-          case "EndAnchor":
-          // A group back reference cannot affect potential starting char.
-          // because if a back reference is the first production than automatically
-          // the group being referenced has had to come BEFORE so its codes have already been added
-          case "GroupBackReference":
-          // assertions do not affect potential starting codes
-          case "Lookahead":
-          case "NegativeLookahead":
-          case "StartAnchor":
-          case "WordBoundary":
-          case "NonWordBoundary":
-            continue;
-        }
-        const atom = term;
-        switch (atom.type) {
-          case "Character":
-            addOptimizedIdxToResult(atom.value, result, ignoreCase);
-            break;
-          case "Set":
-            if (atom.complement === true) {
-              throw Error(complementErrorMessage);
-            }
-            forEach(atom.value, (code) => {
-              if (typeof code === "number") {
-                addOptimizedIdxToResult(code, result, ignoreCase);
-              } else {
-                const range = code;
-                if (ignoreCase === true) {
-                  for (let rangeCode = range.from; rangeCode <= range.to; rangeCode++) {
-                    addOptimizedIdxToResult(rangeCode, result, ignoreCase);
-                  }
-                } else {
-                  for (let rangeCode = range.from; rangeCode <= range.to && rangeCode < minOptimizationVal; rangeCode++) {
-                    addOptimizedIdxToResult(rangeCode, result, ignoreCase);
-                  }
-                  if (range.to >= minOptimizationVal) {
-                    const minUnOptVal = range.from >= minOptimizationVal ? range.from : minOptimizationVal;
-                    const maxUnOptVal = range.to;
-                    const minOptIdx = charCodeToOptimizedIndex(minUnOptVal);
-                    const maxOptIdx = charCodeToOptimizedIndex(maxUnOptVal);
-                    for (let currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) {
-                      result[currOptIdx] = currOptIdx;
-                    }
-                  }
-                }
-              }
-            });
-            break;
-          case "Group":
-            firstCharOptimizedIndices(atom.value, result, ignoreCase);
-            break;
-          /* istanbul ignore next */
-          default:
-            throw Error("Non Exhaustive Match");
-        }
-        const isOptionalQuantifier = atom.quantifier !== void 0 && atom.quantifier.atLeast === 0;
-        if (
-          // A group may be optional due to empty contents /(?:)/
-          // or if everything inside it is optional /((a)?)/
-          atom.type === "Group" && isWholeOptional(atom) === false || // If this term is not a group it may only be optional if it has an optional quantifier
-          atom.type !== "Group" && isOptionalQuantifier === false
-        ) {
-          break;
-        }
-      }
-      break;
-    /* istanbul ignore next */
-    default:
-      throw Error("non exhaustive match!");
-  }
-  return values(result);
-}
-function addOptimizedIdxToResult(code, result, ignoreCase) {
-  const optimizedCharIdx = charCodeToOptimizedIndex(code);
-  result[optimizedCharIdx] = optimizedCharIdx;
-  if (ignoreCase === true) {
-    handleIgnoreCase(code, result);
-  }
-}
-function handleIgnoreCase(code, result) {
-  const char = String.fromCharCode(code);
-  const upperChar = char.toUpperCase();
-  if (upperChar !== char) {
-    const optimizedCharIdx = charCodeToOptimizedIndex(upperChar.charCodeAt(0));
-    result[optimizedCharIdx] = optimizedCharIdx;
-  } else {
-    const lowerChar = char.toLowerCase();
-    if (lowerChar !== char) {
-      const optimizedCharIdx = charCodeToOptimizedIndex(lowerChar.charCodeAt(0));
-      result[optimizedCharIdx] = optimizedCharIdx;
-    }
-  }
-}
-function findCode(setNode, targetCharCodes) {
-  return find(setNode.value, (codeOrRange) => {
-    if (typeof codeOrRange === "number") {
-      return includes(targetCharCodes, codeOrRange);
-    } else {
-      const range = codeOrRange;
-      return find(targetCharCodes, (targetCode) => range.from <= targetCode && targetCode <= range.to) !== void 0;
-    }
-  });
-}
-function isWholeOptional(ast) {
-  const quantifier = ast.quantifier;
-  if (quantifier && quantifier.atLeast === 0) {
-    return true;
-  }
-  if (!ast.value) {
-    return false;
-  }
-  return isArray(ast.value) ? every(ast.value, isWholeOptional) : isWholeOptional(ast.value);
-}
-class CharCodeFinder extends BaseRegExpVisitor {
-  constructor(targetCharCodes) {
-    super();
-    this.targetCharCodes = targetCharCodes;
-    this.found = false;
-  }
-  visitChildren(node) {
-    if (this.found === true) {
-      return;
-    }
-    switch (node.type) {
-      case "Lookahead":
-        this.visitLookahead(node);
-        return;
-      case "NegativeLookahead":
-        this.visitNegativeLookahead(node);
-        return;
-    }
-    super.visitChildren(node);
-  }
-  visitCharacter(node) {
-    if (includes(this.targetCharCodes, node.value)) {
-      this.found = true;
-    }
-  }
-  visitSet(node) {
-    if (node.complement) {
-      if (findCode(node, this.targetCharCodes) === void 0) {
-        this.found = true;
-      }
-    } else {
-      if (findCode(node, this.targetCharCodes) !== void 0) {
-        this.found = true;
-      }
-    }
-  }
-}
-function canMatchCharCode(charCodes, pattern) {
-  if (pattern instanceof RegExp) {
-    const ast = getRegExpAst(pattern);
-    const charCodeFinder = new CharCodeFinder(charCodes);
-    charCodeFinder.visit(ast);
-    return charCodeFinder.found;
-  } else {
-    return find(pattern, (char) => {
-      return includes(charCodes, char.charCodeAt(0));
-    }) !== void 0;
-  }
-}
-export {
-  canMatchCharCode,
-  failedOptimizationPrefixMsg,
-  firstCharOptimizedIndices,
-  getOptimizedStartCodesIndices
-};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/reg_exp_parser.mjs

@@ -1,20 +0,0 @@
-import { RegExpParser } from "../../../../../../@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.mjs";
-let regExpAstCache = {};
-const regExpParser = new RegExpParser();
-function getRegExpAst(regExp) {
-  const regExpStr = regExp.toString();
-  if (regExpAstCache.hasOwnProperty(regExpStr)) {
-    return regExpAstCache[regExpStr];
-  } else {
-    const regExpAst = regExpParser.pattern(regExpStr);
-    regExpAstCache[regExpStr] = regExpAst;
-    return regExpAst;
-  }
-}
-function clearRegExpParserCache() {
-  regExpAstCache = {};
-}
-export {
-  clearRegExpParserCache,
-  getRegExpAst
-};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens.mjs

@@ -1,115 +0,0 @@
-import { forEach, clone, compact, flatten, map, difference, isEmpty, isArray, has, includes } from "lodash-es";
-function tokenStructuredMatcher(tokInstance, tokConstructor) {
-  const instanceType = tokInstance.tokenTypeIdx;
-  if (instanceType === tokConstructor.tokenTypeIdx) {
-    return true;
-  } else {
-    return tokConstructor.isParent === true && tokConstructor.categoryMatchesMap[instanceType] === true;
-  }
-}
-function tokenStructuredMatcherNoCategories(token, tokType) {
-  return token.tokenTypeIdx === tokType.tokenTypeIdx;
-}
-let tokenShortNameIdx = 1;
-const tokenIdxToClass = {};
-function augmentTokenTypes(tokenTypes) {
-  const tokenTypesAndParents = expandCategories(tokenTypes);
-  assignTokenDefaultProps(tokenTypesAndParents);
-  assignCategoriesMapProp(tokenTypesAndParents);
-  assignCategoriesTokensProp(tokenTypesAndParents);
-  forEach(tokenTypesAndParents, (tokType) => {
-    tokType.isParent = tokType.categoryMatches.length > 0;
-  });
-}
-function expandCategories(tokenTypes) {
-  let result = clone(tokenTypes);
-  let categories = tokenTypes;
-  let searching = true;
-  while (searching) {
-    categories = compact(flatten(map(categories, (currTokType) => currTokType.CATEGORIES)));
-    const newCategories = difference(categories, result);
-    result = result.concat(newCategories);
-    if (isEmpty(newCategories)) {
-      searching = false;
-    } else {
-      categories = newCategories;
-    }
-  }
-  return result;
-}
-function assignTokenDefaultProps(tokenTypes) {
-  forEach(tokenTypes, (currTokType) => {
-    if (!hasShortKeyProperty(currTokType)) {
-      tokenIdxToClass[tokenShortNameIdx] = currTokType;
-      currTokType.tokenTypeIdx = tokenShortNameIdx++;
-    }
-    if (hasCategoriesProperty(currTokType) && !isArray(currTokType.CATEGORIES)) {
-      currTokType.CATEGORIES = [currTokType.CATEGORIES];
-    }
-    if (!hasCategoriesProperty(currTokType)) {
-      currTokType.CATEGORIES = [];
-    }
-    if (!hasExtendingTokensTypesProperty(currTokType)) {
-      currTokType.categoryMatches = [];
-    }
-    if (!hasExtendingTokensTypesMapProperty(currTokType)) {
-      currTokType.categoryMatchesMap = {};
-    }
-  });
-}
-function assignCategoriesTokensProp(tokenTypes) {
-  forEach(tokenTypes, (currTokType) => {
-    currTokType.categoryMatches = [];
-    forEach(currTokType.categoryMatchesMap, (val, key) => {
-      currTokType.categoryMatches.push(tokenIdxToClass[key].tokenTypeIdx);
-    });
-  });
-}
-function assignCategoriesMapProp(tokenTypes) {
-  forEach(tokenTypes, (currTokType) => {
-    singleAssignCategoriesToksMap([], currTokType);
-  });
-}
-function singleAssignCategoriesToksMap(path, nextNode) {
-  forEach(path, (pathNode) => {
-    nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;
-  });
-  forEach(nextNode.CATEGORIES, (nextCategory) => {
-    const newPath = path.concat(nextNode);
-    if (!includes(newPath, nextCategory)) {
-      singleAssignCategoriesToksMap(newPath, nextCategory);
-    }
-  });
-}
-function hasShortKeyProperty(tokType) {
-  return has(tokType, "tokenTypeIdx");
-}
-function hasCategoriesProperty(tokType) {
-  return has(tokType, "CATEGORIES");
-}
-function hasExtendingTokensTypesProperty(tokType) {
-  return has(tokType, "categoryMatches");
-}
-function hasExtendingTokensTypesMapProperty(tokType) {
-  return has(tokType, "categoryMatchesMap");
-}
-function isTokenType(tokType) {
-  return has(tokType, "tokenTypeIdx");
-}
-export {
-  assignCategoriesMapProp,
-  assignCategoriesTokensProp,
-  assignTokenDefaultProps,
-  augmentTokenTypes,
-  expandCategories,
-  hasCategoriesProperty,
-  hasExtendingTokensTypesMapProperty,
-  hasExtendingTokensTypesProperty,
-  hasShortKeyProperty,
-  isTokenType,
-  singleAssignCategoriesToksMap,
-  tokenIdxToClass,
-  tokenShortNameIdx,
-  tokenStructuredMatcher,
-  tokenStructuredMatcherNoCategories
-};

package/dist/node_modules/.pnpm/chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.mjs

@@ -1,88 +0,0 @@
-import { isString, isUndefined, has } from "lodash-es";
-import { Lexer } from "./lexer_public.mjs";
-import { tokenStructuredMatcher, augmentTokenTypes } from "./tokens.mjs";
-function tokenLabel(tokType) {
-  if (hasTokenLabel(tokType)) {
-    return tokType.LABEL;
-  } else {
-    return tokType.name;
-  }
-}
-function hasTokenLabel(obj) {
-  return isString(obj.LABEL) && obj.LABEL !== "";
-}
-const PARENT = "parent";
-const CATEGORIES = "categories";
-const LABEL = "label";
-const GROUP = "group";
-const PUSH_MODE = "push_mode";
-const POP_MODE = "pop_mode";
-const LONGER_ALT = "longer_alt";
-const LINE_BREAKS = "line_breaks";
-const START_CHARS_HINT = "start_chars_hint";
-function createToken(config) {
-  return createTokenInternal(config);
-}
-function createTokenInternal(config) {
-  const pattern = config.pattern;
-  const tokenType = {};
-  tokenType.name = config.name;
-  if (!isUndefined(pattern)) {
-    tokenType.PATTERN = pattern;
-  }
-  if (has(config, PARENT)) {
-    throw "The parent property is no longer supported.\nSee: https://github.com/chevrotain/chevrotain/issues/564#issuecomment-349062346 for details.";
-  }
-  if (has(config, CATEGORIES)) {
-    tokenType.CATEGORIES = config[CATEGORIES];
-  }
-  augmentTokenTypes([tokenType]);
-  if (has(config, LABEL)) {
-    tokenType.LABEL = config[LABEL];
-  }
-  if (has(config, GROUP)) {
-    tokenType.GROUP = config[GROUP];
-  }
-  if (has(config, POP_MODE)) {
-    tokenType.POP_MODE = config[POP_MODE];
-  }
-  if (has(config, PUSH_MODE)) {
-    tokenType.PUSH_MODE = config[PUSH_MODE];
-  }
-  if (has(config, LONGER_ALT)) {
-    tokenType.LONGER_ALT = config[LONGER_ALT];
-  }
-  if (has(config, LINE_BREAKS)) {
-    tokenType.LINE_BREAKS = config[LINE_BREAKS];
-  }
-  if (has(config, START_CHARS_HINT)) {
-    tokenType.START_CHARS_HINT = config[START_CHARS_HINT];
-  }
-  return tokenType;
-}
-const EOF = createToken({ name: "EOF", pattern: Lexer.NA });
-augmentTokenTypes([EOF]);
-function createTokenInstance(tokType, image, startOffset, endOffset, startLine, endLine, startColumn, endColumn) {
-  return {
-    image,
-    startOffset,
-    endOffset,
-    startLine,
-    endLine,
-    startColumn,
-    endColumn,
-    tokenTypeIdx: tokType.tokenTypeIdx,
-    tokenType: tokType
-  };
-}
-function tokenMatcher(token, tokType) {
-  return tokenStructuredMatcher(token, tokType);
-}
-export {
-  EOF,
-  createToken,
-  createTokenInstance,
-  hasTokenLabel,
-  tokenLabel,
-  tokenMatcher
-};