anchor.diff:     * World-space = Root-space.
      * Note: The returned object is poolable.
      *     Remember to call the object's [moveToPool] method when finished.
  -   */
  -  Vector2P convertToWorldSpace(Vector2 nodePoint) {
  -    AffineTransform nwt = nodeToWorldTransform();
  +   * 
  +   * [pseudoRoot] is a [Node] that you are sure is a common ancestor
  +   * to the Nodes you are mapping between. However, there is one caveat,
  +   * All the ancestor to the pseudo root must be statically Identity
  +   * transforms. Otherwise you will get improper mapping.
  +   * Providing a pseudoRoot could save a few matrix multiplications.
  +   * 
  +   * When in doubt simply omit providing a pseudoRoot.
  +   */
  +  Vector2P convertToWorldSpace(Vector2 nodePoint, [BaseNode pseudoRoot]) {
  +    AffineTransform nwt = nodeToWorldTransform(pseudoRoot);
       
       Vector2P p = PointApplyAffineTransform(nodePoint, nwt);
       
  
positive.code:       // [child] x [parent ofchild] x [parent of parent of child]...
        //
        // In other words the child is mutiplied "into" the parent.
  //      AffineTransform t = affineTransformMultiply(comp, parentT);
  //      childT.setWithAT(t);
  //      t.moveToPool();
        
        affineTransformMultiplyFrom(comp, parentT);   // <--- correct
  //      affineTransformMultiplyTo(parentT, comp);
  
        // next parent upwards 
        p = p._parent;
      }
  
      return comp;  // return pooled object
    }
  
    double nodeToWorldScale() {
      double scale = uniformScale;
      
  
negative.code:    * The result are in [Point]s.
     * Note: The returned object is poolable.
     *     Remember to call the object's [moveToPool] method when finished.
     * 
     * [pseudoRoot] is a [Node] that you are sure is a common ancestor
     * to the Nodes you are mapping between. However, there is one caveat,
     * All the ancestor to the pseudo root must be statically Identity
     * transforms. Otherwise you will get improper mapping.
     * Providing a pseudoRoot could save a few matrix multiplications.
     * 
     * When in doubt simply omit providing a pseudoRoot.
     */
    Vector2P convertWorldToNodeSpace(Vector2 point, [BaseNode pseudoRoot]) {
      AffineTransform wnt = worldToNodeTransform(pseudoRoot);
      Vector2P p = PointApplyAffineTransform(point, wnt);
      wnt.moveToPool();
      return p; // Remember to call moveToPool on "p"
  