FM / lib

/var/www/cobraambalaj/node_modules/chokidar/node_modules/braces/lib/

/var/www/cobraambalaj/node_modules/chokidar/node_modules/braces/lib

Name	Size	Mode	Actions
compile.js	1415	0644	edit dl rm
constants.js	1593	0644	edit dl rm
expand.js	2780	0644	edit dl rm
parse.js	6913	0644	edit dl rm
stringify.js	700	0644	edit dl rm
utils.js	2451	0644	edit dl rm

Edit: /var/www/cobraambalaj/node_modules/chokidar/node_modules/braces/lib/parse.js (6913B)

'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;

cmd: