File Manager

Editing File: /home/ubuntu/route-and-root-frontend-base/node_modules/esquery/dist/esquery.esm.js

function _typeof(obj) {
  "@babel/helpers - typeof";

if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

return _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" && Symbol.iterator in Object(iter)) return Array.from(iter);
}

function _iterableToArrayLimit(arr, i) {
  if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
  var _arr = [];
  var _n = true;
  var _d = false;
  var _e = undefined;

try {
    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
      _arr.push(_s.value);

if (i && _arr.length === i) break;
    }
  } catch (err) {
    _d = true;
    _e = err;
  } finally {
    try {
      if (!_n && _i["return"] != null) _i["return"]();
    } finally {
      if (_d) throw _e;
    }
  }

return _arr;
}

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.");
}

function _createForOfIteratorHelper(o, allowArrayLike) {
  var it;

if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
      if (it) o = it;
      var i = 0;

var F = function () {};

return {
        s: F,
        n: function () {
          if (i >= o.length) return {
            done: true
          };
          return {
            done: false,
            value: o[i++]
          };
        },
        e: function (e) {
          throw e;
        },
        f: F
      };
    }

throw new TypeError("Invalid attempt to iterate 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

function upperBound(array, func) {
      var diff, len, i, current;
      len = array.length;
      i = 0;

while (len) {
        diff = len >>> 1;
        current = i + diff;

if (func(array[current])) {
          len = diff;
        } else {
          i = current + 1;
          len -= diff + 1;
        }
      }

return i;
    }

Syntax = {
      AssignmentExpression: 'AssignmentExpression',
      AssignmentPattern: 'AssignmentPattern',
      ArrayExpression: 'ArrayExpression',
      ArrayPattern: 'ArrayPattern',
      ArrowFunctionExpression: 'ArrowFunctionExpression',
      AwaitExpression: 'AwaitExpression',
      // CAUTION: It's deferred to ES7.
      BlockStatement: 'BlockStatement',
      BinaryExpression: 'BinaryExpression',
      BreakStatement: 'BreakStatement',
      CallExpression: 'CallExpression',
      CatchClause: 'CatchClause',
      ChainExpression: 'ChainExpression',
      ClassBody: 'ClassBody',
      ClassDeclaration: 'ClassDeclaration',
      ClassExpression: 'ClassExpression',
      ComprehensionBlock: 'ComprehensionBlock',
      // CAUTION: It's deferred to ES7.
      ComprehensionExpression: 'ComprehensionExpression',
      // CAUTION: It's deferred to ES7.
      ConditionalExpression: 'ConditionalExpression',
      ContinueStatement: 'ContinueStatement',
      DebuggerStatement: 'DebuggerStatement',
      DirectiveStatement: 'DirectiveStatement',
      DoWhileStatement: 'DoWhileStatement',
      EmptyStatement: 'EmptyStatement',
      ExportAllDeclaration: 'ExportAllDeclaration',
      ExportDefaultDeclaration: 'ExportDefaultDeclaration',
      ExportNamedDeclaration: 'ExportNamedDeclaration',
      ExportSpecifier: 'ExportSpecifier',
      ExpressionStatement: 'ExpressionStatement',
      ForStatement: 'ForStatement',
      ForInStatement: 'ForInStatement',
      ForOfStatement: 'ForOfStatement',
      FunctionDeclaration: 'FunctionDeclaration',
      FunctionExpression: 'FunctionExpression',
      GeneratorExpression: 'GeneratorExpression',
      // CAUTION: It's deferred to ES7.
      Identifier: 'Identifier',
      IfStatement: 'IfStatement',
      ImportExpression: 'ImportExpression',
      ImportDeclaration: 'ImportDeclaration',
      ImportDefaultSpecifier: 'ImportDefaultSpecifier',
      ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
      ImportSpecifier: 'ImportSpecifier',
      Literal: 'Literal',
      LabeledStatement: 'LabeledStatement',
      LogicalExpression: 'LogicalExpression',
      MemberExpression: 'MemberExpression',
      MetaProperty: 'MetaProperty',
      MethodDefinition: 'MethodDefinition',
      ModuleSpecifier: 'ModuleSpecifier',
      NewExpression: 'NewExpression',
      ObjectExpression: 'ObjectExpression',
      ObjectPattern: 'ObjectPattern',
      Program: 'Program',
      Property: 'Property',
      RestElement: 'RestElement',
      ReturnStatement: 'ReturnStatement',
      SequenceExpression: 'SequenceExpression',
      SpreadElement: 'SpreadElement',
      Super: 'Super',
      SwitchStatement: 'SwitchStatement',
      SwitchCase: 'SwitchCase',
      TaggedTemplateExpression: 'TaggedTemplateExpression',
      TemplateElement: 'TemplateElement',
      TemplateLiteral: 'TemplateLiteral',
      ThisExpression: 'ThisExpression',
      ThrowStatement: 'ThrowStatement',
      TryStatement: 'TryStatement',
      UnaryExpression: 'UnaryExpression',
      UpdateExpression: 'UpdateExpression',
      VariableDeclaration: 'VariableDeclaration',
      VariableDeclarator: 'VariableDeclarator',
      WhileStatement: 'WhileStatement',
      WithStatement: 'WithStatement',
      YieldExpression: 'YieldExpression'
    };
    VisitorKeys = {
      AssignmentExpression: ['left', 'right'],
      AssignmentPattern: ['left', 'right'],
      ArrayExpression: ['elements'],
      ArrayPattern: ['elements'],
      ArrowFunctionExpression: ['params', 'body'],
      AwaitExpression: ['argument'],
      // CAUTION: It's deferred to ES7.
      BlockStatement: ['body'],
      BinaryExpression: ['left', 'right'],
      BreakStatement: ['label'],
      CallExpression: ['callee', 'arguments'],
      CatchClause: ['param', 'body'],
      ChainExpression: ['expression'],
      ClassBody: ['body'],
      ClassDeclaration: ['id', 'superClass', 'body'],
      ClassExpression: ['id', 'superClass', 'body'],
      ComprehensionBlock: ['left', 'right'],
      // CAUTION: It's deferred to ES7.
      ComprehensionExpression: ['blocks', 'filter', 'body'],
      // CAUTION: It's deferred to ES7.
      ConditionalExpression: ['test', 'consequent', 'alternate'],
      ContinueStatement: ['label'],
      DebuggerStatement: [],
      DirectiveStatement: [],
      DoWhileStatement: ['body', 'test'],
      EmptyStatement: [],
      ExportAllDeclaration: ['source'],
      ExportDefaultDeclaration: ['declaration'],
      ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
      ExportSpecifier: ['exported', 'local'],
      ExpressionStatement: ['expression'],
      ForStatement: ['init', 'test', 'update', 'body'],
      ForInStatement: ['left', 'right', 'body'],
      ForOfStatement: ['left', 'right', 'body'],
      FunctionDeclaration: ['id', 'params', 'body'],
      FunctionExpression: ['id', 'params', 'body'],
      GeneratorExpression: ['blocks', 'filter', 'body'],
      // CAUTION: It's deferred to ES7.
      Identifier: [],
      IfStatement: ['test', 'consequent', 'alternate'],
      ImportExpression: ['source'],
      ImportDeclaration: ['specifiers', 'source'],
      ImportDefaultSpecifier: ['local'],
      ImportNamespaceSpecifier: ['local'],
      ImportSpecifier: ['imported', 'local'],
      Literal: [],
      LabeledStatement: ['label', 'body'],
      LogicalExpression: ['left', 'right'],
      MemberExpression: ['object', 'property'],
      MetaProperty: ['meta', 'property'],
      MethodDefinition: ['key', 'value'],
      ModuleSpecifier: [],
      NewExpression: ['callee', 'arguments'],
      ObjectExpression: ['properties'],
      ObjectPattern: ['properties'],
      Program: ['body'],
      Property: ['key', 'value'],
      RestElement: ['argument'],
      ReturnStatement: ['argument'],
      SequenceExpression: ['expressions'],
      SpreadElement: ['argument'],
      Super: [],
      SwitchStatement: ['discriminant', 'cases'],
      SwitchCase: ['test', 'consequent'],
      TaggedTemplateExpression: ['tag', 'quasi'],
      TemplateElement: [],
      TemplateLiteral: ['quasis', 'expressions'],
      ThisExpression: [],
      ThrowStatement: ['argument'],
      TryStatement: ['block', 'handler', 'finalizer'],
      UnaryExpression: ['argument'],
      UpdateExpression: ['argument'],
      VariableDeclaration: ['declarations'],
      VariableDeclarator: ['id', 'init'],
      WhileStatement: ['test', 'body'],
      WithStatement: ['object', 'body'],
      YieldExpression: ['argument']
    }; // 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;

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 () {

function peg$subclass(child, parent) {
      function ctor() {
        this.constructor = child;
      }

ctor.prototype = parent.prototype;
      child.prototype = new ctor();
    }

function peg$SyntaxError(message, expected, found, location) {
      this.message = message;
      this.expected = expected;
      this.found = found;
      this.location = location;
      this.name = "SyntaxError";

if (typeof Error.captureStackTrace === "function") {
        Error.captureStackTrace(this, peg$SyntaxError);
      }
    }

peg$subclass(peg$SyntaxError, Error);

peg$SyntaxError.buildMessage = function (expected, found) {
      var DESCRIBE_EXPECTATION_FNS = {
        literal: function literal(expectation) {
          return "\"" + literalEscape(expectation.text) + "\"";
        },
        "class": function _class(expectation) {
          var escapedParts = "",
              i;

for (i = 0; i < expectation.parts.length; i++) {
            escapedParts += expectation.parts[i] instanceof Array ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1]) : classEscape(expectation.parts[i]);
          }

return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
        },
        any: function any(expectation) {
          return "any character";
        },
        end: function end(expectation) {
          return "end of input";
        },
        other: function other(expectation) {
          return expectation.description;
        }
      };

function hex(ch) {
        return ch.charCodeAt(0).toString(16).toUpperCase();
      }

function describeExpectation(expectation) {
        return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
      }

function describeExpected(expected) {
        var descriptions = new Array(expected.length),
            i,
            j;

for (i = 0; i < expected.length; i++) {
          descriptions[i] = describeExpectation(expected[i]);
        }

descriptions.sort();

if (descriptions.length > 0) {
          for (i = 1, j = 1; i < descriptions.length; i++) {
            if (descriptions[i - 1] !== descriptions[i]) {
              descriptions[j] = descriptions[i];
              j++;
            }
          }

descriptions.length = j;
        }

switch (descriptions.length) {
          case 1:
            return descriptions[0];

case 2:
            return descriptions[0] + " or " + descriptions[1];

default:
            return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
        }
      }

function describeFound(found) {
        return found ? "\"" + literalEscape(found) + "\"" : "end of input";
      }

return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
    };

function peg$parse(input, options) {
      options = options !== void 0 ? options : {};

if ("startRule" in options) {
        if (!(options.startRule in peg$startRuleFunctions)) {
          throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
        }

peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
      }

function peg$literalExpectation(text, ignoreCase) {
        return {
          type: "literal",
          text: text,
          ignoreCase: ignoreCase
        };
      }

function peg$classExpectation(parts, inverted, ignoreCase) {
        return {
          type: "class",
          parts: parts,
          inverted: inverted,
          ignoreCase: ignoreCase
        };
      }

function peg$anyExpectation() {
        return {
          type: "any"
        };
      }

function peg$endExpectation() {
        return {
          type: "end"
        };
      }

function peg$computePosDetails(pos) {
        var details = peg$posDetailsCache[pos],
            p;

if (details) {
          return details;
        } else {
          p = pos - 1;

while (!peg$posDetailsCache[p]) {
            p--;
          }

details = peg$posDetailsCache[p];
          details = {
            line: details.line,
            column: details.column
          };

while (p < pos) {
            if (input.charCodeAt(p) === 10) {
              details.line++;
              details.column = 1;
            } else {
              details.column++;
            }

p++;
          }

peg$posDetailsCache[pos] = details;
          return details;
        }
      }

function peg$computeLocation(startPos, endPos) {
        var startPosDetails = peg$computePosDetails(startPos),
            endPosDetails = peg$computePosDetails(endPos);
        return {
          start: {
            offset: startPos,
            line: startPosDetails.line,
            column: startPosDetails.column
          },
          end: {
            offset: endPos,
            line: endPosDetails.line,
            column: endPosDetails.column
          }
        };
      }

function peg$fail(expected) {
        if (peg$currPos < peg$maxFailPos) {
          return;
        }

if (peg$currPos > peg$maxFailPos) {
          peg$maxFailPos = peg$currPos;
          peg$maxFailExpected = [];
        }

peg$maxFailExpected.push(expected);
      }

function peg$buildStructuredError(expected, found, location) {
        return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
      }

function peg$parsestart() {
        var s0, s1, s2, s3;
        var key = peg$currPos * 30 + 0,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;
        s1 = peg$parse_();

if (s1 !== peg$FAILED) {
          s2 = peg$parseselectors();

if (s2 !== peg$FAILED) {
            s3 = peg$parse_();

if (s3 !== peg$FAILED) {
              s1 = peg$c0(s2);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          s1 = peg$parse_();

if (s1 !== peg$FAILED) {
            s1 = peg$c1();
          }

s0 = s1;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parse_() {
        var s0, s1;
        var key = peg$currPos * 30 + 1,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = [];

if (input.charCodeAt(peg$currPos) === 32) {
          s1 = peg$c2;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c3);
          }
        }

while (s1 !== peg$FAILED) {
          s0.push(s1);

if (input.charCodeAt(peg$currPos) === 32) {
            s1 = peg$c2;
            peg$currPos++;
          } else {
            s1 = peg$FAILED;

{
              peg$fail(peg$c3);
            }
          }
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseidentifierName() {
        var s0, s1, s2;
        var key = peg$currPos * 30 + 2,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;
        s1 = [];

if (peg$c4.test(input.charAt(peg$currPos))) {
          s2 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s2 = peg$FAILED;

{
            peg$fail(peg$c5);
          }
        }

if (s2 !== peg$FAILED) {
          while (s2 !== peg$FAILED) {
            s1.push(s2);

if (peg$c4.test(input.charAt(peg$currPos))) {
              s2 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s2 = peg$FAILED;

{
                peg$fail(peg$c5);
              }
            }
          }
        } else {
          s1 = peg$FAILED;
        }

if (s1 !== peg$FAILED) {
          s1 = peg$c6(s1);
        }

s0 = s1;
        peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsebinaryOp() {
        var s0, s1, s2, s3;
        var key = peg$currPos * 30 + 3,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;
        s1 = peg$parse_();

if (s1 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 62) {
            s2 = peg$c7;
            peg$currPos++;
          } else {
            s2 = peg$FAILED;

{
              peg$fail(peg$c8);
            }
          }

if (s2 !== peg$FAILED) {
            s3 = peg$parse_();

if (s3 !== peg$FAILED) {
              s1 = peg$c9();
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          s1 = peg$parse_();

if (s1 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 126) {
              s2 = peg$c10;
              peg$currPos++;
            } else {
              s2 = peg$FAILED;

{
                peg$fail(peg$c11);
              }
            }

if (s2 !== peg$FAILED) {
              s3 = peg$parse_();

if (s3 !== peg$FAILED) {
                s1 = peg$c12();
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }

if (s0 === peg$FAILED) {
            s0 = peg$currPos;
            s1 = peg$parse_();

if (s1 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 43) {
                s2 = peg$c13;
                peg$currPos++;
              } else {
                s2 = peg$FAILED;

{
                  peg$fail(peg$c14);
                }
              }

if (s2 !== peg$FAILED) {
                s3 = peg$parse_();

if (s3 !== peg$FAILED) {
                  s1 = peg$c15();
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }

if (s0 === peg$FAILED) {
              s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 32) {
                s1 = peg$c2;
                peg$currPos++;
              } else {
                s1 = peg$FAILED;

{
                  peg$fail(peg$c3);
                }
              }

if (s1 !== peg$FAILED) {
                s2 = peg$parse_();

if (s2 !== peg$FAILED) {
                  s1 = peg$c16();
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            }
          }
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseselectors() {
        var s0, s1, s2, s3, s4, s5, s6, s7;
        var key = peg$currPos * 30 + 4,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;
        s1 = peg$parseselector();

if (s1 !== peg$FAILED) {
          s2 = [];
          s3 = peg$currPos;
          s4 = peg$parse_();

if (s4 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 44) {
              s5 = peg$c17;
              peg$currPos++;
            } else {
              s5 = peg$FAILED;

{
                peg$fail(peg$c18);
              }
            }

if (s5 !== peg$FAILED) {
              s6 = peg$parse_();

if (s6 !== peg$FAILED) {
                s7 = peg$parseselector();

if (s7 !== peg$FAILED) {
                  s4 = [s4, s5, s6, s7];
                  s3 = s4;
                } else {
                  peg$currPos = s3;
                  s3 = peg$FAILED;
                }
              } else {
                peg$currPos = s3;
                s3 = peg$FAILED;
              }
            } else {
              peg$currPos = s3;
              s3 = peg$FAILED;
            }
          } else {
            peg$currPos = s3;
            s3 = peg$FAILED;
          }

while (s3 !== peg$FAILED) {
            s2.push(s3);
            s3 = peg$currPos;
            s4 = peg$parse_();

if (s4 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 44) {
                s5 = peg$c17;
                peg$currPos++;
              } else {
                s5 = peg$FAILED;

{
                  peg$fail(peg$c18);
                }
              }

if (s5 !== peg$FAILED) {
                s6 = peg$parse_();

if (s6 !== peg$FAILED) {
                  s7 = peg$parseselector();

if (s7 !== peg$FAILED) {
                    s4 = [s4, s5, s6, s7];
                    s3 = s4;
                  } else {
                    peg$currPos = s3;
                    s3 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s3;
                  s3 = peg$FAILED;
                }
              } else {
                peg$currPos = s3;
                s3 = peg$FAILED;
              }
            } else {
              peg$currPos = s3;
              s3 = peg$FAILED;
            }
          }

if (s2 !== peg$FAILED) {
            s1 = peg$c19(s1, s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseselector() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 5,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;
        s1 = peg$parsesequence();

if (s1 !== peg$FAILED) {
          s2 = [];
          s3 = peg$currPos;
          s4 = peg$parsebinaryOp();

if (s4 !== peg$FAILED) {
            s5 = peg$parsesequence();

if (s5 !== peg$FAILED) {
              s4 = [s4, s5];
              s3 = s4;
            } else {
              peg$currPos = s3;
              s3 = peg$FAILED;
            }
          } else {
            peg$currPos = s3;
            s3 = peg$FAILED;
          }

while (s3 !== peg$FAILED) {
            s2.push(s3);
            s3 = peg$currPos;
            s4 = peg$parsebinaryOp();

if (s4 !== peg$FAILED) {
              s5 = peg$parsesequence();

if (s5 !== peg$FAILED) {
                s4 = [s4, s5];
                s3 = s4;
              } else {
                peg$currPos = s3;
                s3 = peg$FAILED;
              }
            } else {
              peg$currPos = s3;
              s3 = peg$FAILED;
            }
          }

if (s2 !== peg$FAILED) {
            s1 = peg$c20(s1, s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsesequence() {
        var s0, s1, s2, s3;
        var key = peg$currPos * 30 + 6,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 33) {
          s1 = peg$c21;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c22);
          }
        }

if (s1 === peg$FAILED) {
          s1 = null;
        }

if (s1 !== peg$FAILED) {
          s2 = [];
          s3 = peg$parseatom();

if (s3 !== peg$FAILED) {
            while (s3 !== peg$FAILED) {
              s2.push(s3);
              s3 = peg$parseatom();
            }
          } else {
            s2 = peg$FAILED;
          }

if (s2 !== peg$FAILED) {
            s1 = peg$c23(s1, s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseatom() {
        var s0;
        var key = peg$currPos * 30 + 7,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$parsewildcard();

if (s0 === peg$FAILED) {
          s0 = peg$parseidentifier();

if (s0 === peg$FAILED) {
            s0 = peg$parseattr();

if (s0 === peg$FAILED) {
              s0 = peg$parsefield();

if (s0 === peg$FAILED) {
                s0 = peg$parsenegation();

if (s0 === peg$FAILED) {
                  s0 = peg$parsematches();

if (s0 === peg$FAILED) {
                    s0 = peg$parsehas();

if (s0 === peg$FAILED) {
                      s0 = peg$parsefirstChild();

if (s0 === peg$FAILED) {
                        s0 = peg$parselastChild();

if (s0 === peg$FAILED) {
                          s0 = peg$parsenthChild();

if (s0 === peg$FAILED) {
                            s0 = peg$parsenthLastChild();

if (s0 === peg$FAILED) {
                              s0 = peg$parseclass();
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsewildcard() {
        var s0, s1;
        var key = peg$currPos * 30 + 8,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 42) {
          s1 = peg$c24;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c25);
          }
        }

if (s1 !== peg$FAILED) {
          s1 = peg$c26(s1);
        }

s0 = s1;
        peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseidentifier() {
        var s0, s1, s2;
        var key = peg$currPos * 30 + 9,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 35) {
          s1 = peg$c27;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c28);
          }
        }

if (s1 === peg$FAILED) {
          s1 = null;
        }

if (s1 !== peg$FAILED) {
          s2 = peg$parseidentifierName();

if (s2 !== peg$FAILED) {
            s1 = peg$c29(s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseattr() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 10,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 91) {
          s1 = peg$c30;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c31);
          }
        }

if (s1 !== peg$FAILED) {
          s2 = peg$parse_();

if (s2 !== peg$FAILED) {
            s3 = peg$parseattrValue();

if (s3 !== peg$FAILED) {
              s4 = peg$parse_();

if (s4 !== peg$FAILED) {
                if (input.charCodeAt(peg$currPos) === 93) {
                  s5 = peg$c32;
                  peg$currPos++;
                } else {
                  s5 = peg$FAILED;

{
                    peg$fail(peg$c33);
                  }
                }

if (s5 !== peg$FAILED) {
                  s1 = peg$c34(s3);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseattrOps() {
        var s0, s1, s2;
        var key = peg$currPos * 30 + 11,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (peg$c35.test(input.charAt(peg$currPos))) {
          s1 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c36);
          }
        }

if (s1 === peg$FAILED) {
          s1 = null;
        }

if (s1 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 61) {
            s2 = peg$c37;
            peg$currPos++;
          } else {
            s2 = peg$FAILED;

{
              peg$fail(peg$c38);
            }
          }

if (s2 !== peg$FAILED) {
            s1 = peg$c39(s1);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

if (s0 === peg$FAILED) {
          if (peg$c40.test(input.charAt(peg$currPos))) {
            s0 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s0 = peg$FAILED;

{
              peg$fail(peg$c41);
            }
          }
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseattrEqOps() {
        var s0, s1, s2;
        var key = peg$currPos * 30 + 12,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 33) {
          s1 = peg$c21;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c22);
          }
        }

if (s1 === peg$FAILED) {
          s1 = null;
        }

if (s1 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 61) {
            s2 = peg$c37;
            peg$currPos++;
          } else {
            s2 = peg$FAILED;

{
              peg$fail(peg$c38);
            }
          }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseattrName() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 13,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;
        s1 = peg$parseidentifierName();

if (s1 !== peg$FAILED) {
          s2 = [];
          s3 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 46) {
            s4 = peg$c42;
            peg$currPos++;
          } else {
            s4 = peg$FAILED;

{
              peg$fail(peg$c43);
            }
          }

if (s4 !== peg$FAILED) {
            s5 = peg$parseidentifierName();

while (s3 !== peg$FAILED) {
            s2.push(s3);
            s3 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 46) {
              s4 = peg$c42;
              peg$currPos++;
            } else {
              s4 = peg$FAILED;

{
                peg$fail(peg$c43);
              }
            }

if (s4 !== peg$FAILED) {
              s5 = peg$parseidentifierName();

if (s2 !== peg$FAILED) {
            s1 = peg$c44(s1, s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseattrValue() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 14,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;
        s1 = peg$parseattrName();

if (s1 !== peg$FAILED) {
          s2 = peg$parse_();

if (s2 !== peg$FAILED) {
            s3 = peg$parseattrEqOps();

if (s3 !== peg$FAILED) {
              s4 = peg$parse_();

if (s4 !== peg$FAILED) {
                s5 = peg$parsetype();

if (s5 === peg$FAILED) {
                  s5 = peg$parseregex();
                }

if (s5 !== peg$FAILED) {
                  s1 = peg$c45(s1, s3, s5);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

if (s0 === peg$FAILED) {
          s0 = peg$currPos;
          s1 = peg$parseattrName();

if (s1 !== peg$FAILED) {
            s2 = peg$parse_();

if (s2 !== peg$FAILED) {
              s3 = peg$parseattrOps();

if (s3 !== peg$FAILED) {
                s4 = peg$parse_();

if (s4 !== peg$FAILED) {
                  s5 = peg$parsestring();

if (s5 === peg$FAILED) {
                    s5 = peg$parsenumber();

if (s5 === peg$FAILED) {
                      s5 = peg$parsepath();
                    }
                  }

if (s5 !== peg$FAILED) {
                    s1 = peg$c45(s1, s3, s5);
                    s0 = s1;
                  } else {
                    peg$currPos = s0;
                    s0 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }

if (s0 === peg$FAILED) {
            s0 = peg$currPos;
            s1 = peg$parseattrName();

if (s1 !== peg$FAILED) {
              s1 = peg$c46(s1);
            }

s0 = s1;
          }
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsestring() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 15,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 34) {
          s1 = peg$c47;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c48);
          }
        }

if (s1 !== peg$FAILED) {
          s2 = [];

if (peg$c49.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;

{
              peg$fail(peg$c50);
            }
          }

if (s3 === peg$FAILED) {
            s3 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 92) {
              s4 = peg$c51;
              peg$currPos++;
            } else {
              s4 = peg$FAILED;

{
                peg$fail(peg$c52);
              }
            }

if (s4 !== peg$FAILED) {
              if (input.length > peg$currPos) {
                s5 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s5 = peg$FAILED;

{
                  peg$fail(peg$c53);
                }
              }

if (s5 !== peg$FAILED) {
                s4 = peg$c54(s4, s5);
                s3 = s4;
              } else {
                peg$currPos = s3;
                s3 = peg$FAILED;
              }
            } else {
              peg$currPos = s3;
              s3 = peg$FAILED;
            }
          }

while (s3 !== peg$FAILED) {
            s2.push(s3);

if (peg$c49.test(input.charAt(peg$currPos))) {
              s3 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s3 = peg$FAILED;

{
                peg$fail(peg$c50);
              }
            }

if (s3 === peg$FAILED) {
              s3 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 92) {
                s4 = peg$c51;
                peg$currPos++;
              } else {
                s4 = peg$FAILED;

{
                  peg$fail(peg$c52);
                }
              }

if (s4 !== peg$FAILED) {
                if (input.length > peg$currPos) {
                  s5 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s5 = peg$FAILED;

{
                    peg$fail(peg$c53);
                  }
                }

if (s5 !== peg$FAILED) {
                  s4 = peg$c54(s4, s5);
                  s3 = s4;
                } else {
                  peg$currPos = s3;
                  s3 = peg$FAILED;
                }
              } else {
                peg$currPos = s3;
                s3 = peg$FAILED;
              }
            }
          }

if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 34) {
              s3 = peg$c47;
              peg$currPos++;
            } else {
              s3 = peg$FAILED;

{
                peg$fail(peg$c48);
              }
            }

if (s3 !== peg$FAILED) {
              s1 = peg$c55(s2);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

if (s0 === peg$FAILED) {
          s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 39) {
            s1 = peg$c56;
            peg$currPos++;
          } else {
            s1 = peg$FAILED;

{
              peg$fail(peg$c57);
            }
          }

if (s1 !== peg$FAILED) {
            s2 = [];

if (peg$c58.test(input.charAt(peg$currPos))) {
              s3 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s3 = peg$FAILED;

{
                peg$fail(peg$c59);
              }
            }

if (s3 === peg$FAILED) {
              s3 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 92) {
                s4 = peg$c51;
                peg$currPos++;
              } else {
                s4 = peg$FAILED;

{
                  peg$fail(peg$c52);
                }
              }

if (s4 !== peg$FAILED) {
                if (input.length > peg$currPos) {
                  s5 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s5 = peg$FAILED;

{
                    peg$fail(peg$c53);
                  }
                }

if (s5 !== peg$FAILED) {
                  s4 = peg$c54(s4, s5);
                  s3 = s4;
                } else {
                  peg$currPos = s3;
                  s3 = peg$FAILED;
                }
              } else {
                peg$currPos = s3;
                s3 = peg$FAILED;
              }
            }

while (s3 !== peg$FAILED) {
              s2.push(s3);

if (peg$c58.test(input.charAt(peg$currPos))) {
                s3 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s3 = peg$FAILED;

{
                  peg$fail(peg$c59);
                }
              }

if (s3 === peg$FAILED) {
                s3 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 92) {
                  s4 = peg$c51;
                  peg$currPos++;
                } else {
                  s4 = peg$FAILED;

{
                    peg$fail(peg$c52);
                  }
                }

if (s4 !== peg$FAILED) {
                  if (input.length > peg$currPos) {
                    s5 = input.charAt(peg$currPos);
                    peg$currPos++;
                  } else {
                    s5 = peg$FAILED;

{
                      peg$fail(peg$c53);
                    }
                  }

if (s5 !== peg$FAILED) {
                    s4 = peg$c54(s4, s5);
                    s3 = s4;
                  } else {
                    peg$currPos = s3;
                    s3 = peg$FAILED;
                  }
                } else {
                  peg$currPos = s3;
                  s3 = peg$FAILED;
                }
              }
            }

if (s2 !== peg$FAILED) {
              if (input.charCodeAt(peg$currPos) === 39) {
                s3 = peg$c56;
                peg$currPos++;
              } else {
                s3 = peg$FAILED;

{
                  peg$fail(peg$c57);
                }
              }

if (s3 !== peg$FAILED) {
                s1 = peg$c55(s2);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsenumber() {
        var s0, s1, s2, s3;
        var key = peg$currPos * 30 + 16,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;
        s1 = peg$currPos;
        s2 = [];

if (peg$c60.test(input.charAt(peg$currPos))) {
          s3 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s3 = peg$FAILED;

{
            peg$fail(peg$c61);
          }
        }

while (s3 !== peg$FAILED) {
          s2.push(s3);

if (peg$c60.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;

{
              peg$fail(peg$c61);
            }
          }
        }

if (s2 !== peg$FAILED) {
          if (input.charCodeAt(peg$currPos) === 46) {
            s3 = peg$c42;
            peg$currPos++;
          } else {
            s3 = peg$FAILED;

{
              peg$fail(peg$c43);
            }
          }

if (s3 !== peg$FAILED) {
            s2 = [s2, s3];
            s1 = s2;
          } else {
            peg$currPos = s1;
            s1 = peg$FAILED;
          }
        } else {
          peg$currPos = s1;
          s1 = peg$FAILED;
        }

if (s1 === peg$FAILED) {
          s1 = null;
        }

if (s1 !== peg$FAILED) {
          s2 = [];

if (peg$c60.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;

{
              peg$fail(peg$c61);
            }
          }

if (s3 !== peg$FAILED) {
            while (s3 !== peg$FAILED) {
              s2.push(s3);

if (peg$c60.test(input.charAt(peg$currPos))) {
                s3 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s3 = peg$FAILED;

{
                  peg$fail(peg$c61);
                }
              }
            }
          } else {
            s2 = peg$FAILED;
          }

if (s2 !== peg$FAILED) {
            s1 = peg$c62(s1, s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsepath() {
        var s0, s1;
        var key = peg$currPos * 30 + 17,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;
        s1 = peg$parseidentifierName();

if (s1 !== peg$FAILED) {
          s1 = peg$c63(s1);
        }

s0 = s1;
        peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsetype() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 18,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.substr(peg$currPos, 5) === peg$c64) {
          s1 = peg$c64;
          peg$currPos += 5;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c65);
          }
        }

if (s1 !== peg$FAILED) {
          s2 = peg$parse_();

if (s2 !== peg$FAILED) {
            s3 = [];

if (peg$c66.test(input.charAt(peg$currPos))) {
              s4 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s4 = peg$FAILED;

{
                peg$fail(peg$c67);
              }
            }

if (s4 !== peg$FAILED) {
              while (s4 !== peg$FAILED) {
                s3.push(s4);

if (peg$c66.test(input.charAt(peg$currPos))) {
                  s4 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s4 = peg$FAILED;

{
                    peg$fail(peg$c67);
                  }
                }
              }
            } else {
              s3 = peg$FAILED;
            }

if (s3 !== peg$FAILED) {
              s4 = peg$parse_();

if (s4 !== peg$FAILED) {
                if (input.charCodeAt(peg$currPos) === 41) {
                  s5 = peg$c68;
                  peg$currPos++;
                } else {
                  s5 = peg$FAILED;

{
                    peg$fail(peg$c69);
                  }
                }

if (s5 !== peg$FAILED) {
                  s1 = peg$c70(s3);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseflags() {
        var s0, s1;
        var key = peg$currPos * 30 + 19,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = [];

if (peg$c71.test(input.charAt(peg$currPos))) {
          s1 = input.charAt(peg$currPos);
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c72);
          }
        }

if (s1 !== peg$FAILED) {
          while (s1 !== peg$FAILED) {
            s0.push(s1);

if (peg$c71.test(input.charAt(peg$currPos))) {
              s1 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s1 = peg$FAILED;

{
                peg$fail(peg$c72);
              }
            }
          }
        } else {
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseregex() {
        var s0, s1, s2, s3, s4;
        var key = peg$currPos * 30 + 20,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 47) {
          s1 = peg$c73;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c74);
          }
        }

if (s1 !== peg$FAILED) {
          s2 = [];

if (peg$c75.test(input.charAt(peg$currPos))) {
            s3 = input.charAt(peg$currPos);
            peg$currPos++;
          } else {
            s3 = peg$FAILED;

{
              peg$fail(peg$c76);
            }
          }

if (s3 !== peg$FAILED) {
            while (s3 !== peg$FAILED) {
              s2.push(s3);

if (peg$c75.test(input.charAt(peg$currPos))) {
                s3 = input.charAt(peg$currPos);
                peg$currPos++;
              } else {
                s3 = peg$FAILED;

{
                  peg$fail(peg$c76);
                }
              }
            }
          } else {
            s2 = peg$FAILED;
          }

if (s2 !== peg$FAILED) {
            if (input.charCodeAt(peg$currPos) === 47) {
              s3 = peg$c73;
              peg$currPos++;
            } else {
              s3 = peg$FAILED;

{
                peg$fail(peg$c74);
              }
            }

if (s3 !== peg$FAILED) {
              s4 = peg$parseflags();

if (s4 === peg$FAILED) {
                s4 = null;
              }

if (s4 !== peg$FAILED) {
                s1 = peg$c77(s2, s4);
                s0 = s1;
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsefield() {
        var s0, s1, s2, s3, s4, s5, s6;
        var key = peg$currPos * 30 + 21,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 46) {
          s1 = peg$c42;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c43);
          }
        }

if (s1 !== peg$FAILED) {
          s2 = peg$parseidentifierName();

if (s2 !== peg$FAILED) {
            s3 = [];
            s4 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 46) {
              s5 = peg$c42;
              peg$currPos++;
            } else {
              s5 = peg$FAILED;

{
                peg$fail(peg$c43);
              }
            }

if (s5 !== peg$FAILED) {
              s6 = peg$parseidentifierName();

if (s6 !== peg$FAILED) {
                s5 = [s5, s6];
                s4 = s5;
              } else {
                peg$currPos = s4;
                s4 = peg$FAILED;
              }
            } else {
              peg$currPos = s4;
              s4 = peg$FAILED;
            }

while (s4 !== peg$FAILED) {
              s3.push(s4);
              s4 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 46) {
                s5 = peg$c42;
                peg$currPos++;
              } else {
                s5 = peg$FAILED;

{
                  peg$fail(peg$c43);
                }
              }

if (s5 !== peg$FAILED) {
                s6 = peg$parseidentifierName();

if (s6 !== peg$FAILED) {
                  s5 = [s5, s6];
                  s4 = s5;
                } else {
                  peg$currPos = s4;
                  s4 = peg$FAILED;
                }
              } else {
                peg$currPos = s4;
                s4 = peg$FAILED;
              }
            }

if (s3 !== peg$FAILED) {
              s1 = peg$c78(s2, s3);
              s0 = s1;
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsenegation() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 22,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.substr(peg$currPos, 5) === peg$c79) {
          s1 = peg$c79;
          peg$currPos += 5;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c80);
          }
        }

if (s1 !== peg$FAILED) {
          s2 = peg$parse_();

if (s2 !== peg$FAILED) {
            s3 = peg$parseselectors();

if (s3 !== peg$FAILED) {
              s4 = peg$parse_();

{
                    peg$fail(peg$c69);
                  }
                }

if (s5 !== peg$FAILED) {
                  s1 = peg$c81(s3);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsematches() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 23,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.substr(peg$currPos, 9) === peg$c82) {
          s1 = peg$c82;
          peg$currPos += 9;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c83);
          }
        }

if (s1 !== peg$FAILED) {
          s2 = peg$parse_();

if (s2 !== peg$FAILED) {
            s3 = peg$parseselectors();

if (s3 !== peg$FAILED) {
              s4 = peg$parse_();

{
                    peg$fail(peg$c69);
                  }
                }

if (s5 !== peg$FAILED) {
                  s1 = peg$c84(s3);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsehas() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 24,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.substr(peg$currPos, 5) === peg$c85) {
          s1 = peg$c85;
          peg$currPos += 5;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c86);
          }
        }

if (s1 !== peg$FAILED) {
          s2 = peg$parse_();

if (s2 !== peg$FAILED) {
            s3 = peg$parseselectors();

if (s3 !== peg$FAILED) {
              s4 = peg$parse_();

{
                    peg$fail(peg$c69);
                  }
                }

if (s5 !== peg$FAILED) {
                  s1 = peg$c87(s3);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsefirstChild() {
        var s0, s1;
        var key = peg$currPos * 30 + 25,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.substr(peg$currPos, 12) === peg$c88) {
          s1 = peg$c88;
          peg$currPos += 12;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c89);
          }
        }

if (s1 !== peg$FAILED) {
          s1 = peg$c90();
        }

s0 = s1;
        peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parselastChild() {
        var s0, s1;
        var key = peg$currPos * 30 + 26,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.substr(peg$currPos, 11) === peg$c91) {
          s1 = peg$c91;
          peg$currPos += 11;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c92);
          }
        }

if (s1 !== peg$FAILED) {
          s1 = peg$c93();
        }

s0 = s1;
        peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsenthChild() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 27,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.substr(peg$currPos, 11) === peg$c94) {
          s1 = peg$c94;
          peg$currPos += 11;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c95);
          }
        }

if (s1 !== peg$FAILED) {
          s2 = peg$parse_();

if (s2 !== peg$FAILED) {
            s3 = [];

if (peg$c60.test(input.charAt(peg$currPos))) {
              s4 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s4 = peg$FAILED;

{
                peg$fail(peg$c61);
              }
            }

if (s4 !== peg$FAILED) {
              while (s4 !== peg$FAILED) {
                s3.push(s4);

if (peg$c60.test(input.charAt(peg$currPos))) {
                  s4 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s4 = peg$FAILED;

{
                    peg$fail(peg$c61);
                  }
                }
              }
            } else {
              s3 = peg$FAILED;
            }

if (s3 !== peg$FAILED) {
              s4 = peg$parse_();

{
                    peg$fail(peg$c69);
                  }
                }

if (s5 !== peg$FAILED) {
                  s1 = peg$c96(s3);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parsenthLastChild() {
        var s0, s1, s2, s3, s4, s5;
        var key = peg$currPos * 30 + 28,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.substr(peg$currPos, 16) === peg$c97) {
          s1 = peg$c97;
          peg$currPos += 16;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c98);
          }
        }

if (s1 !== peg$FAILED) {
          s2 = peg$parse_();

if (s2 !== peg$FAILED) {
            s3 = [];

if (peg$c60.test(input.charAt(peg$currPos))) {
              s4 = input.charAt(peg$currPos);
              peg$currPos++;
            } else {
              s4 = peg$FAILED;

{
                peg$fail(peg$c61);
              }
            }

if (s4 !== peg$FAILED) {
              while (s4 !== peg$FAILED) {
                s3.push(s4);

if (peg$c60.test(input.charAt(peg$currPos))) {
                  s4 = input.charAt(peg$currPos);
                  peg$currPos++;
                } else {
                  s4 = peg$FAILED;

{
                    peg$fail(peg$c61);
                  }
                }
              }
            } else {
              s3 = peg$FAILED;
            }

if (s3 !== peg$FAILED) {
              s4 = peg$parse_();

{
                    peg$fail(peg$c69);
                  }
                }

if (s5 !== peg$FAILED) {
                  s1 = peg$c99(s3);
                  s0 = s1;
                } else {
                  peg$currPos = s0;
                  s0 = peg$FAILED;
                }
              } else {
                peg$currPos = s0;
                s0 = peg$FAILED;
              }
            } else {
              peg$currPos = s0;
              s0 = peg$FAILED;
            }
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function peg$parseclass() {
        var s0, s1, s2;
        var key = peg$currPos * 30 + 29,
            cached = peg$resultsCache[key];

if (cached) {
          peg$currPos = cached.nextPos;
          return cached.result;
        }

s0 = peg$currPos;

if (input.charCodeAt(peg$currPos) === 58) {
          s1 = peg$c100;
          peg$currPos++;
        } else {
          s1 = peg$FAILED;

{
            peg$fail(peg$c101);
          }
        }

if (s1 !== peg$FAILED) {
          if (input.substr(peg$currPos, 9).toLowerCase() === peg$c102) {
            s2 = input.substr(peg$currPos, 9);
            peg$currPos += 9;
          } else {
            s2 = peg$FAILED;

{
              peg$fail(peg$c103);
            }
          }

if (s2 === peg$FAILED) {
            if (input.substr(peg$currPos, 10).toLowerCase() === peg$c104) {
              s2 = input.substr(peg$currPos, 10);
              peg$currPos += 10;
            } else {
              s2 = peg$FAILED;

{
                peg$fail(peg$c105);
              }
            }

if (s2 === peg$FAILED) {
              if (input.substr(peg$currPos, 11).toLowerCase() === peg$c106) {
                s2 = input.substr(peg$currPos, 11);
                peg$currPos += 11;
              } else {
                s2 = peg$FAILED;

{
                  peg$fail(peg$c107);
                }
              }

if (s2 === peg$FAILED) {
                if (input.substr(peg$currPos, 8).toLowerCase() === peg$c108) {
                  s2 = input.substr(peg$currPos, 8);
                  peg$currPos += 8;
                } else {
                  s2 = peg$FAILED;

{
                    peg$fail(peg$c109);
                  }
                }

if (s2 === peg$FAILED) {
                  if (input.substr(peg$currPos, 7).toLowerCase() === peg$c110) {
                    s2 = input.substr(peg$currPos, 7);
                    peg$currPos += 7;
                  } else {
                    s2 = peg$FAILED;

{
                      peg$fail(peg$c111);
                    }
                  }
                }
              }
            }
          }

if (s2 !== peg$FAILED) {
            s1 = peg$c112(s2);
            s0 = s1;
          } else {
            peg$currPos = s0;
            s0 = peg$FAILED;
          }
        } else {
          peg$currPos = s0;
          s0 = peg$FAILED;
        }

peg$resultsCache[key] = {
          nextPos: peg$currPos,
          result: s0
        };
        return s0;
      }

function nth(n) {
        return {
          type: 'nth-child',
          index: {
            type: 'literal',
            value: n
          }
        };
      }

function nthLast(n) {
        return {
          type: 'nth-last-child',
          index: {
            type: 'literal',
            value: n
          }
        };
      }

function strUnescape(s) {
        return s.replace(/\\(.)/g, function (match, ch) {
          switch (ch) {
            case 'b':
              return '\b';

case 'f':
              return '\f';

case 'n':
              return '\n';

case 'r':
              return '\r';

case 't':
              return '\t';

case 'v':
              return '\v';

default:
              return ch;
          }
        });
      }

peg$result = peg$startRuleFunction();

if (peg$result !== peg$FAILED && peg$currPos === input.length) {
        return peg$result;
      } else {
        if (peg$result !== peg$FAILED && peg$currPos < input.length) {
          peg$fail(peg$endExpectation());
        }

throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));
      }
    }

return {
      SyntaxError: peg$SyntaxError,
      parse: peg$parse
    };
  });
});

function _objectEntries(obj) {
  var entries = [];
  var keys = Object.keys(obj);

for (var k = 0; k < keys.length; k++) entries.push([keys[k], obj[keys[k]]]);

return entries;
}
/**
* @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} key
 * @returns {undefined|boolean|string|number|external:AST}
 */

function getPath(obj, key) {
  var keys = key.split('.');

var _iterator = _createForOfIteratorHelper(keys),
      _step;

try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var _key = _step.value;

if (obj == null) {
        return obj;
      }

obj = obj[_key];
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

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
 * @returns {boolean}
 */

function inPath(node, ancestor, path) {
  if (path.length === 0) {
    return node === ancestor;
  }

if (ancestor == null) {
    return false;
  }

var field = ancestor[path[0]];
  var remainingPath = path.slice(1);

if (Array.isArray(field)) {
    var _iterator2 = _createForOfIteratorHelper(field),
        _step2;

try {
      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
        var component = _step2.value;

if (inPath(node, component, remainingPath)) {
          return true;
        }
      }
    } catch (err) {
      _iterator2.e(err);
    } finally {
      _iterator2.f();
    }

return false;
  } else {
    return inPath(node, field, remainingPath);
  }
}
/**
 * @callback TraverseOptionFallback
 * @param {external:AST} node The given node.
 * @returns {string[]} An array of visitor keys for the given node.
 */

/**
 * @typedef {object} ESQueryOptions
 * @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.
 */

/**
 * 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 = [];
  }

switch (selector.type) {
    case 'wildcard':
      return true;

case 'identifier':
      return selector.value.toLowerCase() === node.type.toLowerCase();

case 'field':
      {
        var path = selector.name.split('.');
        var ancestor = ancestry[path.length - 1];
        return inPath(node, ancestor, path);
      }

case 'matches':
      var _iterator3 = _createForOfIteratorHelper(selector.selectors),
          _step3;

try {
        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
          var sel = _step3.value;

if (matches(node, sel, ancestry, options)) {
            return true;
          }
        }
      } catch (err) {
        _iterator3.e(err);
      } finally {
        _iterator3.f();
      }

return false;

case 'compound':
      var _iterator4 = _createForOfIteratorHelper(selector.selectors),
          _step4;

try {
        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
          var _sel = _step4.value;

if (!matches(node, _sel, ancestry, options)) {
            return false;
          }
        }
      } catch (err) {
        _iterator4.e(err);
      } finally {
        _iterator4.f();
      }

return true;

case 'not':
      var _iterator5 = _createForOfIteratorHelper(selector.selectors),
          _step5;

try {
        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
          var _sel2 = _step5.value;

if (matches(node, _sel2, ancestry, options)) {
            return false;
          }
        }
      } catch (err) {
        _iterator5.e(err);
      } finally {
        _iterator5.f();
      }

return true;

case 'has':
      {
        var _ret = function () {
          var collector = [];

var _iterator6 = _createForOfIteratorHelper(selector.selectors),
              _step6;

try {
            var _loop = function _loop() {
              var sel = _step6.value;
              var a = [];
              estraverse.traverse(node, {
                enter: function enter(node, parent) {
                  if (parent != null) {
                    a.unshift(parent);
                  }

if (matches(node, sel, a, options)) {
                    collector.push(node);
                  }
                },
                leave: function leave() {
                  a.shift();
                },
                keys: options && options.visitorKeys,
                fallback: options && options.fallback || 'iteration'
              });
            };

for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
              _loop();
            }
          } catch (err) {
            _iterator6.e(err);
          } finally {
            _iterator6.f();
          }

return {
            v: collector.length !== 0
          };
        }();

if (_typeof(_ret) === "object") return _ret.v;
      }

case 'child':
      if (matches(node, selector.right, ancestry, options)) {
        return matches(ancestry[0], selector.left, ancestry.slice(1), options);
      }

return false;

case 'descendant':
      if (matches(node, selector.right, ancestry, options)) {
        for (var i = 0, l = ancestry.length; i < l; ++i) {
          if (matches(ancestry[i], selector.left, ancestry.slice(i + 1), options)) {
            return true;
          }
        }
      }

return false;

case 'attribute':
      {
        var p = getPath(node, selector.name);

switch (selector.operator) {
          case void 0:
            return p != null;

case '=':
            switch (selector.value.type) {
              case 'regexp':
                return typeof p === 'string' && selector.value.value.test(p);

case 'literal':
                return "".concat(selector.value.value) === "".concat(p);

case 'type':
                return selector.value.value === _typeof(p);
            }

throw new Error("Unknown selector value type: ".concat(selector.value.type));

case '!=':
            switch (selector.value.type) {
              case 'regexp':
                return !selector.value.value.test(p);

case 'literal':
                return "".concat(selector.value.value) !== "".concat(p);

case 'type':
                return selector.value.value !== _typeof(p);
            }

throw new Error("Unknown selector value type: ".concat(selector.value.type));

case '<=':
            return p <= selector.value.value;

case '<':
            return p < selector.value.value;

case '>':
            return p > selector.value.value;

case '>=':
            return p >= selector.value.value;
        }

throw new Error("Unknown operator: ".concat(selector.operator));
      }

case 'sibling':
      return matches(node, selector.right, ancestry, options) && sibling(node, selector.left, ancestry, LEFT_SIDE, options) || selector.left.subject && matches(node, selector.left, ancestry, options) && sibling(node, selector.right, ancestry, RIGHT_SIDE, options);

case 'adjacent':
      return matches(node, selector.right, ancestry, options) && adjacent(node, selector.left, ancestry, LEFT_SIDE, options) || selector.right.subject && matches(node, selector.left, ancestry, options) && adjacent(node, selector.right, ancestry, RIGHT_SIDE, options);

case 'nth-child':
      return matches(node, selector.right, ancestry, options) && nthChild(node, ancestry, function () {
        return selector.index.value - 1;
      }, options);

case 'nth-last-child':
      return matches(node, selector.right, ancestry, options) && nthChild(node, ancestry, function (length) {
        return length - selector.index.value;
      }, options);

case 'class':
      switch (selector.name.toLowerCase()) {
        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));
}
/**
 * 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 nodeType = node.type;

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 !== 'type';
  });
}
/**
 * Check whether the given value is an ASTNode or not.
 * @param {any} node The value to check.
 * @returns {boolean} `true` if the value is an ASTNode.
 */

function isNode(node) {
  return node !== null && _typeof(node) === 'object' && typeof node.type === 'string';
}
/**
 * Determines if the given node has a sibling that matches the
 * given selector.
 * @param {external:AST} node
 * @param {SelectorSequenceAST} selector
 * @param {external:AST[]} ancestry
 * @param {Side} side
 * @param {ESQueryOptions|undefined} options
 * @returns {boolean}
 */

function sibling(node, selector, ancestry, side, options) {
  var _ancestry = _slicedToArray(ancestry, 1),
      parent = _ancestry[0];

if (!parent) {
    return false;
  }

var keys = getVisitorKeys(parent, options);

var _iterator7 = _createForOfIteratorHelper(keys),
      _step7;

try {
    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
      var key = _step7.value;
      var listProp = parent[key];

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]) && matches(listProp[k], selector, ancestry, options)) {
            return true;
          }
        }
      }
    }
  } catch (err) {
    _iterator7.e(err);
  } finally {
    _iterator7.f();
  }

return false;
}
/**
 * Determines if the given node has an adjacent sibling that matches
 * the given selector.
 * @param {external:AST} node
 * @param {SelectorSequenceAST} selector
 * @param {external:AST[]} ancestry
 * @param {Side} side
 * @param {ESQueryOptions|undefined} options
 * @returns {boolean}
 */

function adjacent(node, selector, ancestry, side, options) {
  var _ancestry2 = _slicedToArray(ancestry, 1),
      parent = _ancestry2[0];

if (!parent) {
    return false;
  }

var keys = getVisitorKeys(parent, options);

var _iterator8 = _createForOfIteratorHelper(keys),
      _step8;

try {
    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
      var key = _step8.value;
      var listProp = parent[key];

if (Array.isArray(listProp)) {
        var idx = listProp.indexOf(node);

if (idx < 0) {
          continue;
        }

if (side === LEFT_SIDE && idx > 0 && isNode(listProp[idx - 1]) && matches(listProp[idx - 1], selector, ancestry, options)) {
          return true;
        }

if (side === RIGHT_SIDE && idx < listProp.length - 1 && isNode(listProp[idx + 1]) && matches(listProp[idx + 1], selector, ancestry, options)) {
          return true;
        }
      }
    }
  } catch (err) {
    _iterator8.e(err);
  } finally {
    _iterator8.f();
  }

return false;
}
/**
* @callback IndexFunction
* @param {Integer} len Containing list's length
* @returns {Integer}
*/

/**
 * Determines if the given node is the nth child, determined by
 * `idxFn`, which is given the containing list's length.
 * @param {external:AST} node
 * @param {external:AST[]} ancestry
 * @param {IndexFunction} idxFn
 * @param {ESQueryOptions|undefined} options
 * @returns {boolean}
 */

function nthChild(node, ancestry, idxFn, options) {
  var _ancestry3 = _slicedToArray(ancestry, 1),
      parent = _ancestry3[0];

if (!parent) {
    return false;
  }

var keys = getVisitorKeys(parent, options);

var _iterator9 = _createForOfIteratorHelper(keys),
      _step9;

try {
    for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
      var key = _step9.value;
      var listProp = parent[key];

if (Array.isArray(listProp)) {
        var idx = listProp.indexOf(node);

if (idx >= 0 && idx === idxFn(listProp.length)) {
          return true;
        }
      }
    }
  } catch (err) {
    _iterator9.e(err);
  } finally {
    _iterator9.f();
  }

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] : [];

for (var _i = 0, _Object$entries = _objectEntries(selector); _i < _Object$entries.length; _i++) {
    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
        p = _Object$entries$_i[0],
        sel = _Object$entries$_i[1];

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 altSubjects = subjects(selector);
  estraverse.traverse(ast, {
    enter: function enter(node, parent) {
      if (parent != null) {
        ancestry.unshift(parent);
      }

if (matches(node, selector, ancestry, options)) {
        if (altSubjects.length) {
          for (var i = 0, l = altSubjects.length; i < l; ++i) {
            if (matches(node, altSubjects[i], ancestry, options)) {
              visitor(node, parent, ancestry);
            }

for (var k = 0, m = ancestry.length; k < m; ++k) {
              var succeedingAncestry = ancestry.slice(k + 1);

if (matches(ancestry[k], altSubjects[i], 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 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;

Back to Directory File Manager