🐛 Update: Added support for the 'find' command in settings.local.json. Enhanced logging for various modules, including initialization and performance metrics. Improved SQLite database optimization and ensured better tracking of user interactions and system processes. 📚

network-visualization/node_modules/extglob/lib/compilers.js

@@ -0,0 +1,169 @@
+'use strict';
+
+var brackets = require('expand-brackets');
+
+/**
+ * Extglob compilers
+ */
+
+module.exports = function(extglob) {
+  function star() {
+    if (typeof extglob.options.star === 'function') {
+      return extglob.options.star.apply(this, arguments);
+    }
+    if (typeof extglob.options.star === 'string') {
+      return extglob.options.star;
+    }
+    return '.*?';
+  }
+
+  /**
+   * Use `expand-brackets` compilers
+   */
+
+  extglob.use(brackets.compilers);
+  extglob.compiler
+
+    /**
+     * Escaped: "\\*"
+     */
+
+    .set('escape', function(node) {
+      return this.emit(node.val, node);
+    })
+
+    /**
+     * Dot: "."
+     */
+
+    .set('dot', function(node) {
+      return this.emit('\\' + node.val, node);
+    })
+
+    /**
+     * Question mark: "?"
+     */
+
+    .set('qmark', function(node) {
+      var val = '[^\\\\/.]';
+      var prev = this.prev();
+
+      if (node.parsed.slice(-1) === '(') {
+        var ch = node.rest.charAt(0);
+        if (ch !== '!' && ch !== '=' && ch !== ':') {
+          return this.emit(val, node);
+        }
+        return this.emit(node.val, node);
+      }
+
+      if (prev.type === 'text' && prev.val) {
+        return this.emit(val, node);
+      }
+
+      if (node.val.length > 1) {
+        val += '{' + node.val.length + '}';
+      }
+      return this.emit(val, node);
+    })
+
+    /**
+     * Plus: "+"
+     */
+
+    .set('plus', function(node) {
+      var prev = node.parsed.slice(-1);
+      if (prev === ']' || prev === ')') {
+        return this.emit(node.val, node);
+      }
+      var ch = this.output.slice(-1);
+      if (!this.output || (/[?*+]/.test(ch) && node.parent.type !== 'bracket')) {
+        return this.emit('\\+', node);
+      }
+      if (/\w/.test(ch) && !node.inside) {
+        return this.emit('+\\+?', node);
+      }
+      return this.emit('+', node);
+    })
+
+    /**
+     * Star: "*"
+     */
+
+    .set('star', function(node) {
+      var prev = this.prev();
+      var prefix = prev.type !== 'text' && prev.type !== 'escape'
+        ? '(?!\\.)'
+        : '';
+
+      return this.emit(prefix + star.call(this, node), node);
+    })
+
+    /**
+     * Parens
+     */
+
+    .set('paren', function(node) {
+      return this.mapVisit(node.nodes);
+    })
+    .set('paren.open', function(node) {
+      var capture = this.options.capture ? '(' : '';
+
+      switch (node.parent.prefix) {
+        case '!':
+        case '^':
+          return this.emit(capture + '(?:(?!(?:', node);
+        case '*':
+        case '+':
+        case '?':
+        case '@':
+          return this.emit(capture + '(?:', node);
+        default: {
+          var val = node.val;
+          if (this.options.bash === true) {
+            val = '\\' + val;
+          } else if (!this.options.capture && val === '(' && node.parent.rest[0] !== '?') {
+            val += '?:';
+          }
+
+          return this.emit(val, node);
+        }
+      }
+    })
+    .set('paren.close', function(node) {
+      var capture = this.options.capture ? ')' : '';
+
+      switch (node.prefix) {
+        case '!':
+        case '^':
+          var prefix = /^(\)|$)/.test(node.rest) ? '$' : '';
+          var str = star.call(this, node);
+
+          // if the extglob has a slash explicitly defined, we know the user wants
+          // to match slashes, so we need to ensure the "star" regex allows for it
+          if (node.parent.hasSlash && !this.options.star && this.options.slash !== false) {
+            str = '.*?';
+          }
+
+          return this.emit(prefix + ('))' + str + ')') + capture, node);
+        case '*':
+        case '+':
+        case '?':
+          return this.emit(')' + node.prefix + capture, node);
+        case '@':
+          return this.emit(')' + capture, node);
+        default: {
+          var val = (this.options.bash === true ? '\\' : '') + ')';
+          return this.emit(val, node);
+        }
+      }
+    })
+
+    /**
+     * Text
+     */
+
+    .set('text', function(node) {
+      var val = node.val.replace(/[\[\]]/g, '\\$&');
+      return this.emit(val, node);
+    });
+};

network-visualization/node_modules/extglob/lib/extglob.js

@@ -0,0 +1,78 @@
+'use strict';
+
+/**
+ * Module dependencies
+ */
+
+var Snapdragon = require('snapdragon');
+var define = require('define-property');
+var extend = require('extend-shallow');
+
+/**
+ * Local dependencies
+ */
+
+var compilers = require('./compilers');
+var parsers = require('./parsers');
+
+/**
+ * Customize Snapdragon parser and renderer
+ */
+
+function Extglob(options) {
+  this.options = extend({source: 'extglob'}, options);
+  this.snapdragon = this.options.snapdragon || new Snapdragon(this.options);
+  this.snapdragon.patterns = this.snapdragon.patterns || {};
+  this.compiler = this.snapdragon.compiler;
+  this.parser = this.snapdragon.parser;
+
+  compilers(this.snapdragon);
+  parsers(this.snapdragon);
+
+  /**
+   * Override Snapdragon `.parse` method
+   */
+
+  define(this.snapdragon, 'parse', function(str, options) {
+    var parsed = Snapdragon.prototype.parse.apply(this, arguments);
+    parsed.input = str;
+
+    // escape unmatched brace/bracket/parens
+    var last = this.parser.stack.pop();
+    if (last && this.options.strict !== true) {
+      var node = last.nodes[0];
+      node.val = '\\' + node.val;
+      var sibling = node.parent.nodes[1];
+      if (sibling.type === 'star') {
+        sibling.loose = true;
+      }
+    }
+
+    // add non-enumerable parser reference
+    define(parsed, 'parser', this.parser);
+    return parsed;
+  });
+
+  /**
+   * Decorate `.parse` method
+   */
+
+  define(this, 'parse', function(ast, options) {
+    return this.snapdragon.parse.apply(this.snapdragon, arguments);
+  });
+
+  /**
+   * Decorate `.compile` method
+   */
+
+  define(this, 'compile', function(ast, options) {
+    return this.snapdragon.compile.apply(this.snapdragon, arguments);
+  });
+
+}
+
+/**
+ * Expose `Extglob`
+ */
+
+module.exports = Extglob;

network-visualization/node_modules/extglob/lib/parsers.js

@@ -0,0 +1,156 @@
+'use strict';
+
+var brackets = require('expand-brackets');
+var define = require('define-property');
+var utils = require('./utils');
+
+/**
+ * Characters to use in text regex (we want to "not" match
+ * characters that are matched by other parsers)
+ */
+
+var TEXT_REGEX = '([!@*?+]?\\(|\\)|[*?.+\\\\]|\\[:?(?=.*\\])|:?\\])+';
+var not = utils.createRegex(TEXT_REGEX);
+
+/**
+ * Extglob parsers
+ */
+
+function parsers(extglob) {
+  extglob.state = extglob.state || {};
+
+  /**
+   * Use `expand-brackets` parsers
+   */
+
+  extglob.use(brackets.parsers);
+  extglob.parser.sets.paren = extglob.parser.sets.paren || [];
+  extglob.parser
+
+    /**
+     * Extglob open: "*("
+     */
+
+    .capture('paren.open', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(/^([!@*?+])?\(/);
+      if (!m) return;
+
+      var prev = this.prev();
+      var prefix = m[1];
+      var val = m[0];
+
+      var open = pos({
+        type: 'paren.open',
+        parsed: parsed,
+        val: val
+      });
+
+      var node = pos({
+        type: 'paren',
+        prefix: prefix,
+        nodes: [open]
+      });
+
+      // if nested negation extglobs, just cancel them out to simplify
+      if (prefix === '!' && prev.type === 'paren' && prev.prefix === '!') {
+        prev.prefix = '@';
+        node.prefix = '@';
+      }
+
+      define(node, 'rest', this.input);
+      define(node, 'parsed', parsed);
+      define(node, 'parent', prev);
+      define(open, 'parent', node);
+
+      this.push('paren', node);
+      prev.nodes.push(node);
+    })
+
+    /**
+     * Extglob close: ")"
+     */
+
+    .capture('paren.close', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(/^\)/);
+      if (!m) return;
+
+      var parent = this.pop('paren');
+      var node = pos({
+        type: 'paren.close',
+        rest: this.input,
+        parsed: parsed,
+        val: m[0]
+      });
+
+      if (!this.isType(parent, 'paren')) {
+        if (this.options.strict) {
+          throw new Error('missing opening paren: "("');
+        }
+        node.escaped = true;
+        return node;
+      }
+
+      node.prefix = parent.prefix;
+      parent.nodes.push(node);
+      define(node, 'parent', parent);
+    })
+
+    /**
+     * Escape: "\\."
+     */
+
+    .capture('escape', function() {
+      var pos = this.position();
+      var m = this.match(/^\\(.)/);
+      if (!m) return;
+
+      return pos({
+        type: 'escape',
+        val: m[0],
+        ch: m[1]
+      });
+    })
+
+    /**
+     * Question marks: "?"
+     */
+
+    .capture('qmark', function() {
+      var parsed = this.parsed;
+      var pos = this.position();
+      var m = this.match(/^\?+(?!\()/);
+      if (!m) return;
+      extglob.state.metachar = true;
+      return pos({
+        type: 'qmark',
+        rest: this.input,
+        parsed: parsed,
+        val: m[0]
+      });
+    })
+
+    /**
+     * Character parsers
+     */
+
+    .capture('star', /^\*(?!\()/)
+    .capture('plus', /^\+(?!\()/)
+    .capture('dot', /^\./)
+    .capture('text', not);
+};
+
+/**
+ * Expose text regex string
+ */
+
+module.exports.TEXT_REGEX = TEXT_REGEX;
+
+/**
+ * Extglob parsers
+ */
+
+module.exports = parsers;

network-visualization/node_modules/extglob/lib/utils.js

@@ -0,0 +1,69 @@
+'use strict';
+
+var regex = require('regex-not');
+var Cache = require('fragment-cache');
+
+/**
+ * Utils
+ */
+
+var utils = module.exports;
+var cache = utils.cache = new Cache();
+
+/**
+ * Cast `val` to an array
+ * @return {Array}
+ */
+
+utils.arrayify = function(val) {
+  if (!Array.isArray(val)) {
+    return [val];
+  }
+  return val;
+};
+
+/**
+ * Memoize a generated regex or function
+ */
+
+utils.memoize = function(type, pattern, options, fn) {
+  var key = utils.createKey(type + pattern, options);
+
+  if (cache.has(type, key)) {
+    return cache.get(type, key);
+  }
+
+  var val = fn(pattern, options);
+  if (options && options.cache === false) {
+    return val;
+  }
+
+  cache.set(type, key, val);
+  return val;
+};
+
+/**
+ * Create the key to use for memoization. The key is generated
+ * by iterating over the options and concatenating key-value pairs
+ * to the pattern string.
+ */
+
+utils.createKey = function(pattern, options) {
+  var key = pattern;
+  if (typeof options === 'undefined') {
+    return key;
+  }
+  for (var prop in options) {
+    key += ';' + prop + '=' + String(options[prop]);
+  }
+  return key;
+};
+
+/**
+ * Create the regex to use for matching text
+ */
+
+utils.createRegex = function(str) {
+  var opts = {contains: true, strictClose: false};
+  return regex(str, opts);
+};