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

package/vendor/java-parser/node_modules/chevrotain/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "chevrotain",
+  "version": "11.0.3",
+  "description": "Chevrotain is a high performance fault tolerant javascript parsing DSL for building recursive decent parsers",
+  "keywords": [
+    "parser",
+    "syntax",
+    "lexical",
+    "analysis",
+    "grammar",
+    "lexer",
+    "tokenizer",
+    "generator",
+    "compiler",
+    "fault",
+    "tolerant"
+  ],
+  "bugs": {
+    "url": "https://github.com/Chevrotain/chevrotain/issues"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Shahar Soel"
+  },
+  "type": "module",
+  "types": "./chevrotain.d.ts",
+  "exports": {
+    ".": {
+      "import": "./lib/src/api.js",
+      "types": "./chevrotain.d.ts"
+    }
+  },
+  "files": [
+    "chevrotain.d.ts",
+    "lib/chevrotain.min.mjs",
+    "lib/chevrotain.mjs",
+    "lib/src/**/*.js",
+    "lib/src/**/*.map",
+    "src/**/*.ts",
+    "diagrams/**/*.*",
+    "BREAKING_CHANGES.md",
+    "CHANGELOG.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/Chevrotain/chevrotain.git"
+  },
+  "homepage": "https://chevrotain.io/docs/",
+  "scripts": {
+    "---------- CI FLOWS --------": "",
+    "ci": "pnpm run build test",
+    "build": "npm-run-all clean compile bundle",
+    "test": "npm-run-all coverage",
+    "version": "node ./scripts/version-update.js",
+    "---------- DEV FLOWS --------": "",
+    "watch": "tsc -w",
+    "unit-tests": "mocha --enable-source-maps",
+    "quick-build": "tsc && npm-run-all run bundle",
+    "---------- BUILD STEPS --------": "",
+    "clean": "shx rm -rf coverage dev lib temp",
+    "compile": "tsc",
+    "compile:watch": "tsc -w",
+    "coverage": "c8 mocha --enable-source-maps",
+    "---------- BUNDLING --------": "",
+    "bundle": "npm-run-all bundle:**",
+    "bundle:esm:regular": "esbuild ./lib/src/api.js --bundle --sourcemap --format=esm --outfile=lib/chevrotain.mjs",
+    "bundle:esm:min": "esbuild ./lib/src/api.js --bundle --minify --format=esm --sourcemap --outfile=lib/chevrotain.min.mjs"
+  },
+  "dependencies": {
+    "@chevrotain/cst-dts-gen": "11.0.3",
+    "@chevrotain/gast": "11.0.3",
+    "@chevrotain/regexp-to-ast": "11.0.3",
+    "@chevrotain/types": "11.0.3",
+    "@chevrotain/utils": "11.0.3",
+    "lodash-es": "4.17.21"
+  },
+  "devDependencies": {
+    "@types/jsdom": "21.1.1",
+    "@types/lodash-es": "4.17.7",
+    "@types/sinon": "10.0.15",
+    "@types/sinon-chai": "3.2.9",
+    "error-stack-parser": "2.1.4",
+    "esbuild": "0.18.11",
+    "gen-esm-wrapper": "1.1.3",
+    "gitty": "3.7.2",
+    "jsdom": "22.1.0",
+    "jsonfile": "6.1.0",
+    "require-from-string": "2.0.2",
+    "sinon": "15.2.0",
+    "sinon-chai": "3.7.0",
+    "xregexp": "5.1.1"
+  },
+  "gitHead": "ac5806631779035c2c1955744a47d8ed4f25a175"
+}

package/vendor/java-parser/node_modules/chevrotain/src/api.ts

@@ -0,0 +1,87 @@
+/* istanbul ignore file - tricky to import some things from this module during testing */
+
+// semantic version
+export { VERSION } from "./version.js";
+
+export {
+  CstParser,
+  EmbeddedActionsParser,
+  ParserDefinitionErrorType,
+  EMPTY_ALT,
+} from "./parse/parser/parser.js";
+
+export { Lexer, LexerDefinitionErrorType } from "./scan/lexer_public.js";
+
+// Tokens utilities
+export {
+  createToken,
+  createTokenInstance,
+  EOF,
+  tokenLabel,
+  tokenMatcher,
+  tokenName,
+} from "./scan/tokens_public.js";
+
+// Lookahead
+
+export { getLookaheadPaths } from "./parse/grammar/lookahead.js";
+
+export { LLkLookaheadStrategy } from "./parse/grammar/llk_lookahead.js";
+
+// Other Utilities
+
+export { defaultParserErrorProvider } from "./parse/errors_public.js";
+
+export {
+  EarlyExitException,
+  isRecognitionException,
+  MismatchedTokenException,
+  NotAllInputParsedException,
+  NoViableAltException,
+} from "./parse/exceptions_public.js";
+
+export { defaultLexerErrorProvider } from "./scan/lexer_errors_public.js";
+
+// grammar reflection API
+export {
+  Alternation,
+  Alternative,
+  NonTerminal,
+  Option,
+  Repetition,
+  RepetitionMandatory,
+  RepetitionMandatoryWithSeparator,
+  RepetitionWithSeparator,
+  Rule,
+  Terminal,
+} from "@chevrotain/gast";
+
+// GAST Utilities
+
+export {
+  serializeGrammar,
+  serializeProduction,
+  GAstVisitor,
+} from "@chevrotain/gast";
+
+export { generateCstDts } from "@chevrotain/cst-dts-gen";
+
+/* istanbul ignore next */
+export function clearCache() {
+  console.warn(
+    "The clearCache function was 'soft' removed from the Chevrotain API." +
+      "\n\t It performs no action other than printing this message." +
+      "\n\t Please avoid using it as it will be completely removed in the future",
+  );
+}
+
+export { createSyntaxDiagramsCode } from "./diagrams/render_public.js";
+
+export class Parser {
+  constructor() {
+    throw new Error(
+      "The Parser class has been deprecated, use CstParser or EmbeddedActionsParser instead.\t\n" +
+        "See: https://chevrotain.io/docs/changes/BREAKING_CHANGES.html#_7-0-0",
+    );
+  }
+}

package/vendor/java-parser/node_modules/chevrotain/src/diagrams/render_public.ts

@@ -0,0 +1,53 @@
+import { VERSION } from "../version.js";
+import { ISerializedGast } from "@chevrotain/types";
+
+export function createSyntaxDiagramsCode(
+  grammar: ISerializedGast[],
+  {
+    resourceBase = `https://unpkg.com/chevrotain@${VERSION}/diagrams/`,
+    css = `https://unpkg.com/chevrotain@${VERSION}/diagrams/diagrams.css`,
+  }: {
+    resourceBase?: string;
+    css?: string;
+  } = {},
+) {
+  const header = `
+<!-- This is a generated file -->
+<!DOCTYPE html>
+<meta charset="utf-8">
+<style>
+  body {
+    background-color: hsl(30, 20%, 95%)
+  }
+</style>
+
+`;
+  const cssHtml = `
+<link rel='stylesheet' href='${css}'>
+`;
+
+  const scripts = `
+<script src='${resourceBase}vendor/railroad-diagrams.js'></script>
+<script src='${resourceBase}src/diagrams_builder.js'></script>
+<script src='${resourceBase}src/diagrams_behavior.js'></script>
+<script src='${resourceBase}src/main.js'></script>
+`;
+  const diagramsDiv = `
+<div id="diagrams" align="center"></div>    
+`;
+  const serializedGrammar = `
+<script>
+    window.serializedGrammar = ${JSON.stringify(grammar, null, "  ")};
+</script>
+`;
+
+  const initLogic = `
+<script>
+    var diagramsDiv = document.getElementById("diagrams");
+    main.drawDiagramsFromSerializedGrammar(serializedGrammar, diagramsDiv);
+</script>
+`;
+  return (
+    header + cssHtml + scripts + diagramsDiv + serializedGrammar + initLogic
+  );
+}

package/vendor/java-parser/node_modules/chevrotain/src/lang/lang_extensions.ts

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

package/vendor/java-parser/node_modules/chevrotain/src/parse/constants.ts

@@ -0,0 +1,2 @@
+// TODO: can this be removed? where is it used?
+export const IN = "_~IN~_";

package/vendor/java-parser/node_modules/chevrotain/src/parse/cst/cst.ts

@@ -0,0 +1,87 @@
+import { CstNode, CstNodeLocation, IToken } from "@chevrotain/types";
+
+/**
+ * This nodeLocation tracking is not efficient and should only be used
+ * when error recovery is enabled or the Token Vector contains virtual Tokens
+ * (e.g, Python Indent/Outdent)
+ * As it executes the calculation for every single terminal/nonTerminal
+ * and does not rely on the fact the token vector is **sorted**
+ */
+export function setNodeLocationOnlyOffset(
+  currNodeLocation: CstNodeLocation,
+  newLocationInfo: Required<Pick<IToken, "startOffset" | "endOffset">>,
+): void {
+  // First (valid) update for this cst node
+  if (isNaN(currNodeLocation.startOffset) === true) {
+    // assumption1: Token location information is either NaN or a valid number
+    // assumption2: Token location information is fully valid if it exist
+    // (both start/end offsets exist and are numbers).
+    currNodeLocation.startOffset = newLocationInfo.startOffset;
+    currNodeLocation.endOffset = newLocationInfo.endOffset;
+  }
+  // Once the startOffset has been updated with a valid number it should never receive
+  // any farther updates as the Token vector is sorted.
+  // We still have to check this this condition for every new possible location info
+  // because with error recovery enabled we may encounter invalid tokens (NaN location props)
+  else if (currNodeLocation.endOffset! < newLocationInfo.endOffset === true) {
+    currNodeLocation.endOffset = newLocationInfo.endOffset;
+  }
+}
+
+/**
+ * This nodeLocation tracking is not efficient and should only be used
+ * when error recovery is enabled or the Token Vector contains virtual Tokens
+ * (e.g, Python Indent/Outdent)
+ * As it executes the calculation for every single terminal/nonTerminal
+ * and does not rely on the fact the token vector is **sorted**
+ */
+export function setNodeLocationFull(
+  currNodeLocation: CstNodeLocation,
+  newLocationInfo: CstNodeLocation,
+): void {
+  // First (valid) update for this cst node
+  if (isNaN(currNodeLocation.startOffset) === true) {
+    // assumption1: Token location information is either NaN or a valid number
+    // assumption2: Token location information is fully valid if it exist
+    // (all start/end props exist and are numbers).
+    currNodeLocation.startOffset = newLocationInfo.startOffset;
+    currNodeLocation.startColumn = newLocationInfo.startColumn;
+    currNodeLocation.startLine = newLocationInfo.startLine;
+    currNodeLocation.endOffset = newLocationInfo.endOffset;
+    currNodeLocation.endColumn = newLocationInfo.endColumn;
+    currNodeLocation.endLine = newLocationInfo.endLine;
+  }
+  // Once the start props has been updated with a valid number it should never receive
+  // any farther updates as the Token vector is sorted.
+  // We still have to check this this condition for every new possible location info
+  // because with error recovery enabled we may encounter invalid tokens (NaN location props)
+  else if (currNodeLocation.endOffset! < newLocationInfo.endOffset! === true) {
+    currNodeLocation.endOffset = newLocationInfo.endOffset;
+    currNodeLocation.endColumn = newLocationInfo.endColumn;
+    currNodeLocation.endLine = newLocationInfo.endLine;
+  }
+}
+
+export function addTerminalToCst(
+  node: CstNode,
+  token: IToken,
+  tokenTypeName: string,
+): void {
+  if (node.children[tokenTypeName] === undefined) {
+    node.children[tokenTypeName] = [token];
+  } else {
+    node.children[tokenTypeName].push(token);
+  }
+}
+
+export function addNoneTerminalToCst(
+  node: CstNode,
+  ruleName: string,
+  ruleResult: any,
+): void {
+  if (node.children[ruleName] === undefined) {
+    node.children[ruleName] = [ruleResult];
+  } else {
+    node.children[ruleName].push(ruleResult);
+  }
+}

package/vendor/java-parser/node_modules/chevrotain/src/parse/cst/cst_visitor.ts

@@ -0,0 +1,153 @@
+import {
+  compact,
+  filter,
+  forEach,
+  isArray,
+  isEmpty,
+  isFunction,
+  isUndefined,
+  keys,
+  map,
+} from "lodash-es";
+import { defineNameProp } from "../../lang/lang_extensions.js";
+import { CstNode, ICstVisitor } from "@chevrotain/types";
+
+export function defaultVisit<IN>(ctx: any, param: IN): void {
+  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: any = currChildArray[j];
+      // distinction between Tokens Children and CstNode children
+      if (currChild.tokenTypeIdx === undefined) {
+        this[currChild.name](currChild.children, param);
+      }
+    }
+  }
+  // defaultVisit does not support generic out param
+}
+
+export function createBaseSemanticVisitorConstructor(
+  grammarName: string,
+  ruleNames: string[],
+): {
+  new (...args: any[]): ICstVisitor<any, any>;
+} {
+  const derivedConstructor: any = function () {};
+
+  // can be overwritten according to:
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/
+  // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname
+  defineNameProp(derivedConstructor, grammarName + "BaseSemantics");
+
+  const semanticProto = {
+    visit: function (cstNode: CstNode | CstNode[], param: any) {
+      // enables writing more concise visitor methods when CstNode has only a single child
+      if (isArray(cstNode)) {
+        // A CST Node's children dictionary can never have empty arrays as values
+        // If a key is defined there will be at least one element in the corresponding value array.
+        cstNode = cstNode[0];
+      }
+
+      // enables passing optional CstNodes concisely.
+      if (isUndefined(cstNode)) {
+        return undefined;
+      }
+
+      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}>:\n\t` +
+            `${errorMessages.join("\n\n").replace(/\n/g, "\n\t")}`,
+        );
+      }
+    },
+  };
+
+  derivedConstructor.prototype = semanticProto;
+  derivedConstructor.prototype.constructor = derivedConstructor;
+
+  derivedConstructor._RULE_NAMES = ruleNames;
+
+  return derivedConstructor;
+}
+
+export function createBaseVisitorConstructorWithDefaults(
+  grammarName: string,
+  ruleNames: string[],
+  baseConstructor: Function,
+): {
+  new (...args: any[]): ICstVisitor<any, any>;
+} {
+  const derivedConstructor: any = function () {};
+
+  // can be overwritten according to:
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/
+  // name?redirectlocale=en-US&redirectslug=JavaScript%2FReference%2FGlobal_Objects%2FFunction%2Fname
+  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;
+}
+
+export enum CstVisitorDefinitionError {
+  REDUNDANT_METHOD,
+  MISSING_METHOD,
+}
+
+export interface IVisitorDefinitionError {
+  msg: string;
+  type: CstVisitorDefinitionError;
+  methodName: string;
+}
+
+export function validateVisitor(
+  visitorInstance: ICstVisitor<unknown, unknown>,
+  ruleNames: string[],
+): IVisitorDefinitionError[] {
+  const missingErrors = validateMissingCstMethods(visitorInstance, ruleNames);
+
+  return missingErrors;
+}
+
+export function validateMissingCstMethods(
+  visitorInstance: ICstVisitor<unknown, unknown>,
+  ruleNames: string[],
+): IVisitorDefinitionError[] {
+  const missingRuleNames = filter(ruleNames, (currRuleName) => {
+    return isFunction((visitorInstance as any)[currRuleName]) === false;
+  });
+
+  const errors: IVisitorDefinitionError[] = map(
+    missingRuleNames,
+    (currRuleName) => {
+      return {
+        msg: `Missing visitor method: <${currRuleName}> on ${<any>(
+          visitorInstance.constructor.name
+        )} CST Visitor.`,
+        type: CstVisitorDefinitionError.MISSING_METHOD,
+        methodName: currRuleName,
+      };
+    },
+  );
+
+  return compact<IVisitorDefinitionError>(errors);
+}