File Manager

Editing File: /home/ubuntu/voice-assistant-frontend/node_modules/esquery/dist/esquery.lite.js

(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('estraverse')) :
  typeof define === 'function' && define.amd ? define(['estraverse'], factory) :
  (global = global || self, global.esquery = factory(global.estraverse));
}(this, (function (estraverse) { 'use strict';

estraverse = estraverse && Object.prototype.hasOwnProperty.call(estraverse, 'default') ? estraverse['default'] : estraverse;

return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
      return typeof obj;
    } : function (obj) {
      return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    }, _typeof(obj);
  }
  function _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
  }
  function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
  }
  function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
  }
  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }
  function _iterableToArray(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
  }
  function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
  }
  function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
    return arr2;
  }
  function _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }
  function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function createCommonjsModule(fn, module) {
  	return module = { exports: {} }, fn(module, module.exports), module.exports;
  }

var parser = createCommonjsModule(function (module) {
    /*
     * Generated by PEG.js 0.10.0.
     *
     * http://pegjs.org/
     */
    (function (root, factory) {
      if ( module.exports) {
        module.exports = factory();
      }
    })(commonjsGlobal, function () {

/**
  * @typedef {"LEFT_SIDE"|"RIGHT_SIDE"} Side
  */

var LEFT_SIDE = 'LEFT_SIDE';
  var RIGHT_SIDE = 'RIGHT_SIDE';

/**
   * @external AST
   * @see https://esprima.readthedocs.io/en/latest/syntax-tree-format.html
   */

/**
   * One of the rules of `grammar.pegjs`
   * @typedef {PlainObject} SelectorAST
   * @see grammar.pegjs
  */

/**
   * The `sequence` production of `grammar.pegjs`
   * @typedef {PlainObject} SelectorSequenceAST
  */

/**
   * Get the value of a property which may be multiple levels down
   * in the object.
   * @param {?PlainObject} obj
   * @param {string[]} keys
   * @returns {undefined|boolean|string|number|external:AST}
   */
  function getPath(obj, keys) {
    for (var i = 0; i < keys.length; ++i) {
      if (obj == null) {
        return obj;
      }
      obj = obj[keys[i]];
    }
    return obj;
  }

/**
   * Determine whether `node` can be reached by following `path`,
   * starting at `ancestor`.
   * @param {?external:AST} node
   * @param {?external:AST} ancestor
   * @param {string[]} path
   * @param {Integer} fromPathIndex
   * @returns {boolean}
   */
  function inPath(node, ancestor, path, fromPathIndex) {
    var current = ancestor;
    for (var i = fromPathIndex; i < path.length; ++i) {
      if (current == null) {
        return false;
      }
      var field = current[path[i]];
      if (Array.isArray(field)) {
        for (var k = 0; k < field.length; ++k) {
          if (inPath(node, field[k], path, i + 1)) {
            return true;
          }
        }
        return false;
      }
      current = field;
    }
    return node === current;
  }

/**
   * A generated matcher function for a selector.
   * @typedef {function} SelectorMatcher
  */

/**
   * A WeakMap for holding cached matcher functions for selectors.
   * @type {WeakMap<SelectorAST, SelectorMatcher>}
  */
  var MATCHER_CACHE = typeof WeakMap === 'function' ? new WeakMap() : null;

/**
   * Look up a matcher function for `selector` in the cache.
   * If it does not exist, generate it with `generateMatcher` and add it to the cache.
   * In engines without WeakMap, the caching is skipped and matchers are generated with every call.
   * @param {?SelectorAST} selector
   * @returns {SelectorMatcher}
   */
  function getMatcher(selector) {
    if (selector == null) {
      return function () {
        return true;
      };
    }
    if (MATCHER_CACHE != null) {
      var matcher = MATCHER_CACHE.get(selector);
      if (matcher != null) {
        return matcher;
      }
      matcher = generateMatcher(selector);
      MATCHER_CACHE.set(selector, matcher);
      return matcher;
    }
    return generateMatcher(selector);
  }

/**
   * Create a matcher function for `selector`,
   * @param {?SelectorAST} selector
   * @returns {SelectorMatcher}
   */
  function generateMatcher(selector) {
    switch (selector.type) {
      case 'wildcard':
        return function () {
          return true;
        };
      case 'identifier':
        {
          var value = selector.value.toLowerCase();
          return function (node, ancestry, options) {
            var nodeTypeKey = options && options.nodeTypeKey || 'type';
            return value === node[nodeTypeKey].toLowerCase();
          };
        }
      case 'field':
        {
          var path = selector.name.split('.');
          return function (node, ancestry) {
            var ancestor = ancestry[path.length - 1];
            return inPath(node, ancestor, path, 0);
          };
        }
      case 'matches':
        {
          var matchers = selector.selectors.map(getMatcher);
          return function (node, ancestry, options) {
            for (var i = 0; i < matchers.length; ++i) {
              if (matchers[i](node, ancestry, options)) {
                return true;
              }
            }
            return false;
          };
        }
      case 'compound':
        {
          var _matchers = selector.selectors.map(getMatcher);
          return function (node, ancestry, options) {
            for (var i = 0; i < _matchers.length; ++i) {
              if (!_matchers[i](node, ancestry, options)) {
                return false;
              }
            }
            return true;
          };
        }
      case 'not':
        {
          var _matchers2 = selector.selectors.map(getMatcher);
          return function (node, ancestry, options) {
            for (var i = 0; i < _matchers2.length; ++i) {
              if (_matchers2[i](node, ancestry, options)) {
                return false;
              }
            }
            return true;
          };
        }
      case 'has':
        {
          var _matchers3 = selector.selectors.map(getMatcher);
          return function (node, ancestry, options) {
            var result = false;
            var a = [];
            estraverse.traverse(node, {
              enter: function enter(node, parent) {
                if (parent != null) {
                  a.unshift(parent);
                }
                for (var i = 0; i < _matchers3.length; ++i) {
                  if (_matchers3[i](node, a, options)) {
                    result = true;
                    this["break"]();
                    return;
                  }
                }
              },
              leave: function leave() {
                a.shift();
              },
              keys: options && options.visitorKeys,
              fallback: options && options.fallback || 'iteration'
            });
            return result;
          };
        }
      case 'child':
        {
          var left = getMatcher(selector.left);
          var right = getMatcher(selector.right);
          return function (node, ancestry, options) {
            if (ancestry.length > 0 && right(node, ancestry, options)) {
              return left(ancestry[0], ancestry.slice(1), options);
            }
            return false;
          };
        }
      case 'descendant':
        {
          var _left = getMatcher(selector.left);
          var _right = getMatcher(selector.right);
          return function (node, ancestry, options) {
            if (_right(node, ancestry, options)) {
              for (var i = 0, l = ancestry.length; i < l; ++i) {
                if (_left(ancestry[i], ancestry.slice(i + 1), options)) {
                  return true;
                }
              }
            }
            return false;
          };
        }
      case 'attribute':
        {
          var _path = selector.name.split('.');
          switch (selector.operator) {
            case void 0:
              return function (node) {
                return getPath(node, _path) != null;
              };
            case '=':
              switch (selector.value.type) {
                case 'regexp':
                  return function (node) {
                    var p = getPath(node, _path);
                    return typeof p === 'string' && selector.value.value.test(p);
                  };
                case 'literal':
                  {
                    var literal = "".concat(selector.value.value);
                    return function (node) {
                      return literal === "".concat(getPath(node, _path));
                    };
                  }
                case 'type':
                  return function (node) {
                    return selector.value.value === _typeof(getPath(node, _path));
                  };
              }
              throw new Error("Unknown selector value type: ".concat(selector.value.type));
            case '!=':
              switch (selector.value.type) {
                case 'regexp':
                  return function (node) {
                    return !selector.value.value.test(getPath(node, _path));
                  };
                case 'literal':
                  {
                    var _literal = "".concat(selector.value.value);
                    return function (node) {
                      return _literal !== "".concat(getPath(node, _path));
                    };
                  }
                case 'type':
                  return function (node) {
                    return selector.value.value !== _typeof(getPath(node, _path));
                  };
              }
              throw new Error("Unknown selector value type: ".concat(selector.value.type));
            case '<=':
              return function (node) {
                return getPath(node, _path) <= selector.value.value;
              };
            case '<':
              return function (node) {
                return getPath(node, _path) < selector.value.value;
              };
            case '>':
              return function (node) {
                return getPath(node, _path) > selector.value.value;
              };
            case '>=':
              return function (node) {
                return getPath(node, _path) >= selector.value.value;
              };
          }
          throw new Error("Unknown operator: ".concat(selector.operator));
        }
      case 'sibling':
        {
          var _left2 = getMatcher(selector.left);
          var _right2 = getMatcher(selector.right);
          return function (node, ancestry, options) {
            return _right2(node, ancestry, options) && sibling(node, _left2, ancestry, LEFT_SIDE, options) || selector.left.subject && _left2(node, ancestry, options) && sibling(node, _right2, ancestry, RIGHT_SIDE, options);
          };
        }
      case 'adjacent':
        {
          var _left3 = getMatcher(selector.left);
          var _right3 = getMatcher(selector.right);
          return function (node, ancestry, options) {
            return _right3(node, ancestry, options) && adjacent(node, _left3, ancestry, LEFT_SIDE, options) || selector.right.subject && _left3(node, ancestry, options) && adjacent(node, _right3, ancestry, RIGHT_SIDE, options);
          };
        }
      case 'nth-child':
        {
          var nth = selector.index.value;
          var _right4 = getMatcher(selector.right);
          return function (node, ancestry, options) {
            return _right4(node, ancestry, options) && nthChild(node, ancestry, nth, options);
          };
        }
      case 'nth-last-child':
        {
          var _nth = -selector.index.value;
          var _right5 = getMatcher(selector.right);
          return function (node, ancestry, options) {
            return _right5(node, ancestry, options) && nthChild(node, ancestry, _nth, options);
          };
        }
      case 'class':
        {
          return function (node, ancestry, options) {
            if (options && options.matchClass) {
              return options.matchClass(selector.name, node, ancestry);
            }
            if (options && options.nodeTypeKey) return false;
            var name = selector.name.toLowerCase();
            switch (name) {
              case 'statement':
                if (node.type.slice(-9) === 'Statement') return true;
              // fallthrough: interface Declaration <: Statement { }
              case 'declaration':
                return node.type.slice(-11) === 'Declaration';
              case 'pattern':
                if (node.type.slice(-7) === 'Pattern') return true;
              // fallthrough: interface Expression <: Node, Pattern { }
              case 'expression':
                return node.type.slice(-10) === 'Expression' || node.type.slice(-7) === 'Literal' || node.type === 'Identifier' && (ancestry.length === 0 || ancestry[0].type !== 'MetaProperty') || node.type === 'MetaProperty';
              case 'function':
                return node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
            }
            throw new Error("Unknown class name: ".concat(selector.name));
          };
        }
    }
    throw new Error("Unknown selector type: ".concat(selector.type));
  }

/**
   * @callback TraverseOptionFallback
   * @param {external:AST} node The given node.
   * @returns {string[]} An array of visitor keys for the given node.
   */

/**
   * @callback ClassMatcher
   * @param {string} className The name of the class to match.
   * @param {external:AST} node The node to match against.
   * @param {Array<external:AST>} ancestry The ancestry of the node.
   * @returns {boolean} True if the node matches the class, false if not.
   */

/**
   * @typedef {object} ESQueryOptions
   * @property {string} [nodeTypeKey="type"] By passing `nodeTypeKey`, we can allow other ASTs to use ESQuery.
   * @property { { [nodeType: string]: string[] } } [visitorKeys] By passing `visitorKeys` mapping, we can extend the properties of the nodes that traverse the node.
   * @property {TraverseOptionFallback} [fallback] By passing `fallback` option, we can control the properties of traversing nodes when encountering unknown nodes.
   * @property {ClassMatcher} [matchClass] By passing `matchClass` option, we can customize the interpretation of classes.
   */

/**
   * Given a `node` and its ancestors, determine if `node` is matched
   * by `selector`.
   * @param {?external:AST} node
   * @param {?SelectorAST} selector
   * @param {external:AST[]} [ancestry=[]]
   * @param {ESQueryOptions} [options]
   * @throws {Error} Unknowns (operator, class name, selector type, or
   * selector value type)
   * @returns {boolean}
   */
  function matches(node, selector, ancestry, options) {
    if (!selector) {
      return true;
    }
    if (!node) {
      return false;
    }
    if (!ancestry) {
      ancestry = [];
    }
    return getMatcher(selector)(node, ancestry, options);
  }

/**
   * Get visitor keys of a given node.
   * @param {external:AST} node The AST node to get keys.
   * @param {ESQueryOptions|undefined} options
   * @returns {string[]} Visitor keys of the node.
   */
  function getVisitorKeys(node, options) {
    var nodeTypeKey = options && options.nodeTypeKey || 'type';
    var nodeType = node[nodeTypeKey];
    if (options && options.visitorKeys && options.visitorKeys[nodeType]) {
      return options.visitorKeys[nodeType];
    }
    if (estraverse.VisitorKeys[nodeType]) {
      return estraverse.VisitorKeys[nodeType];
    }
    if (options && typeof options.fallback === 'function') {
      return options.fallback(node);
    }
    // 'iteration' fallback
    return Object.keys(node).filter(function (key) {
      return key !== nodeTypeKey;
    });
  }

/**
   * Check whether the given value is an ASTNode or not.
   * @param {any} node The value to check.
   * @param {ESQueryOptions|undefined} options The options to use.
   * @returns {boolean} `true` if the value is an ASTNode.
   */
  function isNode(node, options) {
    var nodeTypeKey = options && options.nodeTypeKey || 'type';
    return node !== null && _typeof(node) === 'object' && typeof node[nodeTypeKey] === 'string';
  }

/**
   * Determines if the given node has a sibling that matches the
   * given selector matcher.
   * @param {external:AST} node
   * @param {SelectorMatcher} matcher
   * @param {external:AST[]} ancestry
   * @param {Side} side
   * @param {ESQueryOptions|undefined} options
   * @returns {boolean}
   */
  function sibling(node, matcher, ancestry, side, options) {
    var _ancestry = _slicedToArray(ancestry, 1),
      parent = _ancestry[0];
    if (!parent) {
      return false;
    }
    var keys = getVisitorKeys(parent, options);
    for (var i = 0; i < keys.length; ++i) {
      var listProp = parent[keys[i]];
      if (Array.isArray(listProp)) {
        var startIndex = listProp.indexOf(node);
        if (startIndex < 0) {
          continue;
        }
        var lowerBound = void 0,
          upperBound = void 0;
        if (side === LEFT_SIDE) {
          lowerBound = 0;
          upperBound = startIndex;
        } else {
          lowerBound = startIndex + 1;
          upperBound = listProp.length;
        }
        for (var k = lowerBound; k < upperBound; ++k) {
          if (isNode(listProp[k], options) && matcher(listProp[k], ancestry, options)) {
            return true;
          }
        }
      }
    }
    return false;
  }

/**
   * Determines if the given node has an adjacent sibling that matches
   * the given selector matcher.
   * @param {external:AST} node
   * @param {SelectorMatcher} matcher
   * @param {external:AST[]} ancestry
   * @param {Side} side
   * @param {ESQueryOptions|undefined} options
   * @returns {boolean}
   */
  function adjacent(node, matcher, ancestry, side, options) {
    var _ancestry2 = _slicedToArray(ancestry, 1),
      parent = _ancestry2[0];
    if (!parent) {
      return false;
    }
    var keys = getVisitorKeys(parent, options);
    for (var i = 0; i < keys.length; ++i) {
      var listProp = parent[keys[i]];
      if (Array.isArray(listProp)) {
        var idx = listProp.indexOf(node);
        if (idx < 0) {
          continue;
        }
        if (side === LEFT_SIDE && idx > 0 && isNode(listProp[idx - 1], options) && matcher(listProp[idx - 1], ancestry, options)) {
          return true;
        }
        if (side === RIGHT_SIDE && idx < listProp.length - 1 && isNode(listProp[idx + 1], options) && matcher(listProp[idx + 1], ancestry, options)) {
          return true;
        }
      }
    }
    return false;
  }

/**
   * Determines if the given node is the `nth` child.
   * If `nth` is negative then the position is counted
   * from the end of the list of children.
   * @param {external:AST} node
   * @param {external:AST[]} ancestry
   * @param {Integer} nth
   * @param {ESQueryOptions|undefined} options
   * @returns {boolean}
   */
  function nthChild(node, ancestry, nth, options) {
    if (nth === 0) {
      return false;
    }
    var _ancestry3 = _slicedToArray(ancestry, 1),
      parent = _ancestry3[0];
    if (!parent) {
      return false;
    }
    var keys = getVisitorKeys(parent, options);
    for (var i = 0; i < keys.length; ++i) {
      var listProp = parent[keys[i]];
      if (Array.isArray(listProp)) {
        var idx = nth < 0 ? listProp.length + nth : nth - 1;
        if (idx >= 0 && idx < listProp.length && listProp[idx] === node) {
          return true;
        }
      }
    }
    return false;
  }

/**
   * For each selector node marked as a subject, find the portion of the
   * selector that the subject must match.
   * @param {SelectorAST} selector
   * @param {SelectorAST} [ancestor] Defaults to `selector`
   * @returns {SelectorAST[]}
   */
  function subjects(selector, ancestor) {
    if (selector == null || _typeof(selector) != 'object') {
      return [];
    }
    if (ancestor == null) {
      ancestor = selector;
    }
    var results = selector.subject ? [ancestor] : [];
    var keys = Object.keys(selector);
    for (var i = 0; i < keys.length; ++i) {
      var p = keys[i];
      var sel = selector[p];
      results.push.apply(results, _toConsumableArray(subjects(sel, p === 'left' ? sel : ancestor)));
    }
    return results;
  }

/**
  * @callback TraverseVisitor
  * @param {?external:AST} node
  * @param {?external:AST} parent
  * @param {external:AST[]} ancestry
  */

/**
   * From a JS AST and a selector AST, collect all JS AST nodes that
   * match the selector.
   * @param {external:AST} ast
   * @param {?SelectorAST} selector
   * @param {TraverseVisitor} visitor
   * @param {ESQueryOptions} [options]
   * @returns {external:AST[]}
   */
  function traverse(ast, selector, visitor, options) {
    if (!selector) {
      return;
    }
    var ancestry = [];
    var matcher = getMatcher(selector);
    var altSubjects = subjects(selector).map(getMatcher);
    estraverse.traverse(ast, {
      enter: function enter(node, parent) {
        if (parent != null) {
          ancestry.unshift(parent);
        }
        if (matcher(node, ancestry, options)) {
          if (altSubjects.length) {
            for (var i = 0, l = altSubjects.length; i < l; ++i) {
              if (altSubjects[i](node, ancestry, options)) {
                visitor(node, parent, ancestry);
              }
              for (var k = 0, m = ancestry.length; k < m; ++k) {
                var succeedingAncestry = ancestry.slice(k + 1);
                if (altSubjects[i](ancestry[k], succeedingAncestry, options)) {
                  visitor(ancestry[k], parent, succeedingAncestry);
                }
              }
            }
          } else {
            visitor(node, parent, ancestry);
          }
        }
      },
      leave: function leave() {
        ancestry.shift();
      },
      keys: options && options.visitorKeys,
      fallback: options && options.fallback || 'iteration'
    });
  }

/**
   * From a JS AST and a selector AST, collect all JS AST nodes that
   * match the selector.
   * @param {external:AST} ast
   * @param {?SelectorAST} selector
   * @param {ESQueryOptions} [options]
   * @returns {external:AST[]}
   */
  function match(ast, selector, options) {
    var results = [];
    traverse(ast, selector, function (node) {
      results.push(node);
    }, options);
    return results;
  }

/**
   * Parse a selector string and return its AST.
   * @param {string} selector
   * @returns {SelectorAST}
   */
  function parse(selector) {
    return parser.parse(selector);
  }

/**
   * Query the code AST using the selector string.
   * @param {external:AST} ast
   * @param {string} selector
   * @param {ESQueryOptions} [options]
   * @returns {external:AST[]}
   */
  function query(ast, selector, options) {
    return match(ast, parse(selector), options);
  }
  query.parse = parse;
  query.match = match;
  query.traverse = traverse;
  query.matches = matches;
  query.query = query;

return query;

})));

Back to Directory File Manager