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

package/dist/node_modules/.pnpm/@braintree_sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/constants.mjs

@@ -0,0 +1,20 @@
+import { __exports as constants } from "../../../../../../../_virtual/constants.mjs";
+var hasRequiredConstants;
+function requireConstants() {
+  if (hasRequiredConstants) return constants;
+  hasRequiredConstants = 1;
+  Object.defineProperty(constants, "__esModule", { value: true });
+  constants.BLANK_URL = constants.relativeFirstCharacters = constants.whitespaceEscapeCharsRegex = constants.urlSchemeRegex = constants.ctrlCharactersRegex = constants.htmlCtrlEntityRegex = constants.htmlEntitiesRegex = constants.invalidProtocolRegex = void 0;
+  constants.invalidProtocolRegex = /^([^\w]*)(javascript|data|vbscript)/im;
+  constants.htmlEntitiesRegex = /&#(\w+)(^\w|;)?/g;
+  constants.htmlCtrlEntityRegex = /&(newline|tab);/gi;
+  constants.ctrlCharactersRegex = /[\u0000-\u001F\u007F-\u009F\u2000-\u200D\uFEFF]/gim;
+  constants.urlSchemeRegex = /^.+(:|:)/gim;
+  constants.whitespaceEscapeCharsRegex = /(\\|%5[cC])((%(6[eE]|72|74))|[nrt])/g;
+  constants.relativeFirstCharacters = [".", "/"];
+  constants.BLANK_URL = "about:blank";
+  return constants;
+}
+export {
+  requireConstants as __require
+};

package/dist/node_modules/.pnpm/@braintree_sanitize-url@7.1.1/node_modules/@braintree/sanitize-url/dist/index.mjs

@@ -0,0 +1,76 @@
+import { __exports as dist } from "../../../../../../../_virtual/index2.mjs";
+import { __require as requireConstants } from "./constants.mjs";
+var hasRequiredDist;
+function requireDist() {
+  if (hasRequiredDist) return dist;
+  hasRequiredDist = 1;
+  Object.defineProperty(dist, "__esModule", { value: true });
+  dist.sanitizeUrl = void 0;
+  var constants_1 = requireConstants();
+  function isRelativeUrlWithoutProtocol(url) {
+    return constants_1.relativeFirstCharacters.indexOf(url[0]) > -1;
+  }
+  function decodeHtmlCharacters(str) {
+    var removedNullByte = str.replace(constants_1.ctrlCharactersRegex, "");
+    return removedNullByte.replace(constants_1.htmlEntitiesRegex, function(match, dec) {
+      return String.fromCharCode(dec);
+    });
+  }
+  function isValidUrl(url) {
+    return URL.canParse(url);
+  }
+  function decodeURI(uri) {
+    try {
+      return decodeURIComponent(uri);
+    } catch (e) {
+      return uri;
+    }
+  }
+  function sanitizeUrl(url) {
+    if (!url) {
+      return constants_1.BLANK_URL;
+    }
+    var charsToDecode;
+    var decodedUrl = decodeURI(url.trim());
+    do {
+      decodedUrl = decodeHtmlCharacters(decodedUrl).replace(constants_1.htmlCtrlEntityRegex, "").replace(constants_1.ctrlCharactersRegex, "").replace(constants_1.whitespaceEscapeCharsRegex, "").trim();
+      decodedUrl = decodeURI(decodedUrl);
+      charsToDecode = decodedUrl.match(constants_1.ctrlCharactersRegex) || decodedUrl.match(constants_1.htmlEntitiesRegex) || decodedUrl.match(constants_1.htmlCtrlEntityRegex) || decodedUrl.match(constants_1.whitespaceEscapeCharsRegex);
+    } while (charsToDecode && charsToDecode.length > 0);
+    var sanitizedUrl = decodedUrl;
+    if (!sanitizedUrl) {
+      return constants_1.BLANK_URL;
+    }
+    if (isRelativeUrlWithoutProtocol(sanitizedUrl)) {
+      return sanitizedUrl;
+    }
+    var trimmedUrl = sanitizedUrl.trimStart();
+    var urlSchemeParseResults = trimmedUrl.match(constants_1.urlSchemeRegex);
+    if (!urlSchemeParseResults) {
+      return sanitizedUrl;
+    }
+    var urlScheme = urlSchemeParseResults[0].toLowerCase().trim();
+    if (constants_1.invalidProtocolRegex.test(urlScheme)) {
+      return constants_1.BLANK_URL;
+    }
+    var backSanitized = trimmedUrl.replace(/\\/g, "/");
+    if (urlScheme === "mailto:" || urlScheme.includes("://")) {
+      return backSanitized;
+    }
+    if (urlScheme === "http:" || urlScheme === "https:") {
+      if (!isValidUrl(backSanitized)) {
+        return constants_1.BLANK_URL;
+      }
+      var url_1 = new URL(backSanitized);
+      url_1.protocol = url_1.protocol.toLowerCase();
+      url_1.hostname = url_1.hostname.toLowerCase();
+      return url_1.toString();
+    }
+    return backSanitized;
+  }
+  dist.sanitizeUrl = sanitizeUrl;
+  return dist;
+}
+export {
+  requireDist as __require
+};

package/dist/node_modules/.pnpm/@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/helpers.mjs

@@ -0,0 +1,57 @@
+import { some, includes, every } from "lodash-es";
+import { Alternation, NonTerminal, AbstractProduction, Option, RepetitionMandatory, RepetitionMandatoryWithSeparator, RepetitionWithSeparator, Repetition, Terminal, Alternative, Rule } from "./model.mjs";
+function isSequenceProd(prod) {
+  return prod instanceof Alternative || prod instanceof Option || prod instanceof Repetition || prod instanceof RepetitionMandatory || prod instanceof RepetitionMandatoryWithSeparator || prod instanceof RepetitionWithSeparator || prod instanceof Terminal || prod instanceof Rule;
+}
+function isOptionalProd(prod, alreadyVisited = []) {
+  const isDirectlyOptional = prod instanceof Option || prod instanceof Repetition || prod instanceof RepetitionWithSeparator;
+  if (isDirectlyOptional) {
+    return true;
+  }
+  if (prod instanceof Alternation) {
+    return some(prod.definition, (subProd) => {
+      return isOptionalProd(subProd, alreadyVisited);
+    });
+  } else if (prod instanceof NonTerminal && includes(alreadyVisited, prod)) {
+    return false;
+  } else if (prod instanceof AbstractProduction) {
+    if (prod instanceof NonTerminal) {
+      alreadyVisited.push(prod);
+    }
+    return every(prod.definition, (subProd) => {
+      return isOptionalProd(subProd, alreadyVisited);
+    });
+  } else {
+    return false;
+  }
+}
+function isBranchingProd(prod) {
+  return prod instanceof Alternation;
+}
+function getProductionDslName(prod) {
+  if (prod instanceof NonTerminal) {
+    return "SUBRULE";
+  } else if (prod instanceof Option) {
+    return "OPTION";
+  } else if (prod instanceof Alternation) {
+    return "OR";
+  } else if (prod instanceof RepetitionMandatory) {
+    return "AT_LEAST_ONE";
+  } else if (prod instanceof RepetitionMandatoryWithSeparator) {
+    return "AT_LEAST_ONE_SEP";
+  } else if (prod instanceof RepetitionWithSeparator) {
+    return "MANY_SEP";
+  } else if (prod instanceof Repetition) {
+    return "MANY";
+  } else if (prod instanceof Terminal) {
+    return "CONSUME";
+  } else {
+    throw Error("non exhaustive match");
+  }
+}
+export {
+  getProductionDslName,
+  isBranchingProd,
+  isOptionalProd,
+  isSequenceProd
+};

package/dist/node_modules/.pnpm/@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/model.mjs

@@ -0,0 +1,220 @@
+import { assign, pickBy, forEach, map, isString, isRegExp } from "lodash-es";
+function tokenLabel(tokType) {
+  if (hasTokenLabel(tokType)) {
+    return tokType.LABEL;
+  } else {
+    return tokType.name;
+  }
+}
+function hasTokenLabel(obj) {
+  return isString(obj.LABEL) && obj.LABEL !== "";
+}
+class AbstractProduction {
+  get definition() {
+    return this._definition;
+  }
+  set definition(value) {
+    this._definition = value;
+  }
+  constructor(_definition) {
+    this._definition = _definition;
+  }
+  accept(visitor) {
+    visitor.visit(this);
+    forEach(this.definition, (prod) => {
+      prod.accept(visitor);
+    });
+  }
+}
+class NonTerminal extends AbstractProduction {
+  constructor(options) {
+    super([]);
+    this.idx = 1;
+    assign(this, pickBy(options, (v) => v !== void 0));
+  }
+  set definition(definition) {
+  }
+  get definition() {
+    if (this.referencedRule !== void 0) {
+      return this.referencedRule.definition;
+    }
+    return [];
+  }
+  accept(visitor) {
+    visitor.visit(this);
+  }
+}
+class Rule extends AbstractProduction {
+  constructor(options) {
+    super(options.definition);
+    this.orgText = "";
+    assign(this, pickBy(options, (v) => v !== void 0));
+  }
+}
+class Alternative extends AbstractProduction {
+  constructor(options) {
+    super(options.definition);
+    this.ignoreAmbiguities = false;
+    assign(this, pickBy(options, (v) => v !== void 0));
+  }
+}
+class Option extends AbstractProduction {
+  constructor(options) {
+    super(options.definition);
+    this.idx = 1;
+    assign(this, pickBy(options, (v) => v !== void 0));
+  }
+}
+class RepetitionMandatory extends AbstractProduction {
+  constructor(options) {
+    super(options.definition);
+    this.idx = 1;
+    assign(this, pickBy(options, (v) => v !== void 0));
+  }
+}
+class RepetitionMandatoryWithSeparator extends AbstractProduction {
+  constructor(options) {
+    super(options.definition);
+    this.idx = 1;
+    assign(this, pickBy(options, (v) => v !== void 0));
+  }
+}
+class Repetition extends AbstractProduction {
+  constructor(options) {
+    super(options.definition);
+    this.idx = 1;
+    assign(this, pickBy(options, (v) => v !== void 0));
+  }
+}
+class RepetitionWithSeparator extends AbstractProduction {
+  constructor(options) {
+    super(options.definition);
+    this.idx = 1;
+    assign(this, pickBy(options, (v) => v !== void 0));
+  }
+}
+class Alternation extends AbstractProduction {
+  get definition() {
+    return this._definition;
+  }
+  set definition(value) {
+    this._definition = value;
+  }
+  constructor(options) {
+    super(options.definition);
+    this.idx = 1;
+    this.ignoreAmbiguities = false;
+    this.hasPredicates = false;
+    assign(this, pickBy(options, (v) => v !== void 0));
+  }
+}
+class Terminal {
+  constructor(options) {
+    this.idx = 1;
+    assign(this, pickBy(options, (v) => v !== void 0));
+  }
+  accept(visitor) {
+    visitor.visit(this);
+  }
+}
+function serializeGrammar(topRules) {
+  return map(topRules, serializeProduction);
+}
+function serializeProduction(node) {
+  function convertDefinition(definition) {
+    return map(definition, serializeProduction);
+  }
+  if (node instanceof NonTerminal) {
+    const serializedNonTerminal = {
+      type: "NonTerminal",
+      name: node.nonTerminalName,
+      idx: node.idx
+    };
+    if (isString(node.label)) {
+      serializedNonTerminal.label = node.label;
+    }
+    return serializedNonTerminal;
+  } else if (node instanceof Alternative) {
+    return {
+      type: "Alternative",
+      definition: convertDefinition(node.definition)
+    };
+  } else if (node instanceof Option) {
+    return {
+      type: "Option",
+      idx: node.idx,
+      definition: convertDefinition(node.definition)
+    };
+  } else if (node instanceof RepetitionMandatory) {
+    return {
+      type: "RepetitionMandatory",
+      idx: node.idx,
+      definition: convertDefinition(node.definition)
+    };
+  } else if (node instanceof RepetitionMandatoryWithSeparator) {
+    return {
+      type: "RepetitionMandatoryWithSeparator",
+      idx: node.idx,
+      separator: serializeProduction(new Terminal({ terminalType: node.separator })),
+      definition: convertDefinition(node.definition)
+    };
+  } else if (node instanceof RepetitionWithSeparator) {
+    return {
+      type: "RepetitionWithSeparator",
+      idx: node.idx,
+      separator: serializeProduction(new Terminal({ terminalType: node.separator })),
+      definition: convertDefinition(node.definition)
+    };
+  } else if (node instanceof Repetition) {
+    return {
+      type: "Repetition",
+      idx: node.idx,
+      definition: convertDefinition(node.definition)
+    };
+  } else if (node instanceof Alternation) {
+    return {
+      type: "Alternation",
+      idx: node.idx,
+      definition: convertDefinition(node.definition)
+    };
+  } else if (node instanceof Terminal) {
+    const serializedTerminal = {
+      type: "Terminal",
+      name: node.terminalType.name,
+      label: tokenLabel(node.terminalType),
+      idx: node.idx
+    };
+    if (isString(node.label)) {
+      serializedTerminal.terminalLabel = node.label;
+    }
+    const pattern = node.terminalType.PATTERN;
+    if (node.terminalType.PATTERN) {
+      serializedTerminal.pattern = isRegExp(pattern) ? pattern.source : pattern;
+    }
+    return serializedTerminal;
+  } else if (node instanceof Rule) {
+    return {
+      type: "Rule",
+      name: node.name,
+      orgText: node.orgText,
+      definition: convertDefinition(node.definition)
+    };
+  } else {
+    throw Error("non exhaustive match");
+  }
+}
+export {
+  AbstractProduction,
+  Alternation,
+  Alternative,
+  NonTerminal,
+  Option,
+  Repetition,
+  RepetitionMandatory,
+  RepetitionMandatoryWithSeparator,
+  RepetitionWithSeparator,
+  Rule,
+  Terminal,
+  serializeGrammar,
+  serializeProduction
+};

package/dist/node_modules/.pnpm/@chevrotain_gast@11.0.3/node_modules/@chevrotain/gast/lib/src/visitor.mjs

@@ -0,0 +1,64 @@
+import { Rule, Terminal, Alternation, Repetition, RepetitionWithSeparator, RepetitionMandatoryWithSeparator, RepetitionMandatory, Option, Alternative, NonTerminal } from "./model.mjs";
+class GAstVisitor {
+  visit(node) {
+    const nodeAny = node;
+    switch (nodeAny.constructor) {
+      case NonTerminal:
+        return this.visitNonTerminal(nodeAny);
+      case Alternative:
+        return this.visitAlternative(nodeAny);
+      case Option:
+        return this.visitOption(nodeAny);
+      case RepetitionMandatory:
+        return this.visitRepetitionMandatory(nodeAny);
+      case RepetitionMandatoryWithSeparator:
+        return this.visitRepetitionMandatoryWithSeparator(nodeAny);
+      case RepetitionWithSeparator:
+        return this.visitRepetitionWithSeparator(nodeAny);
+      case Repetition:
+        return this.visitRepetition(nodeAny);
+      case Alternation:
+        return this.visitAlternation(nodeAny);
+      case Terminal:
+        return this.visitTerminal(nodeAny);
+      case Rule:
+        return this.visitRule(nodeAny);
+      /* c8 ignore next 2 */
+      default:
+        throw Error("non exhaustive match");
+    }
+  }
+  /* c8 ignore next */
+  visitNonTerminal(node) {
+  }
+  /* c8 ignore next */
+  visitAlternative(node) {
+  }
+  /* c8 ignore next */
+  visitOption(node) {
+  }
+  /* c8 ignore next */
+  visitRepetition(node) {
+  }
+  /* c8 ignore next */
+  visitRepetitionMandatory(node) {
+  }
+  /* c8 ignore next 3 */
+  visitRepetitionMandatoryWithSeparator(node) {
+  }
+  /* c8 ignore next */
+  visitRepetitionWithSeparator(node) {
+  }
+  /* c8 ignore next */
+  visitAlternation(node) {
+  }
+  /* c8 ignore next */
+  visitTerminal(node) {
+  }
+  /* c8 ignore next */
+  visitRule(node) {
+  }
+}
+export {
+  GAstVisitor
+};

package/dist/node_modules/.pnpm/@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.mjs

@@ -0,0 +1,101 @@
+class BaseRegExpVisitor {
+  visitChildren(node) {
+    for (const key in node) {
+      const child = node[key];
+      if (node.hasOwnProperty(key)) {
+        if (child.type !== void 0) {
+          this.visit(child);
+        } else if (Array.isArray(child)) {
+          child.forEach((subChild) => {
+            this.visit(subChild);
+          }, this);
+        }
+      }
+    }
+  }
+  visit(node) {
+    switch (node.type) {
+      case "Pattern":
+        this.visitPattern(node);
+        break;
+      case "Flags":
+        this.visitFlags(node);
+        break;
+      case "Disjunction":
+        this.visitDisjunction(node);
+        break;
+      case "Alternative":
+        this.visitAlternative(node);
+        break;
+      case "StartAnchor":
+        this.visitStartAnchor(node);
+        break;
+      case "EndAnchor":
+        this.visitEndAnchor(node);
+        break;
+      case "WordBoundary":
+        this.visitWordBoundary(node);
+        break;
+      case "NonWordBoundary":
+        this.visitNonWordBoundary(node);
+        break;
+      case "Lookahead":
+        this.visitLookahead(node);
+        break;
+      case "NegativeLookahead":
+        this.visitNegativeLookahead(node);
+        break;
+      case "Character":
+        this.visitCharacter(node);
+        break;
+      case "Set":
+        this.visitSet(node);
+        break;
+      case "Group":
+        this.visitGroup(node);
+        break;
+      case "GroupBackReference":
+        this.visitGroupBackReference(node);
+        break;
+      case "Quantifier":
+        this.visitQuantifier(node);
+        break;
+    }
+    this.visitChildren(node);
+  }
+  visitPattern(node) {
+  }
+  visitFlags(node) {
+  }
+  visitDisjunction(node) {
+  }
+  visitAlternative(node) {
+  }
+  // Assertion
+  visitStartAnchor(node) {
+  }
+  visitEndAnchor(node) {
+  }
+  visitWordBoundary(node) {
+  }
+  visitNonWordBoundary(node) {
+  }
+  visitLookahead(node) {
+  }
+  visitNegativeLookahead(node) {
+  }
+  // atoms
+  visitCharacter(node) {
+  }
+  visitSet(node) {
+  }
+  visitGroup(node) {
+  }
+  visitGroupBackReference(node) {
+  }
+  visitQuantifier(node) {
+  }
+}
+export {
+  BaseRegExpVisitor
+};

package/dist/node_modules/.pnpm/@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.mjs

@@ -0,0 +1,45 @@
+import { cc } from "./utils.mjs";
+const digitsCharCodes = [];
+for (let i = cc("0"); i <= cc("9"); i++) {
+  digitsCharCodes.push(i);
+}
+const wordCharCodes = [cc("_")].concat(digitsCharCodes);
+for (let i = cc("a"); i <= cc("z"); i++) {
+  wordCharCodes.push(i);
+}
+for (let i = cc("A"); i <= cc("Z"); i++) {
+  wordCharCodes.push(i);
+}
+const whitespaceCodes = [
+  cc(" "),
+  cc("\f"),
+  cc("\n"),
+  cc("\r"),
+  cc("	"),
+  cc("\v"),
+  cc("	"),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc(" "),
+  cc("\u2028"),
+  cc("\u2029"),
+  cc(" "),
+  cc(" "),
+  cc("　"),
+  cc("\uFEFF")
+];
+export {
+  digitsCharCodes,
+  whitespaceCodes,
+  wordCharCodes
+};