Get the node at the given location
@param {location}
198418
function nodeAtLocation(location) {
        return exports.root.find(function each(n) {
            return n.isAtLocation(location, false);
        });
    }
1035601
def get(self, position):
        

        counter = 0
        current_node = self.head

        while current_node is not None and counter <= position:
            if counter == position:
                return current_node.val

            current_node = current_node.next_node
            counter += 1

        return None
830298
function(node) {
         var newNode = function(data, next) {
             var that = {};
             that.getData = function() {
                 return data;
             };
             that.getNext = function() {
                 return next;
             };
             return that;
         };
         var top = node || null;
         var that = {};

         that.__push_internal__ = function(data) {
             return newStack(newNode(data, top));
         };

         that.__peek__ = function() {
             return top && top.getData();
         };

         that.__pop_internal__ = function() {
             return top && newStack(top.getNext());
         };

         that.__forEach__ = function(f) {
             var i = top;
             var s = 0;
             while (i !== null) {
                 f(i.getData(), s);
                 s = s +1;
                 i = i.getNext();
             }
         };
         that.__map__ = function(f) {
             var i = top;
             var result = [];
             while (i !== null) {
                 result.push(f(i.getData()));
                 i = i.getNext();
             }
             return result;
         };

         that.__length__ = function() {
             var count = 0;
             that.__forEach__(function() { count = count + 1;});
             return count;
         };

         return that;
     }
521125
function(node){
    if (!node) this.expect('atblock');
    node = new nodes.Atblock;
    this.state.push('atblock');
    node.block = this.block(node, false);
    this.state.pop();
    return node;
  }
667812
function getPathByNode(node){
  var cursor = node;
  var path = [];
  var role;

  while (cursor && cursor !== document)
  {
    if (role = cursor.getAttribute('role-marker'))
      path.unshift(parseRole(role));
    cursor = cursor.parentNode;
  }

  return path;
}
1081103
def _get_node_dir(node):
        """"""
        path = os.path.abspath(node)
        return path if os.path.isdir(path) else os.path.dirname(path)
850632
function nodePosition(node) {
  let name = node.nodeName
  let position = 1
  while ((node = node.previousSibling)) {
    if (node.nodeName === name) position += 1
  }
  return position
}
112569
def get_node(self, name, memory=False, binary=False):
        
        return self._api_get(
            url='/api/nodes/{0}'.format(name),
            params=dict(
                binary=binary,
                memory=memory,
            ),
        )
738276
function getSiblingNode(node) {
  while (node) {
    if (node.nextSibling) {
      return node.nextSibling;
    }
    node = node.parentNode;
  }
}
640903
def get_node(self, index):
        

        index = self.mapToSource(index)
        if not index.isValid():
            return self.sourceModel().root_node

        return index.internalPointer() or self.sourceModel().root_node
976558
def visit(self, node):
        
        if isinstance(node, Placeholder):
            return self.placeholders[node.id]
        else:
            return super(PlaceholderReplace, self).visit(node)
678868
def getNode(self, name, **context):
        """"""
        if name == self.name:
            return self
        else:
            return self.getBranch(name, **context).getNode(name, **context)
673615
function findFirstTextNode(node) {
          var walker;

          if (node) {
            walker = new TreeWalker(node, node);

            for (node = walker.current(); node; node = walker.next()) {
              if (node.nodeType === 3) {
                return node;
              }
            }
          }
        }
900135
def get_node_at_path(query_path, context):
    """"""
    if query_path not in context.query_path_to_node:
        raise AssertionError(
            u'Unable to find SqlNode for query path {} with context {}.'.format(
                query_path, context))
    node = context.query_path_to_node[query_path]
    return node
816740
function getText(node) {
    if (!node || !node.childNodes) {
        return undefined;
    }
    return node.protectedValue ? node.protectedValue.text : node.textContent;
}
1151258
function isInRange(node, location) {
    return node && node.range[0] <= location && location <= node.range[1];
}
732712
function getInThere(thing, path) {
    var out = thing;
    var apathy = path.split('.');

    for(var i =0 ; i < apathy.length; i ++ ) {
        if(!out) {
            return null;
        }
        out = out[apathy[i]];
    }
    return out;
}