@clear-capabilities/agentic-security-scanner 0.149.0 → 0.149.4

package/vendor/java-parser/node_modules/chevrotain/README.md

@@ -0,0 +1,20 @@
+# Chevrotain
+
+For details see:
+
+- Chevrotain's [website](https://chevrotain.io/docs/).
+- Chevrotain's root [README](https://github.com/chevrotain/chevrotain).
+
+## Install
+
+Using npm:
+
+```sh
+npm install chevrotain
+```
+
+or using yarn:
+
+```sh
+yarn add chevrotain
+```

package/vendor/java-parser/node_modules/chevrotain/chevrotain.d.ts

@@ -0,0 +1,2 @@
+export * from "@chevrotain/types";
+export as namespace chevrotain;

package/vendor/java-parser/node_modules/chevrotain/diagrams/README.md

@@ -0,0 +1 @@
+See [online docs](https://chevrotain.io/docs/guide/generating_syntax_diagrams.html).

package/vendor/java-parser/node_modules/chevrotain/diagrams/diagrams.css

@@ -0,0 +1,85 @@
+svg.railroad-diagram path {
+    stroke-width: 3;
+    stroke: black;
+    fill: rgba(0, 0, 0, 0);
+}
+
+svg.railroad-diagram text {
+    font: bold 14px monospace;
+    text-anchor: middle;
+}
+
+svg.railroad-diagram text.label {
+    text-anchor: start;
+}
+
+svg.railroad-diagram text.comment {
+    font: italic 12px monospace;
+}
+
+svg.railroad-diagram g.non-terminal rect {
+    fill: hsl(223, 100%, 83%);
+}
+
+svg.railroad-diagram rect {
+    stroke-width: 3;
+    stroke: black;
+    fill: hsl(190, 100%, 83%);
+}
+
+.diagramHeader {
+    display: inline-block;
+    -webkit-touch-callout: default;
+    -webkit-user-select: text;
+    -khtml-user-select: text;
+    -moz-user-select: text;
+    -ms-user-select: text;
+    user-select: text;
+    font-weight: bold;
+    font-family: monospace;
+    font-size: 18px;
+    margin-bottom: -8px;
+    text-align: center;
+}
+
+.diagramHeaderDef {
+    background-color: lightgreen;
+}
+
+svg.railroad-diagram text {
+    -webkit-touch-callout: default;
+    -webkit-user-select: text;
+    -khtml-user-select: text;
+    -moz-user-select: text;
+    -ms-user-select: text;
+    user-select: text;
+}
+
+svg.railroad-diagram g.non-terminal rect.diagramRectUsage {
+    color: green;
+    fill: yellow;
+    stroke: 5;
+}
+
+svg.railroad-diagram g.terminal rect.diagramRectUsage {
+    color: green;
+    fill: yellow;
+    stroke: 5;
+}
+
+div {
+    -webkit-touch-callout: none;
+    -webkit-user-select: none;
+    -khtml-user-select: none;
+    -moz-user-select: none;
+    -ms-user-select: none;
+    user-select: none;
+}
+
+svg {
+    width: 100%;
+}
+
+svg.railroad-diagram g.non-terminal text {
+    cursor: pointer;
+}

package/vendor/java-parser/node_modules/chevrotain/diagrams/src/diagrams_behavior.js

@@ -0,0 +1,223 @@
+(function (root, factory) {
+  if (typeof define === "function" && define.amd) {
+    // AMD. Register as an anonymous module.
+    define([], factory);
+  } else if (typeof module === "object" && module.exports) {
+    // Node. Does not work with strict CommonJS, but
+    // only CommonJS-like environments that support module.exports,
+    // like Node.
+    module.exports = factory();
+  } else {
+    // Browser globals (root is window)
+    root.diagrams_behavior = factory();
+  }
+})(this, function () {
+  /**
+   * @param [scrollingEnabled=true] {boolean} - Is the scrolling from a non-terminal usage to it's definition
+   * enabled. it is enabled by default, but this flow is not relevant in all use cases (playground) and thus
+   * it is parametrized.
+   */
+  function initDiagramsBehavior(scrollingEnabled) {
+    if (scrollingEnabled === undefined) {
+      scrollingEnabled = true;
+    }
+
+    var diagramHeaders = toArr(
+      document.getElementsByClassName("diagramHeader"),
+    );
+    diagramHeaders.forEach(function (header) {
+      header.addEventListener(
+        "mouseover",
+        toggleNonTerminalUsageAndDef_fromHeader,
+      );
+      header.addEventListener(
+        "mouseout",
+        toggleNonTerminalUsageAndDef_fromHeader,
+      );
+    });
+
+    var noneTerminals = toArr(document.getElementsByClassName("non-terminal"));
+    var noneTerminalsText = findDomChildrenByTagName(noneTerminals, "text");
+    noneTerminalsText.forEach(function (nonTerminal) {
+      nonTerminal.addEventListener(
+        "mouseover",
+        toggleNonTerminalUsageAndDef_fromNoneTerminal,
+      );
+      nonTerminal.addEventListener(
+        "mouseout",
+        toggleNonTerminalUsageAndDef_fromNoneTerminal,
+      );
+
+      if (scrollingEnabled) {
+        nonTerminal.addEventListener("click", jumpToNoneTerminalDef);
+      }
+    });
+
+    var terminals = toArr(document.getElementsByClassName("terminal"));
+    var terminalsText = findDomChildrenByTagName(terminals, "text");
+    terminalsText.forEach(function (terminal) {
+      terminal.addEventListener("mouseover", toggleTerminalUsage);
+      terminal.addEventListener("mouseout", toggleTerminalUsage);
+    });
+  }
+
+  function toggleTerminalUsage(mouseEvent) {
+    var terminalName = mouseEvent.target.getAttribute("label");
+    var rects = getUsageSvgRect(terminalName, "terminal", "label");
+    toggleClassForNodes(rects, "diagramRectUsage");
+  }
+
+  function toggleNonTerminalUsageAndDef_fromNoneTerminal(mouseEvent) {
+    var rectsHeaderAndRuleName = getUsageRectAndDefHeader(mouseEvent.target);
+    toggleClassForNodes(rectsHeaderAndRuleName.rects, "diagramRectUsage");
+    toggleClass(rectsHeaderAndRuleName.header, "diagramHeaderDef");
+  }
+
+  function jumpToNoneTerminalDef(mouseEvent) {
+    var header = findHeader(mouseEvent.target.getAttribute("rulename"));
+    scrollToY(header.offsetTop, 666, "easeInOutQuint");
+  }
+
+  function toggleNonTerminalUsageAndDef_fromHeader(mouseEvent) {
+    toggleClass(mouseEvent.target, "diagramHeaderDef");
+    // this does not work on an svg DOM element so its ok to use innerHTML.
+    var definitionName = mouseEvent.target.innerHTML;
+    var rects = getUsageSvgRect(definitionName, "non-terminal", "rulename");
+    toggleClassForNodes(rects, "diagramRectUsage");
+  }
+
+  function getUsageSvgRect(definitionName, className, attributeName) {
+    var classDomElements = toArr(document.getElementsByClassName(className));
+    var rects = findDomChildrenByTagName(classDomElements, "rect");
+    return rects.filter(function (currRect) {
+      var textNode = currRect.parentNode.getElementsByTagName("text")[0];
+      return textNode.getAttribute(attributeName) === definitionName;
+    });
+  }
+
+  function findHeader(headerName) {
+    var headers = toArr(document.getElementsByClassName("diagramHeader"));
+    var header = headers.find(function (currHeader) {
+      // this works on H2 dom elements and not SVG elements so innerHTML usage is safe.
+      return currHeader.innerHTML === headerName;
+    });
+    return header;
+  }
+
+  function getUsageRectAndDefHeader(target) {
+    var headerName = target.getAttribute("rulename");
+    var rects = getUsageSvgRect(headerName, "non-terminal", "rulename");
+    var header = findHeader(headerName);
+    return {
+      rects: rects,
+      header: header,
+      ruleName: headerName,
+    };
+  }
+
+  // utils
+
+  // IE 10/11 does not support this on svg elements.
+  // I'm uncertain I really care... :)
+  // https://developer.mozilla.org/en-US/docs/Web/API/Element/classList
+  function toggleClass(domNode, className) {
+    if (domNode.classList.contains(className)) {
+      domNode.classList.remove(className);
+    } else {
+      domNode.classList.add(className);
+    }
+  }
+
+  function toggleClassForNodes(domNodes, className) {
+    domNodes.forEach(function (currDomNode) {
+      toggleClass(currDomNode, className);
+    });
+  }
+
+  function toArr(htmlCollection) {
+    return Array.prototype.slice.call(htmlCollection);
+  }
+
+  // first add raf shim
+  // http://www.paulirish.com/2011/requestanimationframe-for-smart-animating/
+  var requestAnimFrame = (function () {
+    return (
+      window.requestAnimationFrame ||
+      window.webkitRequestAnimationFrame ||
+      window.mozRequestAnimationFrame ||
+      function (callback) {
+        window.setTimeout(callback, 1000 / 60);
+      }
+    );
+  })();
+
+  // https://stackoverflow.com/questions/8917921/cross-browser-javascript-not-jquery-scroll-to-top-animation
+  function scrollToY(scrollTargetY, speed, easing) {
+    // scrollTargetY: the target scrollY property of the window
+    // speed: time in pixels per second
+    // easing: easing equation to use
+
+    var scrollY = window.scrollY,
+      scrollTargetY = scrollTargetY || 0,
+      speed = speed || 2000,
+      easing = easing || "easeOutSine",
+      currentTime = 0;
+
+    // min time .1, max time .8 seconds
+    var time = Math.max(
+      0.1,
+      Math.min(Math.abs(scrollY - scrollTargetY) / speed, 0.8),
+    );
+
+    // easing equations from https://github.com/danro/easing-js/blob/master/easing.js
+    var PI_D2 = Math.PI / 2,
+      easingEquations = {
+        easeOutSine: function (pos) {
+          return Math.sin(pos * (Math.PI / 2));
+        },
+        easeInOutSine: function (pos) {
+          return -0.5 * (Math.cos(Math.PI * pos) - 1);
+        },
+        easeInOutQuint: function (pos) {
+          if ((pos /= 0.5) < 1) {
+            return 0.5 * Math.pow(pos, 5);
+          }
+          return 0.5 * (Math.pow(pos - 2, 5) + 2);
+        },
+      };
+
+    // add animation loop
+    function tick() {
+      currentTime += 1 / 60;
+
+      var p = currentTime / time;
+      var t = easingEquations[easing](p);
+
+      if (p < 1) {
+        requestAnimFrame(tick);
+
+        window.scrollTo(0, scrollY + (scrollTargetY - scrollY) * t);
+      } else {
+        window.scrollTo(0, scrollTargetY);
+      }
+    }
+
+    // call it once to get started
+    tick();
+  }
+
+  function findDomChildrenByTagName(domElements, tagName) {
+    var elemsFound = [];
+    domElements.forEach(function (currDomNode) {
+      toArr(currDomNode.children).forEach(function (currChild) {
+        if (currChild.tagName === tagName) {
+          elemsFound.push(currChild);
+        }
+      });
+    });
+    return elemsFound;
+  }
+  return {
+    initDiagramsBehavior: initDiagramsBehavior,
+  };
+});

package/vendor/java-parser/node_modules/chevrotain/diagrams/src/diagrams_builder.js

@@ -0,0 +1,204 @@
+(function (root, factory) {
+  if (typeof define === "function" && define.amd) {
+    // AMD. Register as an anonymous module.
+    // TODO: remove dependency to Chevrotain
+    define(["../vendor/railroad-diagrams"], factory);
+  } else if (typeof module === "object" && module.exports) {
+    // Node. Does not work with strict CommonJS, but
+    // only CommonJS-like environments that support module.exports,
+    // like Node.
+    // TODO: remove dependency to Chevrotain
+    module.exports = factory(require("../vendor/railroad-diagrams"));
+  } else {
+    // Browser globals (root is window)
+    root.diagrams_builder = factory(root.railroad);
+  }
+})(this, function (railroad) {
+  var Diagram = railroad.Diagram;
+  var Sequence = railroad.Sequence;
+  var Choice = railroad.Choice;
+  var Optional = railroad.Optional;
+  var OneOrMore = railroad.OneOrMore;
+  var ZeroOrMore = railroad.ZeroOrMore;
+  // var Terminal = railroad.Terminal
+  var NonTerminal = railroad.NonTerminal;
+
+  /**
+   * @param {chevrotain.gast.ISerializedGast} topRules
+   *
+   * @returns {string} - The htmlText that will render the diagrams
+   */
+  function buildSyntaxDiagramsText(topRules) {
+    var diagramsHtml = "";
+
+    topRules.forEach(function (production) {
+      var currDiagramHtml = convertProductionToDiagram(
+        production,
+        production.name,
+      );
+      diagramsHtml +=
+        '<h2 class="diagramHeader">' +
+        production.name +
+        "</h2>" +
+        currDiagramHtml;
+    });
+
+    return diagramsHtml;
+  }
+
+  function definitionsToSubDiagrams(definitions, topRuleName) {
+    var subDiagrams = definitions.map(function (subProd) {
+      return convertProductionToDiagram(subProd, topRuleName);
+    });
+    return subDiagrams;
+  }
+
+  /**
+   * @param {chevrotain.gast.ISerializedTerminal} prod
+   * @param {string} topRuleName
+   * @param {string} dslRuleName
+   *
+   * @return {RailRoadDiagram.Terminal}
+   */
+  function createTerminalFromSerializedGast(prod, topRuleName, dslRuleName) {
+    // PATTERN static property will not exist when using custom lexers (hand built or other lexer generators)
+    var toolTipTitle = undefined;
+    // avoid trying to use a custom token pattern as the title.
+    if (
+      typeof prod.pattern === "string" ||
+      Object.prototype.toString.call(prod.pattern) === "[object RegExp]"
+    ) {
+      toolTipTitle = prod.pattern;
+    }
+
+    return railroad.Terminal(
+      prod.label,
+      undefined,
+      toolTipTitle,
+      prod.occurrenceInParent,
+      topRuleName,
+      dslRuleName,
+      prod.name,
+    );
+  }
+
+  /**
+   * @param prod
+   * @param topRuleName
+   *
+   * Converts a single Chevrotain Grammar production to a RailRoad Diagram.
+   * This is also exported to allow custom logic in the creation of the diagrams.
+   * @returns {*}
+   */
+  function convertProductionToDiagram(prod, topRuleName) {
+    if (prod.type === "NonTerminal") {
+      // must handle NonTerminal separately from the other AbstractProductions as we do not want to expand the subDefinition
+      // of a reference and cause infinite loops
+      return NonTerminal(
+        getNonTerminalName(prod),
+        undefined,
+        prod.occurrenceInParent,
+        topRuleName,
+      );
+    } else if (prod.type !== "Terminal") {
+      var subDiagrams = definitionsToSubDiagrams(prod.definition, topRuleName);
+      if (prod.type === "Rule") {
+        return Diagram.apply(this, subDiagrams);
+      } else if (prod.type === "Alternative") {
+        return Sequence.apply(this, subDiagrams);
+      } else if (prod.type === "Option") {
+        if (subDiagrams.length > 1) {
+          return Optional(Sequence.apply(this, subDiagrams));
+        } else if (subDiagrams.length === 1) {
+          return Optional(subDiagrams[0]);
+        } else {
+          throw Error("Empty Optional production, OOPS!");
+        }
+      } else if (prod.type === "Repetition") {
+        if (subDiagrams.length > 1) {
+          return ZeroOrMore(Sequence.apply(this, subDiagrams));
+        } else if (subDiagrams.length === 1) {
+          return ZeroOrMore(subDiagrams[0]);
+        } else {
+          throw Error("Empty Optional production, OOPS!");
+        }
+      } else if (prod.type === "Alternation") {
+        // todo: what does the first argument of choice (the index 0 means?)
+        return Choice.apply(this, [0].concat(subDiagrams));
+      } else if (prod.type === "RepetitionMandatory") {
+        if (subDiagrams.length > 1) {
+          return OneOrMore(Sequence.apply(this, subDiagrams));
+        } else if (subDiagrams.length === 1) {
+          return OneOrMore(subDiagrams[0]);
+        } else {
+          throw Error("Empty Optional production, OOPS!");
+        }
+      } else if (prod.type === "RepetitionWithSeparator") {
+        if (subDiagrams.length > 0) {
+          // MANY_SEP(separator, definition) === (definition (separator definition)*)?
+          return Optional(
+            Sequence.apply(
+              this,
+              subDiagrams.concat([
+                ZeroOrMore(
+                  Sequence.apply(
+                    this,
+                    [
+                      createTerminalFromSerializedGast(
+                        prod.separator,
+                        topRuleName,
+                        "many_sep",
+                      ),
+                    ].concat(subDiagrams),
+                  ),
+                ),
+              ]),
+            ),
+          );
+        } else {
+          throw Error("Empty Optional production, OOPS!");
+        }
+      } else if (prod.type === "RepetitionMandatoryWithSeparator") {
+        if (subDiagrams.length > 0) {
+          // AT_LEAST_ONE_SEP(separator, definition) === definition (separator definition)*
+          return Sequence.apply(
+            this,
+            subDiagrams.concat([
+              ZeroOrMore(
+                Sequence.apply(
+                  this,
+                  [
+                    createTerminalFromSerializedGast(
+                      prod.separator,
+                      topRuleName,
+                      "at_least_one_sep",
+                    ),
+                  ].concat(subDiagrams),
+                ),
+              ),
+            ]),
+          );
+        } else {
+          throw Error("Empty Optional production, OOPS!");
+        }
+      }
+    } else if (prod.type === "Terminal") {
+      return createTerminalFromSerializedGast(prod, topRuleName, "consume");
+    } else {
+      throw Error("non exhaustive match");
+    }
+  }
+
+  function getNonTerminalName(prod) {
+    if (prod.nonTerminalName !== undefined) {
+      return prod.nonTerminalName;
+    } else {
+      return prod.name;
+    }
+  }
+
+  return {
+    buildSyntaxDiagramsText: buildSyntaxDiagramsText,
+    convertProductionToDiagram: convertProductionToDiagram,
+  };
+});

package/vendor/java-parser/node_modules/chevrotain/diagrams/src/diagrams_serializer.js

@@ -0,0 +1,20 @@
+/**
+ * @param {string} targetFilePath - The path and file name to serialize to.
+ * @param {string} varName - The name of the global variable to expose the serialized contents/
+ * @param {chevrotain.Parser} parserInstance - A parser instance whose grammar will be serialized.
+ */
+function serializeGrammarToFile(targetFilePath, varName, parserInstance) {
+  var fs = require("fs");
+  var serializedGrammar = parserInstance.getSerializedGastProductions();
+  var serializedGrammarText = JSON.stringify(serializedGrammar, null, "\t");
+
+  // generated a JavaScript file which exports the serialized grammar on the global scope (Window)
+  fs.writeFileSync(
+    targetFilePath,
+    "var " + varName + " = " + serializedGrammarText,
+  );
+}
+
+module.exports = {
+  serializeGrammarToFile: serializeGrammarToFile,
+};

package/vendor/java-parser/node_modules/chevrotain/diagrams/src/main.js

@@ -0,0 +1,30 @@
+(function (root, factory) {
+  if (typeof define === "function" && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(["./diagrams_builder", "./diagrams_behavior"], factory);
+  } else if (typeof module === "object" && module.exports) {
+    // Node. Does not work with strict CommonJS, but
+    // only CommonJS-like environments that support module.exports,
+    // like Node.
+    module.exports = factory(
+      require("./diagrams_builder"),
+      require("./diagrams_behavior"),
+    );
+  } else {
+    // Browser globals (root is window)
+    root.main = factory(root.diagrams_builder, root.diagrams_behavior);
+  }
+})(this, function (builder, behavior) {
+  return {
+    drawDiagramsFromParserInstance: function (parserInstanceToDraw, targetDiv) {
+      var topRules = parserInstanceToDraw.getSerializedGastProductions();
+      targetDiv.innerHTML = builder.buildSyntaxDiagramsText(topRules);
+      behavior.initDiagramsBehavior();
+    },
+
+    drawDiagramsFromSerializedGrammar: function (serializedGrammar, targetDiv) {
+      targetDiv.innerHTML = builder.buildSyntaxDiagramsText(serializedGrammar);
+      behavior.initDiagramsBehavior();
+    },
+  };
+});