code: function precacheChildNodes(inst, node) {
    if (inst._flags & Flags.hasCachedChildNodes) {
      return;
    }
    var children = inst._renderedChildren;
    var childNode = node.firstChild;
    outer: for (var name in children) {
      if (!children.hasOwnProperty(name)) {
        continue;
      }
      var childInst = children[name];
      var childID = getRenderedHostOrTextFromComponent(childInst)._domID;
      if (childID === 0) {
        // We're currently unmounting this child in ReactMultiChild; skip it.
        continue;
      }
      // We assume the child nodes are in the same order as the child instances.
      for (; childNode !== null; childNode = childNode.nextSibling) {
        if (shouldPrecacheNode(childNode, childID)) {
          precacheNode(childInst, childNode);
          continue outer;
        }
      }
      // We reached the end of the DOM children without finding an ID match.
       true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unable to find element with ID %s.', childID) : _prodInvariant('32', childID) : void 0;
    }
    inst._flags |= Flags.hasCachedChildNodes;
  }
docs: Populate `_hostNode` on each child of `inst`, assuming that the children
  match up with the DOM (element) children of `node`.
  
  We cache entire levels at once to avoid an n^2 problem where we access the
  children of a node sequentially and have to walk from the start to our target
  node every time.
  
  Since we update `_renderedChildren` and the actual DOM at (slightly)
  different times, we could race here and see a newer `_renderedChildren` than
  the DOM nodes we see. To avoid this, ReactMultiChild calls
  `prepareToManageChildren` before we change `_renderedChildren`, at which
  time the container's child nodes are always cached (until it unmounts).