Grammar and style fixes for the jsdoc documentation

Joris-van-der-Wel · Joris-van-der-Wel · commit 20fa9b64726a · 2016-02-28T09:58:30.000+01:00
diff --git a/lib/SymbolTree.js b/lib/SymbolTree.js
@@ -29,7 +29,7 @@ class SymbolTree {
         }
 
         /**
-         * You can optionally initialize an object after its creation,
+         * You can use this function to (optionally) initialize an object right after its creation,
          * to take advantage of V8's fast properties. Also useful if you would like to
          * freeze your object.
          *
@@ -63,7 +63,7 @@ class SymbolTree {
         /**
          * Returns `true` if the object has any children. Otherwise it returns `false`.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method hasChildren
          * @memberOf module:symbol-tree#
@@ -75,9 +75,9 @@ class SymbolTree {
         }
 
         /**
-         * Return the first child of the given object.
+         * Returns the first child of the given object.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method firstChild
          * @memberOf module:symbol-tree#
@@ -89,9 +89,9 @@ class SymbolTree {
         }
 
         /**
-         * Return the last child of the given object.
+         * Returns the last child of the given object.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method lastChild
          * @memberOf module:symbol-tree#
@@ -103,9 +103,9 @@ class SymbolTree {
         }
 
         /**
-         * Return the previous sibling of the given object.
+         * Returns the previous sibling of the given object.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method previousSibling
          * @memberOf module:symbol-tree#
@@ -117,9 +117,9 @@ class SymbolTree {
         }
 
         /**
-         * Return the nextSibling sibling of the given object.
+         * Returns the next sibling of the given object.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method nextSibling
          * @memberOf module:symbol-tree#
@@ -133,7 +133,7 @@ class SymbolTree {
         /**
          * Return the parent of the given object.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method parent
          * @memberOf module:symbol-tree#
@@ -147,7 +147,7 @@ class SymbolTree {
         /**
          * Find the inclusive descendant that is last in tree order of the given object.
          *
-         * `O(n)` (worst case) where n is the depth of the subtree of `object`
+         * * `O(n)` (worst case) where `n` is the depth of the subtree of `object`
          *
          * @method lastInclusiveDescendant
          * @memberOf module:symbol-tree#
@@ -169,8 +169,8 @@ class SymbolTree {
          * An object A is preceding an object B if A and B are in the same tree
          * and A comes before B in tree order.
          *
-         * `O(n)` (worst case) <br>
-         * `O(1)` (amortized when walking the entire tree)
+         * * `O(n)` (worst case)
+         * * `O(1)` (amortized when walking the entire tree)
          *
          * @method preceding
          * @memberOf module:symbol-tree#
@@ -203,8 +203,8 @@ class SymbolTree {
          * An object A is following an object B if A and B are in the same tree
          * and A comes after B in tree order.
          *
-         * `O(n)` (worst case) where n is the amount of objects in the entire tree<br>
-         * `O(1)` (amortized when walking the entire tree)
+         * * `O(n)` (worst case) where `n` is the amount of objects in the entire tree
+         * * `O(1)` (amortized when walking the entire tree)
          *
          * @method following
          * @memberOf module:symbol-tree#
@@ -249,7 +249,7 @@ class SymbolTree {
         /**
          * Append all children of the given object to an array.
          *
-         * `O(n)` where n is the amount of children of the given `parent`
+         * * `O(n)` where `n` is the amount of children of the given `parent`
          *
          * @method childrenToArray
          * @memberOf module:symbol-tree#
@@ -289,7 +289,7 @@ class SymbolTree {
         /**
          * Append all inclusive ancestors of the given object to an array.
          *
-         * `O(n)` where n is the amount of ancestors of the given `object`
+         * * `O(n)` where `n` is the amount of ancestors of the given `object`
          *
          * @method ancestorsToArray
          * @memberOf module:symbol-tree#
@@ -322,7 +322,7 @@ class SymbolTree {
         /**
          * Append all descendants of the given object to an array (in tree order).
          *
-         * `O(n)` where n is the amount of objects in the sub-tree of the given `object`
+         * * `O(n)` where `n` is the amount of objects in the sub-tree of the given `object`
          *
          * @method treeToArray
          * @memberOf module:symbol-tree#
@@ -355,7 +355,7 @@ class SymbolTree {
         /**
          * Iterate over all children of the given object
          *
-         * `O(1)` for a single iteration
+         * * `O(1)` for a single iteration
          *
          * @method childrenIterator
          * @memberOf module:symbol-tree#
@@ -379,7 +379,7 @@ class SymbolTree {
         /**
          * Iterate over all the previous siblings of the given object. (in reverse tree order)
          *
-         * `O(1)` for a single iteration
+         * * `O(1)` for a single iteration
          *
          * @method previousSiblingsIterator
          * @memberOf module:symbol-tree#
@@ -398,7 +398,7 @@ class SymbolTree {
         /**
          * Iterate over all the next siblings of the given object. (in tree order)
          *
-         * `O(1)` for a single iteration
+         * * `O(1)` for a single iteration
          *
          * @method nextSiblingsIterator
          * @memberOf module:symbol-tree#
@@ -417,7 +417,7 @@ class SymbolTree {
         /**
          * Iterate over all inclusive ancestors of the given object
          *
-         * `O(1)` for a single iteration
+         * * `O(1)` for a single iteration
          *
          * @method ancestorsIterator
          * @memberOf module:symbol-tree#
@@ -436,9 +436,10 @@ class SymbolTree {
         /**
          * Iterate over all descendants of the given object (in tree order).
          *
-         * where n is the amount of objects in the sub-tree of the given `root`:
-         * `O(n)` (worst case for a single iterator)
-         * `O(n)` (amortized, when completing the iterator)<br>
+         * Where `n` is the amount of objects in the sub-tree of the given `root`:
+         *
+         * * `O(n)` (worst case for a single iteration)
+         * * `O(n)` (amortized, when completing the iterator)
          *
          * @method treeIterator
          * @memberOf module:symbol-tree#
@@ -461,8 +462,8 @@ class SymbolTree {
         /**
          * Find the index of the given object (the number of preceding siblings).
          *
-         * `O(n)` where n is the amount of preceding siblings<br>
-         * `O(1)` (amortized, if the tree is not modified)
+         * * `O(n)` where `n` is the amount of preceding siblings
+         * * `O(1)` (amortized, if the tree is not modified)
          *
          * @method index
          * @memberOf module:symbol-tree#
@@ -515,8 +516,8 @@ class SymbolTree {
         /**
          * Calculate the number of children.
          *
-         * `O(n)` where n is the amount of children<br>
-         * `O(1)` (amortized, if the tree is not modified)
+         * * `O(n)` where `n` is the amount of children
+         * * `O(1)` (amortized, if the tree is not modified)
          *
          * @method childrenCount
          * @memberOf module:symbol-tree#
@@ -547,10 +548,11 @@ class SymbolTree {
          * The semantics are the same as compareDocumentPosition in DOM, with the exception that
          * DISCONNECTED never occurs with any other bit.
          *
-         * where n and m are the amount of ancestors of `left` and `right`;
-         * where o is the amount of children of the lowest common ancestor of `left` and `right`:
-         * `O(n + m + o)` (worst case)
-         * `O(n + m)` (amortized, if the tree is not modified)
+         * where `n` and `m` are the amount of ancestors of `left` and `right`;
+         * where `o` is the amount of children of the lowest common ancestor of `left` and `right`:
+         *
+         * * `O(n + m + o)` (worst case)
+         * * `O(n + m)` (amortized, if the tree is not modified)
          *
          * @method compareTreePosition
          * @memberOf module:symbol-tree#
@@ -633,7 +635,7 @@ class SymbolTree {
          * Remove the object from this tree.
          * Has no effect if already removed.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method remove
          * @memberOf module:symbol-tree#
@@ -679,7 +681,7 @@ class SymbolTree {
          * Insert the given object before the reference object.
          * `newObject` is now the previous sibling of `referenceObject`.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method insertBefore
          * @memberOf module:symbol-tree#
@@ -722,7 +724,7 @@ class SymbolTree {
          * Insert the given object after the reference object.
          * `newObject` is now the next sibling of `referenceObject`.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method insertAfter
          * @memberOf module:symbol-tree#
@@ -765,7 +767,7 @@ class SymbolTree {
          * Insert the given object as the first child of the given reference object.
          * `newObject` is now the first child of `referenceObject`.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method prependChild
          * @memberOf module:symbol-tree#
@@ -799,7 +801,7 @@ class SymbolTree {
          * Insert the given object as the last child of the given reference object.
          * `newObject` is now the last child of `referenceObject`.
          *
-         * `O(1)`
+         * * `O(1)`
          *
          * @method appendChild
          * @memberOf module:symbol-tree#

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ class SymbolTree {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`/**`
`32`		`- * You can optionally initialize an object after its creation,`
	`32`	`+ * You can use this function to (optionally) initialize an object right after its creation,`
`33`	`33`	`* to take advantage of V8's fast properties. Also useful if you would like to`
`34`	`34`	`* freeze your object.`
`35`	`35`	`*`
`@@ -63,7 +63,7 @@ class SymbolTree {`
`63`	`63`	`/**`
`64`	`64`	* Returns `true` if the object has any children. Otherwise it returns `false`.
`65`	`65`	`*`
`66`		- * `O(1)`
	`66`	+ * * `O(1)`
`67`	`67`	`*`
`68`	`68`	`* @method hasChildren`
`69`	`69`	`* @memberOf module:symbol-tree#`
`@@ -75,9 +75,9 @@ class SymbolTree {`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`/**`
`78`		`- * Return the first child of the given object.`
	`78`	`+ * Returns the first child of the given object.`
`79`	`79`	`*`
`80`		- * `O(1)`
	`80`	+ * * `O(1)`
`81`	`81`	`*`
`82`	`82`	`* @method firstChild`
`83`	`83`	`* @memberOf module:symbol-tree#`
`@@ -89,9 +89,9 @@ class SymbolTree {`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`/**`
`92`		`- * Return the last child of the given object.`
	`92`	`+ * Returns the last child of the given object.`
`93`	`93`	`*`
`94`		- * `O(1)`
	`94`	+ * * `O(1)`
`95`	`95`	`*`
`96`	`96`	`* @method lastChild`
`97`	`97`	`* @memberOf module:symbol-tree#`
`@@ -103,9 +103,9 @@ class SymbolTree {`
`103`	`103`	`}`
`104`	`104`
`105`	`105`	`/**`
`106`		`- * Return the previous sibling of the given object.`
	`106`	`+ * Returns the previous sibling of the given object.`
`107`	`107`	`*`
`108`		- * `O(1)`
	`108`	+ * * `O(1)`
`109`	`109`	`*`
`110`	`110`	`* @method previousSibling`
`111`	`111`	`* @memberOf module:symbol-tree#`
`@@ -117,9 +117,9 @@ class SymbolTree {`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`/**`
`120`		`- * Return the nextSibling sibling of the given object.`
	`120`	`+ * Returns the next sibling of the given object.`
`121`	`121`	`*`
`122`		- * `O(1)`
	`122`	+ * * `O(1)`
`123`	`123`	`*`
`124`	`124`	`* @method nextSibling`
`125`	`125`	`* @memberOf module:symbol-tree#`
`@@ -133,7 +133,7 @@ class SymbolTree {`
`133`	`133`	`/**`
`134`	`134`	`* Return the parent of the given object.`
`135`	`135`	`*`
`136`		- * `O(1)`
	`136`	+ * * `O(1)`
`137`	`137`	`*`
`138`	`138`	`* @method parent`
`139`	`139`	`* @memberOf module:symbol-tree#`
`@@ -147,7 +147,7 @@ class SymbolTree {`
`147`	`147`	`/**`
`148`	`148`	`* Find the inclusive descendant that is last in tree order of the given object.`
`149`	`149`	`*`
`150`		- * `O(n)` (worst case) where n is the depth of the subtree of `object`
	`150`	+ * * `O(n)` (worst case) where `n` is the depth of the subtree of `object`
`151`	`151`	`*`
`152`	`152`	`* @method lastInclusiveDescendant`
`153`	`153`	`* @memberOf module:symbol-tree#`
`@@ -169,8 +169,8 @@ class SymbolTree {`
`169`	`169`	`* An object A is preceding an object B if A and B are in the same tree`
`170`	`170`	`* and A comes before B in tree order.`
`171`	`171`	`*`
`172`		- * `O(n)` (worst case) <br>
`173`		- * `O(1)` (amortized when walking the entire tree)
	`172`	+ * * `O(n)` (worst case)
	`173`	+ * * `O(1)` (amortized when walking the entire tree)
`174`	`174`	`*`
`175`	`175`	`* @method preceding`
`176`	`176`	`* @memberOf module:symbol-tree#`
`@@ -203,8 +203,8 @@ class SymbolTree {`
`203`	`203`	`* An object A is following an object B if A and B are in the same tree`
`204`	`204`	`* and A comes after B in tree order.`
`205`	`205`	`*`
`206`		- * `O(n)` (worst case) where n is the amount of objects in the entire tree<br>
`207`		- * `O(1)` (amortized when walking the entire tree)
	`206`	+ * * `O(n)` (worst case) where `n` is the amount of objects in the entire tree
	`207`	+ * * `O(1)` (amortized when walking the entire tree)
`208`	`208`	`*`
`209`	`209`	`* @method following`
`210`	`210`	`* @memberOf module:symbol-tree#`
`@@ -249,7 +249,7 @@ class SymbolTree {`
`249`	`249`	`/**`
`250`	`250`	`* Append all children of the given object to an array.`
`251`	`251`	`*`
`252`		- * `O(n)` where n is the amount of children of the given `parent`
	`252`	+ * * `O(n)` where `n` is the amount of children of the given `parent`
`253`	`253`	`*`
`254`	`254`	`* @method childrenToArray`
`255`	`255`	`* @memberOf module:symbol-tree#`
`@@ -289,7 +289,7 @@ class SymbolTree {`
`289`	`289`	`/**`
`290`	`290`	`* Append all inclusive ancestors of the given object to an array.`
`291`	`291`	`*`
`292`		- * `O(n)` where n is the amount of ancestors of the given `object`
	`292`	+ * * `O(n)` where `n` is the amount of ancestors of the given `object`
`293`	`293`	`*`
`294`	`294`	`* @method ancestorsToArray`
`295`	`295`	`* @memberOf module:symbol-tree#`
`@@ -322,7 +322,7 @@ class SymbolTree {`
`322`	`322`	`/**`
`323`	`323`	`* Append all descendants of the given object to an array (in tree order).`
`324`	`324`	`*`
`325`		- * `O(n)` where n is the amount of objects in the sub-tree of the given `object`
	`325`	+ * * `O(n)` where `n` is the amount of objects in the sub-tree of the given `object`
`326`	`326`	`*`
`327`	`327`	`* @method treeToArray`
`328`	`328`	`* @memberOf module:symbol-tree#`
`@@ -355,7 +355,7 @@ class SymbolTree {`
`355`	`355`	`/**`
`356`	`356`	`* Iterate over all children of the given object`
`357`	`357`	`*`
`358`		- * `O(1)` for a single iteration
	`358`	+ * * `O(1)` for a single iteration
`359`	`359`	`*`
`360`	`360`	`* @method childrenIterator`
`361`	`361`	`* @memberOf module:symbol-tree#`
`@@ -379,7 +379,7 @@ class SymbolTree {`
`379`	`379`	`/**`
`380`	`380`	`* Iterate over all the previous siblings of the given object. (in reverse tree order)`
`381`	`381`	`*`
`382`		- * `O(1)` for a single iteration
	`382`	+ * * `O(1)` for a single iteration
`383`	`383`	`*`
`384`	`384`	`* @method previousSiblingsIterator`
`385`	`385`	`* @memberOf module:symbol-tree#`
`@@ -398,7 +398,7 @@ class SymbolTree {`
`398`	`398`	`/**`
`399`	`399`	`* Iterate over all the next siblings of the given object. (in tree order)`
`400`	`400`	`*`
`401`		- * `O(1)` for a single iteration
	`401`	+ * * `O(1)` for a single iteration
`402`	`402`	`*`
`403`	`403`	`* @method nextSiblingsIterator`
`404`	`404`	`* @memberOf module:symbol-tree#`
`@@ -417,7 +417,7 @@ class SymbolTree {`
`417`	`417`	`/**`
`418`	`418`	`* Iterate over all inclusive ancestors of the given object`
`419`	`419`	`*`
`420`		- * `O(1)` for a single iteration
	`420`	+ * * `O(1)` for a single iteration
`421`	`421`	`*`
`422`	`422`	`* @method ancestorsIterator`
`423`	`423`	`* @memberOf module:symbol-tree#`
`@@ -436,9 +436,10 @@ class SymbolTree {`
`436`	`436`	`/**`
`437`	`437`	`* Iterate over all descendants of the given object (in tree order).`
`438`	`438`	`*`
`439`		- * where n is the amount of objects in the sub-tree of the given `root`:
`440`		- * `O(n)` (worst case for a single iterator)
`441`		- * `O(n)` (amortized, when completing the iterator)<br>
	`439`	+ * Where `n` is the amount of objects in the sub-tree of the given `root`:
	`440`	`+ *`
	`441`	+ * * `O(n)` (worst case for a single iteration)
	`442`	+ * * `O(n)` (amortized, when completing the iterator)
`442`	`443`	`*`
`443`	`444`	`* @method treeIterator`
`444`	`445`	`* @memberOf module:symbol-tree#`
`@@ -461,8 +462,8 @@ class SymbolTree {`
`461`	`462`	`/**`
`462`	`463`	`* Find the index of the given object (the number of preceding siblings).`
`463`	`464`	`*`
`464`		- * `O(n)` where n is the amount of preceding siblings<br>
`465`		- * `O(1)` (amortized, if the tree is not modified)
	`465`	+ * * `O(n)` where `n` is the amount of preceding siblings
	`466`	+ * * `O(1)` (amortized, if the tree is not modified)
`466`	`467`	`*`
`467`	`468`	`* @method index`
`468`	`469`	`* @memberOf module:symbol-tree#`
`@@ -515,8 +516,8 @@ class SymbolTree {`
`515`	`516`	`/**`
`516`	`517`	`* Calculate the number of children.`
`517`	`518`	`*`
`518`		- * `O(n)` where n is the amount of children<br>
`519`		- * `O(1)` (amortized, if the tree is not modified)
	`519`	+ * * `O(n)` where `n` is the amount of children
	`520`	+ * * `O(1)` (amortized, if the tree is not modified)
`520`	`521`	`*`
`521`	`522`	`* @method childrenCount`
`522`	`523`	`* @memberOf module:symbol-tree#`
`@@ -547,10 +548,11 @@ class SymbolTree {`
`547`	`548`	`* The semantics are the same as compareDocumentPosition in DOM, with the exception that`
`548`	`549`	`* DISCONNECTED never occurs with any other bit.`
`549`	`550`	`*`
`550`		- * where n and m are the amount of ancestors of `left` and `right`;
`551`		- * where o is the amount of children of the lowest common ancestor of `left` and `right`:
`552`		- * `O(n + m + o)` (worst case)
`553`		- * `O(n + m)` (amortized, if the tree is not modified)
	`551`	+ * where `n` and `m` are the amount of ancestors of `left` and `right`;
	`552`	+ * where `o` is the amount of children of the lowest common ancestor of `left` and `right`:
	`553`	`+ *`
	`554`	+ * * `O(n + m + o)` (worst case)
	`555`	+ * * `O(n + m)` (amortized, if the tree is not modified)
`554`	`556`	`*`
`555`	`557`	`* @method compareTreePosition`
`556`	`558`	`* @memberOf module:symbol-tree#`
`@@ -633,7 +635,7 @@ class SymbolTree {`
`633`	`635`	`* Remove the object from this tree.`
`634`	`636`	`* Has no effect if already removed.`
`635`	`637`	`*`
`636`		- * `O(1)`
	`638`	+ * * `O(1)`
`637`	`639`	`*`
`638`	`640`	`* @method remove`
`639`	`641`	`* @memberOf module:symbol-tree#`
`@@ -679,7 +681,7 @@ class SymbolTree {`
`679`	`681`	`* Insert the given object before the reference object.`
`680`	`682`	* `newObject` is now the previous sibling of `referenceObject`.
`681`	`683`	`*`
`682`		- * `O(1)`
	`684`	+ * * `O(1)`
`683`	`685`	`*`
`684`	`686`	`* @method insertBefore`
`685`	`687`	`* @memberOf module:symbol-tree#`
`@@ -722,7 +724,7 @@ class SymbolTree {`
`722`	`724`	`* Insert the given object after the reference object.`
`723`	`725`	* `newObject` is now the next sibling of `referenceObject`.
`724`	`726`	`*`
`725`		- * `O(1)`
	`727`	+ * * `O(1)`
`726`	`728`	`*`
`727`	`729`	`* @method insertAfter`
`728`	`730`	`* @memberOf module:symbol-tree#`
`@@ -765,7 +767,7 @@ class SymbolTree {`
`765`	`767`	`* Insert the given object as the first child of the given reference object.`
`766`	`768`	* `newObject` is now the first child of `referenceObject`.
`767`	`769`	`*`
`768`		- * `O(1)`
	`770`	+ * * `O(1)`
`769`	`771`	`*`
`770`	`772`	`* @method prependChild`
`771`	`773`	`* @memberOf module:symbol-tree#`
`@@ -799,7 +801,7 @@ class SymbolTree {`
`799`	`801`	`* Insert the given object as the last child of the given reference object.`
`800`	`802`	* `newObject` is now the last child of `referenceObject`.
`801`	`803`	`*`
`802`		- * `O(1)`
	`804`	+ * * `O(1)`
`803`	`805`	`*`
`804`	`806`	`* @method appendChild`
`805`	`807`	`* @memberOf module:symbol-tree#`