Create a function that can be used to insert nodes after the one given as argument.
1389
function pointAt(node){
      var parent = node.parentNode;
      var next = node.nextSibling;
      return function(newnode) {
        parent.insertBefore(newnode, next);
      };
    }
992596
function() {
    this.expect('function');
    this.state.push('function arguments');
    var args = this.args();
    this.expect(')');
    this.state.pop();
    return new nodes.Call('url', args);
  }
702163
function insertTable(
    opts: Options,
    change: Change,
    columns?: number = 2,
    rows?: number = 2,
    getCellContent?: (column: number, row: number) => Node[]
): Change {
    const { value } = change;

    if (!value.selection.startKey) return change;

    // Create the table node
    const table = createTable(opts, columns, rows, getCellContent);

    return change.insertBlock(table);
}
249023
def insert_after_node(data, node)
      Node(data).tap do |new_node|
        new_node.prev = node
        new_node.next = node.next
        if node.next
          node.next.prev = new_node
        else
          @tail = new_node
        end
        node.next = new_node
        @length += 1
      end
    end
616019
def insert(self, node, before=None):
        
        node._list = self
        if self._first is None:
            self._first = self._last = node  # first node in list
            self._size += 1
            return node
        if before is None:
            self._last._next = node  # insert as last node
            node._prev = self._last
            self._last = node
        else:
            node._next = before
            node._prev = before._prev
            if node._prev:
                node._prev._next = node
            else:
                self._first = node  # inserting as first node
            node._next._prev = node
        self._size += 1
        return node
886514
def visit_call(self, node, parent):
        """"""
        newnode = nodes.Call(node.lineno, node.col_offset, parent)
        starargs = _visit_or_none(node, "starargs", self, newnode)
        kwargs = _visit_or_none(node, "kwargs", self, newnode)
        args = [self.visit(child, newnode) for child in node.args]

        if node.keywords:
            keywords = [self.visit(child, newnode) for child in node.keywords]
        else:
            keywords = None
        if starargs:
            new_starargs = nodes.Starred(
                col_offset=starargs.col_offset,
                lineno=starargs.lineno,
                parent=starargs.parent,
            )
            new_starargs.postinit(value=starargs)
            args.append(new_starargs)
        if kwargs:
            new_kwargs = nodes.Keyword(
                arg=None,
                col_offset=kwargs.col_offset,
                lineno=kwargs.lineno,
                parent=kwargs.parent,
            )
            new_kwargs.postinit(value=kwargs)
            if keywords:
                keywords.append(new_kwargs)
            else:
                keywords = [new_kwargs]

        newnode.postinit(self.visit(node.func, newnode), args, keywords)
        return newnode
714311
function (parent, nodes) {
  for (var i = nodes.length - 1; i >= 0; i--) {
    parent.insertBefore(nodes[nodes.length - 1], parent.firstChild)
  }
}
763083
def append(self, *nodes: Union[AbstractNode, str]) -> None:
        """"""
        node = _to_node_list(nodes)
        self.appendChild(node)
189294
def append(self, node):
        ""
        if not isinstance(node, self.__class__):
            raise TypeError('Expected Node instance, got %r' % node)
        self.nodes.append(node)
204419
def visit_ifexp(self, node, parent):
        """"""
        newnode = nodes.IfExp(node.lineno, node.col_offset, parent)
        newnode.postinit(
            self.visit(node.test, newnode),
            self.visit(node.body, newnode),
            self.visit(node.orelse, newnode),
        )
        return newnode
561256
function insert(queue, index, fns, mode = InsertMode.REGULAR) {
  fns.forEach(({ fn, name }) => {
    if (queue.findIndex(e => e.name === name) !== -1) {
      throw new Error(`${name}: A function is already queued with this name`);
    } else if (typeof fn !== 'function') {
      throw new Error(`${name}: Not a valid function`);
    }
  });

  const deleteCount = mode === InsertMode.REPLACE ? 1 : 0;
  queue.splice(index, deleteCount, ...fns);
}
254582
def add_node(node, parent):
    '''
    '''
    newNode = dict(node_id=node.id, children=[])
    parent["children"].append(newNode)
    if node.left: add_node(node.left, newNode)
    if node.right: add_node(node.right, newNode)
55763
function prepend(nodesToPrepend) {
                var nodes = Array.prototype.slice.call(nodesToPrepend),
                    i = nodes.length;

                while (i--) {
                    el.insertBefore(nodes[i], el.firstChild);
                }
            }
966329
def npartial(func, *args, **kwargs):
  
  def wrapped(self, node):
    func(self, *args, **kwargs)
  return wrapped
789679
function insertContent(node, content) {
	let inserted = insertContentIntoPlaceholder(node, content);
	node.walk(child => inserted |= insertContentIntoPlaceholder(child, content));

	if (!inserted) {
		// no placeholders were found in node, insert content into deepest child
		setNodeContent(findDeepestNode(node), content);
	}

	return node;
}
930849
function insertNode (i, last) {
  var node = new Node(i)

  if (!last) {
    node.prev = node
    node.next = node

  } else {
    node.next = last.next
    node.prev = last
    last.next.prev = node
    last.next = node
  }
  return node
}
894936
def make_node(cls, func_name, lineno, type_=None):
        
        entry = global_.SYMBOL_TABLE.declare_func(func_name, lineno, type_=type_)
        if entry is None:
            return None

        entry.declared = True
        return cls(entry, lineno)