codtracker-js/node_modules/eslint/lib/rules/utils/char-source.js

/**
 * @fileoverview Utility functions to locate the source text of each code unit in the value of a string literal or template token.
 * @author Francesco Trotta
 */

'use strict';

/**
 * Represents a code unit produced by the evaluation of a JavaScript common token like a string
 * literal or template token.
 */
class CodeUnit {
  constructor(start, source) {
    this.start = start;
    this.source = source;
  }

  get end() {
    return this.start + this.length;
  }

  get length() {
    return this.source.length;
  }
}

/**
 * An object used to keep track of the position in a source text where the next characters will be read.
 */
class TextReader {
  constructor(source) {
    this.source = source;
    this.pos = 0;
  }

  /**
   * Advances the reading position of the specified number of characters.
   * @param {number} length Number of characters to advance.
   * @returns {void}
   */
  advance(length) {
    this.pos += length;
  }

  /**
   * Reads characters from the source.
   * @param {number} [offset=0] The offset where reading starts, relative to the current position.
   * @param {number} [length=1] Number of characters to read.
   * @returns {string} A substring of source characters.
   */
  read(offset = 0, length = 1) {
    const start = offset + this.pos;

    return this.source.slice(start, start + length);
  }
}

const SIMPLE_ESCAPE_SEQUENCES = {
  __proto__: null,
  b: '\b',
  f: '\f',
  n: '\n',
  r: '\r',
  t: '\t',
  v: '\v',
};

/**
 * Reads a hex escape sequence.
 * @param {TextReader} reader The reader should be positioned on the first hexadecimal digit.
 * @param {number} length The number of hexadecimal digits.
 * @returns {string} A code unit.
 */
function readHexSequence(reader, length) {
  const str = reader.read(0, length);
  const charCode = parseInt(str, 16);

  reader.advance(length);
  return String.fromCharCode(charCode);
}

/**
 * Reads a Unicode escape sequence.
 * @param {TextReader} reader The reader should be positioned after the "u".
 * @returns {string} A code unit.
 */
function readUnicodeSequence(reader) {
  const regExp = /\{(?<hexDigits>[\dA-Fa-f]+)\}/uy;

  regExp.lastIndex = reader.pos;
  const match = regExp.exec(reader.source);

  if (match) {
    const codePoint = parseInt(match.groups.hexDigits, 16);

    reader.pos = regExp.lastIndex;
    return String.fromCodePoint(codePoint);
  }
  return readHexSequence(reader, 4);
}

/**
 * Reads an octal escape sequence.
 * @param {TextReader} reader The reader should be positioned after the first octal digit.
 * @param {number} maxLength The maximum number of octal digits.
 * @returns {string} A code unit.
 */
function readOctalSequence(reader, maxLength) {
  const [octalStr] = reader.read(-1, maxLength).match(/^[0-7]+/u);

  reader.advance(octalStr.length - 1);
  const octal = parseInt(octalStr, 8);

  return String.fromCharCode(octal);
}

/**
 * Reads an escape sequence or line continuation.
 * @param {TextReader} reader The reader should be positioned on the backslash.
 * @returns {string} A string of zero, one or two code units.
 */
function readEscapeSequenceOrLineContinuation(reader) {
  const char = reader.read(1);

  reader.advance(2);
  const unitChar = SIMPLE_ESCAPE_SEQUENCES[char];

  if (unitChar) {
    return unitChar;
  }
  switch (char) {
    case 'x':
      return readHexSequence(reader, 2);
    case 'u':
      return readUnicodeSequence(reader);
    case '\r':
      if (reader.read() === '\n') {
        reader.advance(1);
      }

    // fallthrough
    case '\n':
    case '\u2028':
    case '\u2029':
      return '';
    case '0':
    case '1':
    case '2':
    case '3':
      return readOctalSequence(reader, 3);
    case '4':
    case '5':
    case '6':
    case '7':
      return readOctalSequence(reader, 2);
    default:
      return char;
  }
}

/**
 * Reads an escape sequence or line continuation and generates the respective `CodeUnit` elements.
 * @param {TextReader} reader The reader should be positioned on the backslash.
 * @returns {Generator<CodeUnit>} Zero, one or two `CodeUnit` elements.
 */
function* mapEscapeSequenceOrLineContinuation(reader) {
  const start = reader.pos;
  const str = readEscapeSequenceOrLineContinuation(reader);
  const end = reader.pos;
  const source = reader.source.slice(start, end);

  switch (str.length) {
    case 0:
      break;
    case 1:
      yield new CodeUnit(start, source);
      break;
    default:
      yield new CodeUnit(start, source);
      yield new CodeUnit(start, source);
      break;
  }
}

/**
 * Parses a string literal.
 * @param {string} source The string literal to parse, including the delimiting quotes.
 * @returns {CodeUnit[]} A list of code units produced by the string literal.
 */
function parseStringLiteral(source) {
  const reader = new TextReader(source);
  const quote = reader.read();

  reader.advance(1);
  const codeUnits = [];

  for (;;) {
    const char = reader.read();

    if (char === quote) {
      break;
    }
    if (char === '\\') {
      codeUnits.push(...mapEscapeSequenceOrLineContinuation(reader));
    } else {
      codeUnits.push(new CodeUnit(reader.pos, char));
      reader.advance(1);
    }
  }
  return codeUnits;
}

/**
 * Parses a template token.
 * @param {string} source The template token to parse, including the delimiting sequences `` ` ``, `${` and `}`.
 * @returns {CodeUnit[]} A list of code units produced by the template token.
 */
function parseTemplateToken(source) {
  const reader = new TextReader(source);

  reader.advance(1);
  const codeUnits = [];

  for (;;) {
    const char = reader.read();

    if (char === '`' || (char === '$' && reader.read(1) === '{')) {
      break;
    }
    if (char === '\\') {
      codeUnits.push(...mapEscapeSequenceOrLineContinuation(reader));
    } else {
      let unitSource;

      if (char === '\r' && reader.read(1) === '\n') {
        unitSource = '\r\n';
      } else {
        unitSource = char;
      }
      codeUnits.push(new CodeUnit(reader.pos, unitSource));
      reader.advance(unitSource.length);
    }
  }
  return codeUnits;
}

module.exports = { parseStringLiteral, parseTemplateToken };