File Manager

Current Path: Root / node_modules/ braces/ lib

Parent Directory

Name	Size	Last Modified
[F]compile.js Edit	1.38 KB	2022-10-08 17:28:20
[F]constants.js Edit	1.56 KB	2022-10-08 17:28:20
[F]expand.js Edit	2.71 KB	2022-10-08 17:28:20
[F]parse.js Edit	6.75 KB	2022-10-08 17:28:20
[F]stringify.js Edit	700 bytes	2022-10-08 17:28:21
[F]utils.js Edit	2.39 KB	2022-10-08 17:28:21

Editing: parse.js

'use strict';

const stringify = require('./stringify');

/**
 * Constants
 */

const {
  MAX_LENGTH,
  CHAR_BACKSLASH, /* \ */
  CHAR_BACKTICK, /* ` */
  CHAR_COMMA, /* , */
  CHAR_DOT, /* . */
  CHAR_LEFT_PARENTHESES, /* ( */
  CHAR_RIGHT_PARENTHESES, /* ) */
  CHAR_LEFT_CURLY_BRACE, /* { */
  CHAR_RIGHT_CURLY_BRACE, /* } */
  CHAR_LEFT_SQUARE_BRACKET, /* [ */
  CHAR_RIGHT_SQUARE_BRACKET, /* ] */
  CHAR_DOUBLE_QUOTE, /* " */
  CHAR_SINGLE_QUOTE, /* ' */
  CHAR_NO_BREAK_SPACE,
  CHAR_ZERO_WIDTH_NOBREAK_SPACE
} = require('./constants');

/**
 * parse
 */

const parse = (input, options = {}) => {
  if (typeof input !== 'string') {
    throw new TypeError('Expected a string');
  }

let ast = { type: 'root', input, nodes: [] };
  let stack = [ast];
  let block = ast;
  let prev = ast;
  let brackets = 0;
  let length = input.length;
  let index = 0;
  let depth = 0;
  let value;
  let memo = {};

/**
   * Helpers
   */

const advance = () => input[index++];
  const push = node => {
    if (node.type === 'text' && prev.type === 'dot') {
      prev.type = 'text';
    }

if (prev && prev.type === 'text' && node.type === 'text') {
      prev.value += node.value;
      return;
    }

block.nodes.push(node);
    node.parent = block;
    node.prev = prev;
    prev = node;
    return node;
  };

push({ type: 'bos' });

while (index < length) {
    block = stack[stack.length - 1];
    value = advance();

/**
     * Invalid chars
     */

if (value === CHAR_ZERO_WIDTH_NOBREAK_SPACE || value === CHAR_NO_BREAK_SPACE) {
      continue;
    }

/**
     * Escaped chars
     */

if (value === CHAR_BACKSLASH) {
      push({ type: 'text', value: (options.keepEscaping ? value : '') + advance() });
      continue;
    }

/**
     * Right square bracket (literal): ']'
     */

if (value === CHAR_RIGHT_SQUARE_BRACKET) {
      push({ type: 'text', value: '\\' + value });
      continue;
    }

/**
     * Left square bracket: '['
     */

if (value === CHAR_LEFT_SQUARE_BRACKET) {
      brackets++;

let closed = true;
      let next;

while (index < length && (next = advance())) {
        value += next;

if (next === CHAR_LEFT_SQUARE_BRACKET) {
          brackets++;
          continue;
        }

if (next === CHAR_BACKSLASH) {
          value += advance();
          continue;
        }

if (next === CHAR_RIGHT_SQUARE_BRACKET) {
          brackets--;

if (brackets === 0) {
            break;
          }
        }
      }

push({ type: 'text', value });
      continue;
    }

/**
     * Parentheses
     */

if (value === CHAR_LEFT_PARENTHESES) {
      block = push({ type: 'paren', nodes: [] });
      stack.push(block);
      push({ type: 'text', value });
      continue;
    }

if (value === CHAR_RIGHT_PARENTHESES) {
      if (block.type !== 'paren') {
        push({ type: 'text', value });
        continue;
      }
      block = stack.pop();
      push({ type: 'text', value });
      block = stack[stack.length - 1];
      continue;
    }

/**
     * Quotes: '|"|`
     */

if (value === CHAR_DOUBLE_QUOTE || value === CHAR_SINGLE_QUOTE || value === CHAR_BACKTICK) {
      let open = value;
      let next;

if (options.keepQuotes !== true) {
        value = '';
      }

while (index < length && (next = advance())) {
        if (next === CHAR_BACKSLASH) {
          value += next + advance();
          continue;
        }

if (next === open) {
          if (options.keepQuotes === true) value += next;
          break;
        }

value += next;
      }

push({ type: 'text', value });
      continue;
    }

/**
     * Left curly brace: '{'
     */

if (value === CHAR_LEFT_CURLY_BRACE) {
      depth++;

let dollar = prev.value && prev.value.slice(-1) === '$' || block.dollar === true;
      let brace = {
        type: 'brace',
        open: true,
        close: false,
        dollar,
        depth,
        commas: 0,
        ranges: 0,
        nodes: []
      };

block = push(brace);
      stack.push(block);
      push({ type: 'open', value });
      continue;
    }

/**
     * Right curly brace: '}'
     */

if (value === CHAR_RIGHT_CURLY_BRACE) {
      if (block.type !== 'brace') {
        push({ type: 'text', value });
        continue;
      }

let type = 'close';
      block = stack.pop();
      block.close = true;

push({ type, value });
      depth--;

block = stack[stack.length - 1];
      continue;
    }

/**
     * Comma: ','
     */

if (value === CHAR_COMMA && depth > 0) {
      if (block.ranges > 0) {
        block.ranges = 0;
        let open = block.nodes.shift();
        block.nodes = [open, { type: 'text', value: stringify(block) }];
      }

push({ type: 'comma', value });
      block.commas++;
      continue;
    }

/**
     * Dot: '.'
     */

if (value === CHAR_DOT && depth > 0 && block.commas === 0) {
      let siblings = block.nodes;

if (depth === 0 || siblings.length === 0) {
        push({ type: 'text', value });
        continue;
      }

if (prev.type === 'dot') {
        block.range = [];
        prev.value += value;
        prev.type = 'range';

if (block.nodes.length !== 3 && block.nodes.length !== 5) {
          block.invalid = true;
          block.ranges = 0;
          prev.type = 'text';
          continue;
        }

block.ranges++;
        block.args = [];
        continue;
      }

if (prev.type === 'range') {
        siblings.pop();

let before = siblings[siblings.length - 1];
        before.value += prev.value + value;
        prev = before;
        block.ranges--;
        continue;
      }

push({ type: 'dot', value });
      continue;
    }

/**
     * Text
     */

push({ type: 'text', value });
  }

// Mark imbalanced braces and brackets as invalid
  do {
    block = stack.pop();

if (block.type !== 'root') {
      block.nodes.forEach(node => {
        if (!node.nodes) {
          if (node.type === 'open') node.isOpen = true;
          if (node.type === 'close') node.isClose = true;
          if (!node.nodes) node.type = 'text';
          node.invalid = true;
        }
      });

// get the location of the block on parent.nodes (block's siblings)
      let parent = stack[stack.length - 1];
      let index = parent.nodes.indexOf(block);
      // replace the (invalid) block with it's nodes
      parent.nodes.splice(index, 1, ...block.nodes);
    }
  } while (stack.length > 0);

push({ type: 'eos' });
  return ast;
};

module.exports = parse;

Cancel

File Explorer

Navigation

File Manager

Editing: parse.js

File Explorer

Navigation

File Manager

Editing: parse.js

Confirm Deletion

Rename Item

Change Permissions (Chmod)