Gecko [ gandhischool.edu.np ]

Name	Size	Permission
esquery.esm.js	122.05 KB	-rw-rw-rw-
esquery.esm.min.js	34.34 KB	-rw-rw-rw-
esquery.esm.min.js.map	175.07 KB	-rw-rw-rw-
esquery.js	130.36 KB	-rw-rw-rw-
esquery.lite.js	105.42 KB	-rw-rw-rw-
esquery.lite.min.js	24.23 KB	-rw-rw-rw-
esquery.lite.min.js.map	135.16 KB	-rw-rw-rw-
esquery.min.js	34.51 KB	-rw-rw-rw-
esquery.min.js.map	175.07 KB	-rw-rw-rw-

Code Editor : esquery.esm.js

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 estraverse = createCommonjsModule(function (module, exports) {
  /*
    Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
    Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
  
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions are met:
  
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
  
    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
    AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
    ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
  /*jslint vars:false, bitwise:true*/
  /*jshint indent:4*/
  /*global exports:true*/
  (function clone(exports) {

var Syntax, VisitorOption, VisitorKeys, BREAK, SKIP, REMOVE;
    function deepCopy(obj) {
      var ret = {},
        key,
        val;
      for (key in obj) {
        if (obj.hasOwnProperty(key)) {
          val = obj[key];
          if (typeof val === 'object' && val !== null) {
            ret[key] = deepCopy(val);
          } else {
            ret[key] = val;
          }
        }
      }
      return ret;
    }

// based on LLVM libc++ upper_bound / lower_bound
    // MIT License

// unique id
    BREAK = {};
    SKIP = {};
    REMOVE = {};
    VisitorOption = {
      Break: BREAK,
      Skip: SKIP,
      Remove: REMOVE
    };
    function Reference(parent, key) {
      this.parent = parent;
      this.key = key;
    }
    Reference.prototype.replace = function replace(node) {
      this.parent[this.key] = node;
    };
    Reference.prototype.remove = function remove() {
      if (Array.isArray(this.parent)) {
        this.parent.splice(this.key, 1);
        return true;
      } else {
        this.replace(null);
        return false;
      }
    };
    function Element(node, path, wrap, ref) {
      this.node = node;
      this.path = path;
      this.wrap = wrap;
      this.ref = ref;
    }
    function Controller() {}

// API:
    // return property path array from root to current node
    Controller.prototype.path = function path() {
      var i, iz, j, jz, result, element;
      function addToPath(result, path) {
        if (Array.isArray(path)) {
          for (j = 0, jz = path.length; j < jz; ++j) {
            result.push(path[j]);
          }
        } else {
          result.push(path);
        }
      }

// root node
      if (!this.__current.path) {
        return null;
      }

// first node is sentinel, second node is root element
      result = [];
      for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
        element = this.__leavelist[i];
        addToPath(result, element.path);
      }
      addToPath(result, this.__current.path);
      return result;
    };

// API:
    // return type of current node
    Controller.prototype.type = function () {
      var node = this.current();
      return node.type || this.__current.wrap;
    };

// API:
    // return array of parent elements
    Controller.prototype.parents = function parents() {
      var i, iz, result;

// first node is sentinel
      result = [];
      for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
        result.push(this.__leavelist[i].node);
      }
      return result;
    };

// API:
    // return current node
    Controller.prototype.current = function current() {
      return this.__current.node;
    };
    Controller.prototype.__execute = function __execute(callback, element) {
      var previous, result;
      result = undefined;
      previous = this.__current;
      this.__current = element;
      this.__state = null;
      if (callback) {
        result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
      }
      this.__current = previous;
      return result;
    };

// API:
    // notify control skip / break
    Controller.prototype.notify = function notify(flag) {
      this.__state = flag;
    };

// API:
    // skip child nodes of current node
    Controller.prototype.skip = function () {
      this.notify(SKIP);
    };

// API:
    // break traversals
    Controller.prototype['break'] = function () {
      this.notify(BREAK);
    };

// API:
    // remove node
    Controller.prototype.remove = function () {
      this.notify(REMOVE);
    };
    Controller.prototype.__initialize = function (root, visitor) {
      this.visitor = visitor;
      this.root = root;
      this.__worklist = [];
      this.__leavelist = [];
      this.__current = null;
      this.__state = null;
      this.__fallback = null;
      if (visitor.fallback === 'iteration') {
        this.__fallback = Object.keys;
      } else if (typeof visitor.fallback === 'function') {
        this.__fallback = visitor.fallback;
      }
      this.__keys = VisitorKeys;
      if (visitor.keys) {
        this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
      }
    };
    function isNode(node) {
      if (node == null) {
        return false;
      }
      return typeof node === 'object' && typeof node.type === 'string';
    }
    function isProperty(nodeType, key) {
      return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
    }
    function candidateExistsInLeaveList(leavelist, candidate) {
      for (var i = leavelist.length - 1; i >= 0; --i) {
        if (leavelist[i].node === candidate) {
          return true;
        }
      }
      return false;
    }
    Controller.prototype.traverse = function traverse(root, visitor) {
      var worklist, leavelist, element, node, nodeType, ret, key, current, current2, candidates, candidate, sentinel;
      this.__initialize(root, visitor);
      sentinel = {};

// reference
      worklist = this.__worklist;
      leavelist = this.__leavelist;

// initialize
      worklist.push(new Element(root, null, null, null));
      leavelist.push(new Element(null, null, null, null));
      while (worklist.length) {
        element = worklist.pop();
        if (element === sentinel) {
          element = leavelist.pop();
          ret = this.__execute(visitor.leave, element);
          if (this.__state === BREAK || ret === BREAK) {
            return;
          }
          continue;
        }
        if (element.node) {
          ret = this.__execute(visitor.enter, element);
          if (this.__state === BREAK || ret === BREAK) {
            return;
          }
          worklist.push(sentinel);
          leavelist.push(element);
          if (this.__state === SKIP || ret === SKIP) {
            continue;
          }
          node = element.node;
          nodeType = node.type || element.wrap;
          candidates = this.__keys[nodeType];
          if (!candidates) {
            if (this.__fallback) {
              candidates = this.__fallback(node);
            } else {
              throw new Error('Unknown node type ' + nodeType + '.');
            }
          }
          current = candidates.length;
          while ((current -= 1) >= 0) {
            key = candidates[current];
            candidate = node[key];
            if (!candidate) {
              continue;
            }
            if (Array.isArray(candidate)) {
              current2 = candidate.length;
              while ((current2 -= 1) >= 0) {
                if (!candidate[current2]) {
                  continue;
                }
                if (candidateExistsInLeaveList(leavelist, candidate[current2])) {
                  continue;
                }
                if (isProperty(nodeType, candidates[current])) {
                  element = new Element(candidate[current2], [key, current2], 'Property', null);
                } else if (isNode(candidate[current2])) {
                  element = new Element(candidate[current2], [key, current2], null, null);
                } else {
                  continue;
                }
                worklist.push(element);
              }
            } else if (isNode(candidate)) {
              if (candidateExistsInLeaveList(leavelist, candidate)) {
                continue;
              }
              worklist.push(new Element(candidate, key, null, null));
            }
          }
        }
      }
    };
    Controller.prototype.replace = function replace(root, visitor) {
      var worklist, leavelist, node, nodeType, target, element, current, current2, candidates, candidate, sentinel, outer, key;
      function removeElem(element) {
        var i, key, nextElem, parent;
        if (element.ref.remove()) {
          // When the reference is an element of an array.
          key = element.ref.key;
          parent = element.ref.parent;

// If removed from array, then decrease following items' keys.
          i = worklist.length;
          while (i--) {
            nextElem = worklist[i];
            if (nextElem.ref && nextElem.ref.parent === parent) {
              if (nextElem.ref.key < key) {
                break;
              }
              --nextElem.ref.key;
            }
          }
        }
      }
      this.__initialize(root, visitor);
      sentinel = {};

// reference
      worklist = this.__worklist;
      leavelist = this.__leavelist;

// initialize
      outer = {
        root: root
      };
      element = new Element(root, null, null, new Reference(outer, 'root'));
      worklist.push(element);
      leavelist.push(element);
      while (worklist.length) {
        element = worklist.pop();
        if (element === sentinel) {
          element = leavelist.pop();
          target = this.__execute(visitor.leave, element);

// node may be replaced with null,
          // so distinguish between undefined and null in this place
          if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
            // replace
            element.ref.replace(target);
          }
          if (this.__state === REMOVE || target === REMOVE) {
            removeElem(element);
          }
          if (this.__state === BREAK || target === BREAK) {
            return outer.root;
          }
          continue;
        }
        target = this.__execute(visitor.enter, element);

// node may be replaced with null,
        // so distinguish between undefined and null in this place
        if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
          // replace
          element.ref.replace(target);
          element.node = target;
        }
        if (this.__state === REMOVE || target === REMOVE) {
          removeElem(element);
          element.node = null;
        }
        if (this.__state === BREAK || target === BREAK) {
          return outer.root;
        }

// node may be null
        node = element.node;
        if (!node) {
          continue;
        }
        worklist.push(sentinel);
        leavelist.push(element);
        if (this.__state === SKIP || target === SKIP) {
          continue;
        }
        nodeType = node.type || element.wrap;
        candidates = this.__keys[nodeType];
        if (!candidates) {
          if (this.__fallback) {
            candidates = this.__fallback(node);
          } else {
            throw new Error('Unknown node type ' + nodeType + '.');
          }
        }
        current = candidates.length;
        while ((current -= 1) >= 0) {
          key = candidates[current];
          candidate = node[key];
          if (!candidate) {
            continue;
          }
          if (Array.isArray(candidate)) {
            current2 = candidate.length;
            while ((current2 -= 1) >= 0) {
              if (!candidate[current2]) {
                continue;
              }
              if (isProperty(nodeType, candidates[current])) {
                element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
              } else if (isNode(candidate[current2])) {
                element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
              } else {
                continue;
              }
              worklist.push(element);
            }
          } else if (isNode(candidate)) {
            worklist.push(new Element(candidate, key, null, new Reference(node, key)));
          }
        }
      }
      return outer.root;
    };
    function traverse(root, visitor) {
      var controller = new Controller();
      return controller.traverse(root, visitor);
    }
    function replace(root, visitor) {
      var controller = new Controller();
      return controller.replace(root, visitor);
    }
    function extendCommentRange(comment, tokens) {
      var target;
      target = upperBound(tokens, function search(token) {
        return token.range[0] > comment.range[0];
      });
      comment.extendedRange = [comment.range[0], comment.range[1]];
      if (target !== tokens.length) {
        comment.extendedRange[1] = tokens[target].range[0];
      }
      target -= 1;
      if (target >= 0) {
        comment.extendedRange[0] = tokens[target].range[1];
      }
      return comment;
    }
    function attachComments(tree, providedComments, tokens) {
      // At first, we should calculate extended comment ranges.
      var comments = [],
        comment,
        len,
        i,
        cursor;
      if (!tree.range) {
        throw new Error('attachComments needs range information');
      }

// tokens array is empty, we attach comments to tree as 'leadingComments'
      if (!tokens.length) {
        if (providedComments.length) {
          for (i = 0, len = providedComments.length; i < len; i += 1) {
            comment = deepCopy(providedComments[i]);
            comment.extendedRange = [0, tree.range[0]];
            comments.push(comment);
          }
          tree.leadingComments = comments;
        }
        return tree;
      }
      for (i = 0, len = providedComments.length; i < len; i += 1) {
        comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
      }

// This is based on John Freeman's implementation.
      cursor = 0;
      traverse(tree, {
        enter: function (node) {
          var comment;
          while (cursor < comments.length) {
            comment = comments[cursor];
            if (comment.extendedRange[1] > node.range[0]) {
              break;
            }
            if (comment.extendedRange[1] === node.range[0]) {
              if (!node.leadingComments) {
                node.leadingComments = [];
              }
              node.leadingComments.push(comment);
              comments.splice(cursor, 1);
            } else {
              cursor += 1;
            }
          }

// already out of owned node
          if (cursor === comments.length) {
            return VisitorOption.Break;
          }
          if (comments[cursor].extendedRange[0] > node.range[1]) {
            return VisitorOption.Skip;
          }
        }
      });
      cursor = 0;
      traverse(tree, {
        leave: function (node) {
          var comment;
          while (cursor < comments.length) {
            comment = comments[cursor];
            if (node.range[1] < comment.extendedRange[0]) {
              break;
            }
            if (node.range[1] === comment.extendedRange[0]) {
              if (!node.trailingComments) {
                node.trailingComments = [];
              }
              node.trailingComments.push(comment);
              comments.splice(cursor, 1);
            } else {
              cursor += 1;
            }
          }

// already out of owned node
          if (cursor === comments.length) {
            return VisitorOption.Break;
          }
          if (comments[cursor].extendedRange[0] > node.range[1]) {
            return VisitorOption.Skip;
          }
        }
      });
      return tree;
    }
    exports.Syntax = Syntax;
    exports.traverse = traverse;
    exports.replace = replace;
    exports.attachComments = attachComments;
    exports.VisitorKeys = VisitorKeys;
    exports.VisitorOption = VisitorOption;
    exports.Controller = Controller;
    exports.cloneEnvironment = function () {
      return clone({});
    };
    return exports;
  })(exports);
  /* vim: set sw=4 ts=4 et tw=80 : */
});

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.
 * @callback SelectorMatcher
 * @param {?SelectorAST} selector
 * @param {external:AST[]} [ancestry=[]]
 * @param {ESQueryOptions} [options]
 * @returns {void}
*/

/**
 * 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 'exactNode':
      return function (node, ancestry) {
        return ancestry.length === 0;
      };
    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':
      {
        var name = selector.name.toLowerCase();
        return function (node, ancestry, options) {
          if (options && options.matchClass) {
            return options.matchClass(selector.name, node, ancestry);
          }
          if (options && options.nodeTypeKey) return false;
          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;

export default query;

${this.title}

Code Editor : esquery.esm.js