Updated version and references.

Author: Oren (electricessence)

Open.Hierarchy.csproj

@@ -14,9 +14,8 @@ Part of the "Open" set of libraries.</Description>
     <RepositoryUrl>https://github.com/electricessence/Open.Hierarchy/</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
     <PackageTags>dotnet, dotnetcore, cs, tree, node, hierarchy, parent, child, root</PackageTags>
-    <Version>1.6.1</Version>
-    <PackageReleaseNotes>Improved API.  Implemented IList&lt;Node&lt;T&gt;&gt; for all nodes.
-Validated mapping optimization.</PackageReleaseNotes>
+    <Version>1.6.2</Version>
+    <PackageReleaseNotes></PackageReleaseNotes>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
   </PropertyGroup>
 
@@ -35,7 +34,7 @@ Validated mapping optimization.</PackageReleaseNotes>
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Open.Disposable.ObjectPools" Version="2.3.2" />
+    <PackageReference Include="Open.Disposable.ObjectPools" Version="2.3.3" />
   </ItemGroup>
 
 </Project>

Readme.md

@@ -1,20 +1,25 @@
 # Open.Hierarchy
 
-## ```Node<T>```
-One of the important abilities of ```Node<T>``` and its supporting classes is to allow for creating and modifying tree structures that only have a parent to child relationship.  It's important to ensure that a node cannot occur multiple times in a tree but an instance of its value can occur any number of times. This facilitates potential 'value sub-trees' that can have dupicate references but not duplicate instances.  By using ```Node<T>``` as a container, a single instance can exist multiple times in a tree but still be uniquely indentifyable by its position.
+## `Node<T>`
 
-## ```Node<T>.Factory```
+One of the important abilities of `Node<T>` and its supporting classes is to allow for creating and modifying tree structures that only have a parent to child relationship.  It's important to ensure that a node cannot occur multiple times in a tree but an instance of its value can occur any number of times. This facilitates potential 'value sub-trees' that can have duplicate references but not duplicate instances.  By using `Node<T>` as a container, a single instance can exist multiple times in a tree but still be uniquely identifiable by its position.
+
+## `Node<T>.Factory`
 
 ### Blank Instance
-Calling ```.GetBlankNode()``` will retrieve a blank node from the underlying object pool or create a new one.
+
+Calling `.GetBlankNode()` will retrieve a blank node from the underlying object pool or create a new one.
 
 ### Mapping
-Calling ```.Map(root)``` generates node hierarchy map based upon if the root or any of its children implement ```IParent```. 
+
+Calling `.Map(root)` generates node hierarchy map based upon if the root or any of its children implement `IParent`.
 
 ### Cloning
-Calling ```.Clone(node)``` creates a copy of the node map.
+
+Calling `.Clone(node)` creates a copy of the node map.
 
 ### Recycling
-```Node<T>``` instances can be recycled by calling the ```Factory.Recycle(node)``` method.  The node itself and its children are torn down and recycled to an object pool.
 
-***WARNING:*** The ```Factory.Recycle(node)``` method is the one point of potential trouble if multiple references are retained.  It must be used with care.
+`Node<T>` instances can be recycled by calling the `Factory.Recycle(node)` method.  The node itself and its children are torn down and recycled to an object pool.
+
+***WARNING:*** The `Factory.Recycle(node)` method is the one point of potential trouble if multiple references are retained.  It must be used with care.