@contrast/agent 4.31.2 → 5.0.0-alpha.1

package/lib/util/clean-string/brackets.js

@@ -1,86 +0,0 @@
-/**
-Copyright: 2023 Contrast Security, Inc
-  Contact: support@contrastsecurity.com
-  License: Commercial
-
-  NOTICE: This Software and the patented inventions embodied within may only be
-  used as part of Contrast Security’s commercial offerings. Even though it is
-  made available through public repositories, use of this Software is subject to
-  the applicable End User Licensing Agreement found at
-  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
-  between Contrast Security and the End User. The Software may not be reverse
-  engineered, modified, repackaged, sold, redistributed or otherwise used in a
-  way not consistent with the End User License Agreement.
-*/
-'use strict';
-const DOT = '.';
-
-class Brackets {
-  constructor(str) {
-    this.string = str;
-  }
-
-  /**
-   * Converts substrings that look like JavaScript bracket
-   * accessors (['abcd']) into dot accessor equivalents.
-   */
-  toDotNotation() {
-    this.string = coerceToDotAccessors(this.string);
-    return this.string;
-  }
-
-  /**
-   * Cleans the given string value.
-   * @param   {String} str the string to clean
-   * @returns {String}
-   */
-  static clean(str) {
-    return new Brackets(str).toDotNotation();
-  }
-}
-
-/**
- * Coerces occurrences of substrings that look like
- * bracket accessors (['abcd'], ["efgh"]) into their
- * dot-accessor equivalents (.abcd, .efgh).
- * @param {} str
- * @returns {}
- */
-function coerceToDotAccessors(str) {
-  const startIdx = str.indexOf('[');
-  if (-1 === startIdx) {
-    return str;
-  }
-
-  const stopIdx = str.indexOf(']', startIdx + 1);
-  if (-1 === stopIdx) {
-    return str;
-  }
-
-  const bracketed = str.substring(startIdx, stopIdx + 1);
-  const pattern = /^\[\s*[`'"]([a-zA-Z_]+[a-zA-Z0-9_]*)[`'"]\s*]$/;
-  const match = pattern.exec(bracketed);
-
-  return !match
-    ? str
-    : coerceToDotAccessors(
-        [
-          str.substr(0, startIdx),
-          bracketToDot(bracketed),
-          str.substr(stopIdx + 1)
-        ].join('')
-      );
-}
-
-/**
- * Turns a bracket-accessor string into a dot-accessor string.
- * @param   {String} bracket The string to convert
- * @returns {String}
- */
-function bracketToDot(bracket) {
-  bracket = bracket.replace(/\s/g, '');
-  bracket = bracket.substring(2, bracket.length - 2);
-  return `${DOT}${bracket}`;
-}
-
-module.exports = Brackets;

package/lib/util/clean-string/clean-string-base.js

@@ -1,60 +0,0 @@
-/**
-Copyright: 2023 Contrast Security, Inc
-  Contact: support@contrastsecurity.com
-  License: Commercial
-
-  NOTICE: This Software and the patented inventions embodied within may only be
-  used as part of Contrast Security’s commercial offerings. Even though it is
-  made available through public repositories, use of this Software is subject to
-  the applicable End User Licensing Agreement found at
-  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
-  between Contrast Security and the End User. The Software may not be reverse
-  engineered, modified, repackaged, sold, redistributed or otherwise used in a
-  way not consistent with the End User License Agreement.
-*/
-'use strict';
-
-/**
- * Implements a small subset of the String API.
- */
-class CleanStringBase {
-  constructor(string) {
-    this._value = string;
-  }
-
-  /**
-   * Returns the instance's value as a String.
-   */
-  toString() {
-    return this._value;
-  }
-
-  /**
-   * Returns the instance's value as a String.
-   */
-  valueOf() {
-    return this._value;
-  }
-
-  /**
-   * Calls indexOf on <code>_value</code> property.
-   * @param   {String} sub     The substring
-   * @param   {Number} fromIdx Starting index for search
-   * @returns {Number}
-   */
-  indexOf(sub, fromIdx) {
-    return this._value.indexOf(sub, fromIdx);
-  }
-
-  /**
-   * Calls lastIndexOf on <code>_value</code> property.
-   * @param   {String} sub     The substring
-   * @param   {Number} fromIdx Starting index for search
-   * @returns {Number}
-   */
-  lastIndexOf(sub, fromIdx) {
-    return this._value.lastIndexOf(sub, fromIdx);
-  }
-}
-
-module.exports = CleanStringBase;

package/lib/util/clean-string/comments.js

@@ -1,107 +0,0 @@
-/**
-Copyright: 2023 Contrast Security, Inc
-  Contact: support@contrastsecurity.com
-  License: Commercial
-
-  NOTICE: This Software and the patented inventions embodied within may only be
-  used as part of Contrast Security’s commercial offerings. Even though it is
-  made available through public repositories, use of this Software is subject to
-  the applicable End User Licensing Agreement found at
-  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
-  between Contrast Security and the End User. The Software may not be reverse
-  engineered, modified, repackaged, sold, redistributed or otherwise used in a
-  way not consistent with the End User License Agreement.
-*/
-'use strict';
-const os = require('os');
-const BLOCK = { START: '/*', END: '*/' };
-const INLINE = { START: '//', END: os.EOL };
-
-class Comments {
-  constructor(str) {
-    this.string = str;
-  }
-
-  /**
-   * Removes all comments from the instance's string value.
-   * Searches for both block and inline comments and determines
-   * how to remove them.
-   */
-  remove() {
-    const blockStart = this.string.indexOf(BLOCK.START);
-    const blockEnd = this.string.indexOf(BLOCK.END, blockStart);
-
-    const inlineStart = this.string.indexOf(INLINE.START);
-    const inlineEnd = this.string.indexOf(INLINE.END, inlineStart);
-
-    const activeRange = resolveRanges(
-      [blockStart, blockEnd],
-      [inlineStart, inlineEnd]
-    );
-
-    if (activeRange) {
-      const offset = activeRange[1] == blockEnd ? 2 : 1;
-
-      this.string = [
-        this.string.substring(0, activeRange[0]),
-        this.string.substring(activeRange[1] + offset)
-      ].join('');
-
-      this.remove();
-    }
-
-    return this.string;
-  }
-
-  /**
-   * Static method to clean all comments from a string.
-   * @param {} str
-   * @returns {}
-   */
-  static clean(str) {
-    return new Comments(str).remove();
-  }
-}
-
-/**
- * Takes a block comment range and an inline comment range and compares
- * them do determine which is the appropriate one to remove from the string.
- * @param   {Number[]}      range1 Range of indices of found block comment
- * @param   {Number[]}      range2 Range of indices of found inline comment
- * @returns {Number[]|null}
- */
-function resolveRanges(block, inline) {
-  const blockValid = isRangeValid(block);
-  const inlineValid = isRangeValid(inline);
-
-  /* Cases where one or both ranges are invalid: */
-  if (!blockValid && !inlineValid) {
-    return null;
-  }
-  if (blockValid && !inlineValid) {
-    return block;
-  }
-  if (!blockValid && inlineValid) {
-    return inline;
-  }
-
-  /* Both are valid, so we need to look at arrangement. */
-  return block[0] < inline[0] ? block : inline;
-}
-
-/**
- * Whether the given range is a valid set if indices.
- * @param   {Number[]} range
- * @returns {Boolean}
- */
-function isRangeValid(range) {
-  return (
-    range &&
-    range.length === 2 &&
-    range[0] < range[1] &&
-    -1 < range[0] &&
-    -1 < range[1]
-  );
-}
-
-module.exports = Comments;

package/lib/util/clean-string/concatenations.js

@@ -1,183 +0,0 @@
-/**
-Copyright: 2023 Contrast Security, Inc
-  Contact: support@contrastsecurity.com
-  License: Commercial
-
-  NOTICE: This Software and the patented inventions embodied within may only be
-  used as part of Contrast Security’s commercial offerings. Even though it is
-  made available through public repositories, use of this Software is subject to
-  the applicable End User Licensing Agreement found at
-  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
-  between Contrast Security and the End User. The Software may not be reverse
-  engineered, modified, repackaged, sold, redistributed or otherwise used in a
-  way not consistent with the End User License Agreement.
-*/
-'use strict';
-
-const { searchTimesF, searchTimesR } = require('./util');
-
-const PLUS = '+';
-const QUOTE_CHARS = ['`', "'", '"'];
-const BACKTICK = QUOTE_CHARS[0];
-const SINGLE = QUOTE_CHARS[1];
-
-class Concatenations {
-  constructor(str, opIdx) {
-    this.string = str;
-    this.operatorIdx = opIdx || str.indexOf(PLUS);
-    this.reset();
-
-    capture(this, str, this.operatorIdx);
-  }
-
-  /**
-   * Resets the state of the current capture's concat info.
-   */
-  reset() {
-    this.mergeable = false;
-    this.left = { char: null, range: [-Infinity, -Infinity] };
-    this.right = { char: null, range: [Infinity, Infinity] };
-  }
-
-  /**
-   * Once <code>capture</code> has been called, this value
-   * will return true or false based on whether an instance
-   * of a concatenation has been found at the next index of
-   * the '+' character. If not valid, we can search for the
-   * next index of '+' and try again.
-   */
-  isValid() {
-    return (
-      this.mergeable &&
-      [
-        this.left.range.every(Number.isFinite),
-        this.right.range.every(Number.isFinite)
-      ].every(Boolean)
-    );
-  }
-
-  /**
-   * Merges the first occurrance of a string concatenation.
-   */
-  merge() {
-    if (!this.isValid()) {
-      return this.string;
-    }
-
-    const quote = resolveQuotes(this.left.char, this.right.char);
-
-    const rangeL = [this.left.range[0] + 1, this.left.range[1]];
-    const rangeR = [this.right.range[0] + 1, this.right.range[1]];
-
-    const leftContents = this.string.substring(...rangeL);
-    const rightContents = this.string.substring(...rangeR);
-
-    this.lastIndex = this.right.range[1] - this.cutLength;
-
-    this.string =
-      this.string.substr(0, rangeL[0] - 1) +
-      quote +
-      leftContents +
-      rightContents +
-      quote +
-      this.string.substr(rangeR[1] + 1);
-
-    return this.string;
-  }
-
-  /**
-   * Merges all occurrances of a string concatenation.
-   */
-  mergeAll() {
-    this.merge();
-    this.reset();
-    this.operatorIdx = this.string.indexOf(PLUS, this.operatorIdx + 1);
-
-    capture(this, this.string, this.operatorIdx);
-
-    // Recurse while we still can find additional '+' operators.
-    return 0 <= this.operatorIdx ? this.mergeAll() : this.string;
-  }
-
-  /**
-   * Merges all occurrances of a string concatenation within the
-   * provided string.
-   */
-  static clean(str) {
-    return new Concatenations(str).mergeAll();
-  }
-}
-
-/**
- * Captures the next string concatenation occurrence
- * within the instance's string value.
- * @param {} info
- * @param {} str
- * @param {} operatorIdx
- * @returns {}
- */
-function capture(info, str, operatorIdx) {
-  if (operatorIdx < 0) {
-    return;
-  }
-
-  QUOTE_CHARS.reduce((memo, char) => {
-    let range;
-
-    /* Search for the first 2 quotes forwards from '+'  */
-    range = searchTimesF(2, char, str, operatorIdx);
-    if (!range.some((idx) => idx === -1)) {
-      if (range[0] < memo.right.range[0]) {
-        memo.right = { char, range };
-      }
-    }
-
-    /* Search for the first 2 quotes backwards from '+' */
-    range = searchTimesR(2, char, str, operatorIdx);
-    if (!range.some((idx) => idx === -1)) {
-      if (memo.left.range[1] < range[1]) {
-        memo.left = { char, range };
-      }
-    }
-
-    return memo;
-  }, info);
-
-  /* We've found something that looks like string concatenation;  */
-  if (info.left.char && info.right.char) {
-    const l = info.left.range[1] + 1;
-    const r = info.right.range[0];
-
-    /* ensure mergable - only '+' and spaces are between strings. */
-    const operatorMatch = /(^[\r\n\s]*\+[\r\n\s]*$)/.exec(str.substr(l, r - l));
-
-    if (operatorMatch) {
-      /* We're removing inner quotes and what's between them.     */
-      info.cutLength = operatorMatch[1].length + 2;
-      info.mergeable = true;
-    } else {
-      info.mergeable = false;
-    }
-  }
-}
-
-/**
- * Resolves two quote strings to the one most appropriate
- * to perform the result of a concatenation. Backtick takes
- * highest rank, while single quote is default. If either
- * is <code>null</code>, then <code>null</code> is returned.
- * @param   {String}      char1 Quote character
- * @param   {String}      char2 Quote character
- * @returns {String|null}
- */
-function resolveQuotes(char1, char2) {
-  if (char1 === BACKTICK || char2 === BACKTICK) {
-    return BACKTICK;
-  } else if (char1 === null || char2 === null) {
-    return null;
-  } else {
-    return SINGLE;
-  }
-}
-
-module.exports = Concatenations;

package/lib/util/clean-string/jsclean-string.js

@@ -1,96 +0,0 @@
-/**
-Copyright: 2023 Contrast Security, Inc
-  Contact: support@contrastsecurity.com
-  License: Commercial
-
-  NOTICE: This Software and the patented inventions embodied within may only be
-  used as part of Contrast Security’s commercial offerings. Even though it is
-  made available through public repositories, use of this Software is subject to
-  the applicable End User Licensing Agreement found at
-  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
-  between Contrast Security and the End User. The Software may not be reverse
-  engineered, modified, repackaged, sold, redistributed or otherwise used in a
-  way not consistent with the End User License Agreement.
-*/
-'use strict';
-
-const Brackets = require('./brackets');
-const Comments = require('./comments');
-const Concatenations = require('./concatenations');
-const Placeholders = require('./placeholders');
-
-/**
- * @module lib/util/JSCleanString
- */
-
-/**
- * Normalizes a string that is presumed to have JavaScript code in it.
- * Note : Most instance methods are chainable, BUT, the order in which
- *        they are chained may have an effect on the resulting string.
- *        Results will depend both on the order of the methods as well
- *        as the characteristics of the string being normalized.
- */
-class JSCleanString extends require('./clean-string-base') {
-  constructor(string) {
-    super(string);
-    this._value = string;
-  }
-
-  /**
-   * Removes all cases of inline or block comments from the
-   * instance's underlying value.
-   */
-  cleanComments() {
-    this._value = Comments.clean(this._value);
-    return this;
-  }
-
-  /**
-   * Mutative. Scans the string and merges all string concatenations into
-   * a single string representation as if the concatenations were applied.
-   * Examples:
-   *   `'a'+"b"` => `ab`
-   *   'some text `in-a-quote` + "!"' => 'some text `in-a-quote!`'
-   * If any strings that were in the concatenation were template strings,
-   * then the resultant string will use the <code>`</code> character.
-   */
-  cleanStringConcats() {
-    this._value = Concatenations.clean(this._value);
-    return this;
-  }
-
-  /**
-   * Converts substrings that look like JavaScript bracket
-   * accessors (['abcd']) into dot accessor equivalents.
-   */
-  cleanBrackets() {
-    this._value = Brackets.clean(this._value);
-    return this;
-  }
-
-  /**
-   * Looks at template string placeholders and attempts to
-   * remove them if their values are
-   * - string literals
-   * - ... more to come?
-   */
-  cleanPlaceholders() {
-    this._value = Placeholders.clean(this._value);
-    return this;
-  }
-
-  /**
-   * Performs all cleaning operations on the given string.
-   * @param   {String} str The string to clean.
-   * @returns {String}
-   */
-  static clean(str) {
-    return new JSCleanString(str)
-      .cleanComments() /** 1 */
-      .cleanStringConcats() /** 2 */
-      .cleanPlaceholders() /** 3 */
-      .cleanBrackets(); /** 4 */
-  }
-}
-
-module.exports = JSCleanString;

package/lib/util/clean-string/placeholders.js

@@ -1,107 +0,0 @@
-/**
-Copyright: 2023 Contrast Security, Inc
-  Contact: support@contrastsecurity.com
-  License: Commercial
-
-  NOTICE: This Software and the patented inventions embodied within may only be
-  used as part of Contrast Security’s commercial offerings. Even though it is
-  made available through public repositories, use of this Software is subject to
-  the applicable End User Licensing Agreement found at
-  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
-  between Contrast Security and the End User. The Software may not be reverse
-  engineered, modified, repackaged, sold, redistributed or otherwise used in a
-  way not consistent with the End User License Agreement.
-*/
-'use strict';
-
-const BACKTICK = '`';
-const PLACEHOLDER_OPEN = '${';
-const PLACEHOLDER_CLOSE = '}';
-
-class Placeholders {
-  constructor(str) {
-    this.string = str;
-  }
-
-  /**
-   * Looks for placeholders in template strings. If the
-   * contents of the placeholder is a string literal, then
-   * it will remove the placeholder as if it were evaluated
-   * and interpolated into the string.
-   */
-  renderStringLiterals() {
-    this.string = _renderStringLiterals(this.string);
-    return this;
-  }
-
-  /**
-   * Returns the string value property. Because there may
-   * be multiple operations that could be done to parse and
-   * modify placeholders, this class's methods return the
-   * instance so that operations can be chained. This gives
-   * a way to get the resulting value of chained calls.
-   */
-  toString() {
-    return this.string;
-  }
-
-  /**
-   * Static method to perform all cleaning operations on a string.
-   */
-  static clean(str) {
-    return new Placeholders(str).renderStringLiterals().toString();
-  }
-}
-
-/**
- * If a placeholder ${expression} is found in a template string,
- * then this function will attempt to remove the placeholder if
- * the expression is simply a string literal;
- *
- * @param   {String} str
- * @param   {Number} fromIdx
- * @returns {String}
- */
-function _renderStringLiterals(str, fromIdx) {
-  fromIdx = fromIdx || 0;
-
-  /* Find indices of chars and validate thier arrangement. */
-  const btStartIdx = str.indexOf(BACKTICK, fromIdx);
-  if (-1 === btStartIdx) {
-    return str;
-  }
-
-  const phStartIdx = str.indexOf(PLACEHOLDER_OPEN, btStartIdx + 1);
-  if (-1 === phStartIdx) {
-    return str;
-  }
-
-  const phEndIdx = str.indexOf(PLACEHOLDER_CLOSE, phStartIdx + 1);
-  if (-1 === phEndIdx) {
-    return str;
-  }
-
-  const btEndIdx = str.indexOf(BACKTICK, phEndIdx + 1);
-  if (-1 === btEndIdx) {
-    return str;
-  }
-
-  const singles = /^\${\s*(?:')([^']*?)(?:')(\s*})$/;
-  const doubles = /^\${\s*(?:")([^"]*?)(?:")(\s*})$/;
-  const ticks = /^\${\s*(?:`)([^`]*?)(?:`)(\s*})$/;
-  const section = str.substring(phStartIdx, phEndIdx + 1);
-  const match =
-    singles.exec(section) || doubles.exec(section) || ticks.exec(section);
-
-  if (!match) {
-    return str;
-  }
-
-  /* Recurse to capture all cases. */
-  return _renderStringLiterals(
-    str.substring(0, phStartIdx) + match[1] + str.substring(phEndIdx + 1),
-    phEndIdx - match[2].length + 1
-  );
-}
-
-module.exports = Placeholders;

package/lib/util/clean-string/util.js

@@ -1,69 +0,0 @@
-/**
-Copyright: 2023 Contrast Security, Inc
-  Contact: support@contrastsecurity.com
-  License: Commercial
-
-  NOTICE: This Software and the patented inventions embodied within may only be
-  used as part of Contrast Security’s commercial offerings. Even though it is
-  made available through public repositories, use of this Software is subject to
-  the applicable End User Licensing Agreement found at
-  https://www.contrastsecurity.com/enduser-terms-0317a or as otherwise agreed
-  between Contrast Security and the End User. The Software may not be reverse
-  engineered, modified, repackaged, sold, redistributed or otherwise used in a
-  way not consistent with the End User License Agreement.
-*/
-'use strict';
-
-/**
- * Search for a target char(s) in a string that is
- * forward of start index.
- * @param {} target
- * @param {} string
- * @param {} startIdx
- * @returns {}
- */
-function searchTimesF(times, target, str, startIdx) {
-  startIdx = startIdx || 0;
-
-  const coll = [];
-  let counter = -1;
-
-  while (0 < times - ++counter) {
-    const fromIndex =
-      coll[counter - 1] !== undefined ? coll[counter - 1] : startIdx;
-    const idx = str.indexOf(target, fromIndex + 1);
-
-    coll.push(idx);
-  }
-
-  return times === 1 ? coll[0] : coll;
-}
-
-/**
- * Search for a target char(s) in a string that is
- * behind start index (in reverse).
- * @param {} target
- * @param {} str
- * @param {} startIdx
- * @returns {}
- */
-function searchTimesR(times, target, str, startIdx) {
-  startIdx = startIdx || 0;
-
-  const coll = [];
-  let counter = -1;
-
-  while (0 < times - ++counter) {
-    const fromIndex = coll[0] !== undefined ? coll[0] : startIdx;
-    const idx = str.lastIndexOf(target, fromIndex - 1);
-
-    coll.unshift(idx);
-  }
-
-  return coll;
-}
-
-module.exports = {
-  searchTimesF,
-  searchTimesR
-};