Generates a "mount image" for each of the supplied children. In the case
of `ReactDOMComponent`, a mount image is a string of markup.

@param {?object} nestedChildNodes Nested child maps.
@return {?object} A set of child instances.
@internal
509284
function (nestedChildNodes, transaction, context, selfDebugID) // 0 in production and for roots
  {
    if (nestedChildNodes == null) {
      return null;
    }
    var childInstances = {};

    if (process.env.NODE_ENV !== 'production') {
      traverseAllChildren(nestedChildNodes, function (childInsts, child, name) {
        return instantiateChild(childInsts, child, name, selfDebugID);
      }, childInstances);
    } else {
      traverseAllChildren(nestedChildNodes, instantiateChild, childInstances);
    }
    return childInstances;
  }
198725
function deepMap(children, callback) {//参考https://github.com/reactjs/react-tabs/blob/master/src/helpers/childrenDeepMap.js
  return Children.map(children, child => {
    if (child === null) return null;
    if (isRViewerTrigger(child)) {
      return callback(child);
    }
    if (child.props && child.props.children && typeof child.props.children === 'object') {
      return cloneElement(child, {
        ...child.props,
        children: deepMap(child.props.children, callback),
      });
    }
    return child;
  });
}
905784
function(children) {
      return this.each(function(index, el) {
        children.each(function(index, child) {
          el.appendChild(child);
        });
      });
    }
84499
public Iterator childNodes() {
        return new Iterator() {
            private final Iterator iter = Node.this.children.iterator();
            private Object nextElementNodes = getNextElementNodes();

            public boolean hasNext() {
                return this.nextElementNodes != null;
            }

            public Object next() {
                try {
                    return this.nextElementNodes;
                } finally {
                    this.nextElementNodes = getNextElementNodes();
                }
            }

            public void remove() {
                throw new UnsupportedOperationException();
            }

            private Object getNextElementNodes() {
                while (iter.hasNext()) {
                    final Object node = iter.next();
                    if (node instanceof Node) {
                        return node;
                    }
                }
                return null;
            }
        };
    }
711524
@Override
  public Collection<ConfigKeyPath> getChildren(ConfigKeyPath configKey) {
    try {
      return this.childrenMap.get(configKey, () -> this.fallback.getChildren(configKey));
    } catch (ExecutionException ee) {
      throw new RuntimeException(ee);
    }
  }
505453
function arrayCopyChildNodes(parent) {
    var copy=[], i=0;
    for (var n=parent.firstChild; n; n=n.nextSibling) {
      copy[i++] = n;
    }
    return copy;
  }
203541
function(container) {
    // Various parts of our code (such as ReactCompositeComponent's
    // _renderValidatedComponent) assume that calls to render aren't nested;
    // verify that that's the case. (Strictly speaking, unmounting won't cause a
    // render but we still don't expect to be in a render call here.)
    ("production" !== "development" ? warning(
      ReactCurrentOwner.current == null,
      'unmountComponentAtNode(): Render methods should be a pure function of ' +
      'props and state; triggering nested component updates from render is ' +
      'not allowed. If necessary, trigger nested updates in ' +
      'componentDidUpdate.'
    ) : null);

    ("production" !== "development" ? invariant(
      container && (
        (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)
      ),
      'unmountComponentAtNode(...): Target container is not a DOM element.'
    ) : invariant(container && (
      (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)
    )));

    var reactRootID = getReactRootID(container);
    var component = instancesByReactRootID[reactRootID];
    if (!component) {
      return false;
    }
    ReactMount.unmountComponentFromNode(component, container);
    delete instancesByReactRootID[reactRootID];
    delete containersByReactRootID[reactRootID];
    if ("production" !== "development") {
      delete rootElementsByReactRootID[reactRootID];
    }
    return true;
  }
501816
function(node, collapsedChildren){
    var children = node.data('collapsedChildren');
    var i;
    for (i=0; i < children.length; i++){
      if (children[i].data('collapsedChildren')){
        collapsedChildren = collapsedChildren.union(this.getCollapsedChildrenRecursively(children[i], collapsedChildren));
      }
      collapsedChildren = collapsedChildren.union(children[i]);
    }
    return collapsedChildren;
  }
1077088
function flattenChildren(children, selfDebugID) {
  if (children == null) {
    return children;
  }
  var result = {};

  if ("development" !== 'production') {
    traverseAllChildren(children, function (traverseContext, child, name) {
      return flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID);
    }, result);
  } else {
    traverseAllChildren(children, flattenSingleChildIntoContext, result);
  }
  return result;
}
321422
public function setChildNodes(array $childNodes)
    {
        $rootNode = $this->objectManager->get(RootNode::class);
        foreach ($childNodes as $childNode) {
            $rootNode->addChildNode($childNode);
        }
        $this->widgetContext->setViewHelperChildNodes($rootNode, $this->renderingContext);
    }
105165
function(data){
	var container = document.createElement(data.childTag);
	data.nodes.forEach(function(node){
		container.appendChild(renderNodeTarget.hydrate({node: node, childTag: data.childTag}));
	});
	return container;
}
902162
function mount(selector, tagName, opts) {
      var tags = [];
      var elem, allTags;

      function pushTagsTo(root) {
        if (root.tagName) {
          var riotTag = getAttribute(root, IS_DIRECTIVE), tag;

          // have tagName? force riot-tag to be the same
          if (tagName && riotTag !== tagName) {
            riotTag = tagName;
            setAttribute(root, IS_DIRECTIVE, tagName);
          }

          tag = mount$1(root, riotTag || root.tagName.toLowerCase(), opts);

          if (tag)
            { tags.push(tag); }
        } else if (root.length)
          { each(root, pushTagsTo); } // assume nodeList
      }

      // inject styles into DOM
      styleManager.inject();

      if (isObject$1(tagName)) {
        opts = tagName;
        tagName = 0;
      }

      // crawl the DOM to find the tag
      if (isString(selector)) {
        selector = selector === '*' ?
          // select all registered tags
          // & tags found with the riot-tag attribute set
          allTags = query() :
          // or just the ones named like the selector
          selector + query(selector.split(/, */));

        // make sure to pass always a selector
        // to the querySelectorAll function
        elem = selector ? $$(selector) : [];
      }
      else
        // probably you have passed already a tag or a NodeList
        { elem = selector; }

      // select all the registered and mount them inside their root elements
      if (tagName === '*') {
        // get all custom tags
        tagName = allTags || query();
        // if the root els it's just a single tag
        if (elem.tagName)
          { elem = $$(tagName, elem); }
        else {
          // select all the children for all the different root elements
          var nodeList = [];

          each(elem, function (_el) { return nodeList.push($$(tagName, _el)); });

          elem = nodeList;
        }
        // get rid of the tagName
        tagName = 0;
      }

      pushTagsTo(elem);

      return tags
    }
1322933
@SafeVarargs
	public final TreeNode<T> attach(final T... children) {
		for (T child : children) {
			attach(TreeNode.of(child));
		}

		return this;
	}
843279
function(markup) {

	var container = document.createElement('div');
	container.innerHTML = markup;

	return new NWTNodeInstance(container.childNodes[0]);
}
1310182
public Map<String, String> getChildrenMap(String parentId) {
		Map<String, String> map = new HashMap<>();
		List<StringEntity> children = getByField(Column.PARENT_ID, parentId);
		for (StringEntity stringEntity : children) {
			map.put(stringEntity.getId(), stringEntity.getValue());
		}
		return map;
	}
256963
function ListNode (children) {
    for(var i = 0; i < children.length; i++)
        this[i] = children[i];
    this.length = children.length;
}
676792
function getNodeSlots (element) {
  let nodeSlots = [...element.childNodes]
    .map(node => {
      element.removeChild(node)
      return node
    })

  return nodeSlots
}