Added missing documentation.

Author: hexydec

src/manipulation/insertto/readme.md

@@ -0,0 +1,61 @@
+# .insertBefore()
+Add nodes before each object in a Dabby collection.
+
+# .prependTo()
+Prepend nodes to each object in a Dabby collection.
+
+# .appendTo()
+Append nodes to each object in a Dabby collection.
+
+# .insertAfter()
+Add nodes after each object in a Dabby collection.
+
+## Usage
+```javascript
+$(content).insertBefore(selector);
+$(content).prependTo(selector);
+$(content).appendTo(selector);
+$(content).insertAfter(selector);
+```
+
+### content
+The Dabby collection, node, array of nodes, or document to insert.
+
+### selector
+A string specifying a CSS selector, a node, an array of nodes, a document, or a Dabby collection to attach the Dabby collection to.
+
+## Returns
+The original Dabby collection.
+
+## Differences to jQuery
+None.
+
+## Examples
+
+### Using .insertBefore()
+This will insert the `<span>` element before the` <p>` element.
+
+```javascript
+$("<span>Hello</span>").insertBefore("p.target");
+```
+
+### Using .prependTo()
+This will prepend the `<h2>` element to the `<section>` element.
+
+```javascript
+$("<h2>My Title</h2>").prependTo("section.main");
+```
+
+### Using .appendTo()
+This will append the `<li>` element to the `<ul>` element.
+
+```javascript
+$("<li>Item 3</li>").appendTo("ul#my-list");
+```
+
+### Using .insertAfter()
+This will insert the `<button>` element after the `<div>` element.
+
+```javascript
+$("<button>Click Me</button>").insertAfter("div#container");
+```

src/manipulation/remove/readme.md

@@ -0,0 +1,61 @@
+# .detach()
+Detaches some or all of the items in the collection from the DOM. This method is similar to .remove(), except it keeps all data and events associated with the detached elements. This is useful if you want to reinsert the elements into the DOM later.
+
+## Usage
+```javascript
+$(selector).detach();
+$(selector).detach(selector);
+```
+
+### selector
+A optional selector, HTML string, Node, array of Nodes, Dabby collection or a callback function to filter the collection by.
+
+## Returns
+A new Dabby collection containing the detached nodes.
+
+## Differences to jQuery
+None.
+
+## Examples
+Detach all `<li>` elements from a `<ul>`, this will remove all list items from the `<ul>` and store them in a variable:
+
+```javascript
+const items = $("ul#my-list li").detach();
+```
+
+Detach a specific `<div>` with a filter, this will detach any `<p>` elements that are children of `#my-div`:
+
+```javascript
+const items = $("div#my-div p").detach("p");
+```
+
+# .remove()
+Removes some or all of the items in the collection from the DOM. This method removes the selected elements and all of their associated data and events.
+
+## Usage
+```javascript
+$(collection).remove();
+$(collection).remove(selector);
+```
+
+### selector
+A optional selector, HTML string, Node, array of Nodes, Dabby collection or a callback function to filter the collection by.
+
+## Returns
+The original Dabby collection.
+
+## Differences to jQuery
+None.
+
+## Examples
+Remove a button from the page, this will completely remove the button and its associated data from the page:
+
+```javascript
+$("button#my-button").remove();
+```
+
+Remove specific `<li>` elements, this will remove any list items with the class completed:
+
+```javascript
+$("ul#my-list li").remove(".completed");
+```

src/manipulation/replace/readme.md

@@ -0,0 +1,53 @@
+# .replaceAll()
+Replaces all elements matched by a selector with the elements in the current Dabby collection. This method is the reverse of `.replaceWith()`.
+
+## Usage
+```javascript
+$(content).replaceAll(selector);
+```
+
+### selector
+A selector string, Node, array of Nodes, Dabby collection or a callback function.
+
+### content
+An HTML string, Node, array of Nodes, or a Dabby collection.
+
+## Returns
+The original Dabby collection.
+
+## Differences to jQuery
+None.
+
+## Examples
+This will replace all `<h2>` elements with the `<p>` element.
+
+```javascript
+$("<p>A new paragraph</p>").replaceAll("h2");
+```
+
+# .replaceWith()
+Replaces each element in the current Dabby collection with the provided new elements.
+
+## Usage
+```javascript
+$(selector).replaceWith(content);
+```
+
+### selector
+A selector string, Node, array of Nodes, Dabby collection or a callback function.
+
+### content
+An HTML string, Node, array of Nodes, or a Dabby collection.
+
+## Returns
+The original Dabby collection.
+
+## Differences to jQuery
+None.
+
+## Examples
+This will replace each `.item` div with a new `<li>` element:
+
+```javascript
+$(".item").replaceWith("<li>New List Item</li>");
+```

src/manipulation/text/readme.md

@@ -0,0 +1,39 @@
+# .text()
+Retrieves the text from all items in the collection, or sets the text content on each item in the collection.
+
+## Usage
+```javascript
+$(selector).text();
+$(selector).text(text);
+```
+
+### text
+A string of text, or a function that returns a string.
+
+## Returns
+When getting text: A string containing the combined text of all elements in the collection.
+
+When setting text: The original Dabby collection.
+
+## Differences to jQuery
+None.
+
+## Examples
+This will retrieve the text content of the `<p>` element:
+
+```javascript
+const myText = $("p").text();
+console.log(myText);
+```
+
+This will set the text content of the `<h2>` element to "New Title".
+
+```javascript
+$("h2").text("New Title");
+```
+
+Set the text using a function, this will set the text of each `<li>` element to include its index and its original text.
+
+```javascript
+$("li").text((i, value) => "Item " + (i + 1) + ": " + value);
+```

src/manipulation/unwrap/readme.md

@@ -0,0 +1,30 @@
+# .unwrap()
+Removes the parents of some or all of the items in the collection, leaving the children in their place.
+
+## Usage
+```javascript
+$(collection).unwrap();
+$(collection).unwrap(selector);
+```
+
+### selector
+An optional selector to match the parent element to be removed.
+
+## Returns
+The original Dabby collection.
+
+## Differences to jQuery
+None.
+
+## Examples
+Unwrap all `<div>` elements, this will remove the `<div>` parent of all `p` tags with the target class, moving the `p` tags up one level in the DOM tree.
+
+```javascript
+$("p.target").unwrap("div");
+```
+
+Unwrap a specific element, this will unwrap the `<p>` element from its `<span>` parent, leaving the `<span>`'s content in its place.
+
+```javascript
+$("p.my-paragraph").unwrap();
+```

src/manipulation/wrap/readme.md

@@ -0,0 +1,46 @@
+# .wrap()
+Wraps each element in the collection with the provided new elements.
+
+## Usage
+```javascript
+$(selector).wrap(html);
+```
+
+### html
+An HTML string, Node, array of Nodes, Dabby collection or a callback function.
+
+## Returns
+The original Dabby collection.
+
+## Differences to jQuery
+None.
+
+## Examples
+Wrap a single element, this will wrap the `<p>` element with a `<div>` element:
+
+```javascript
+// HTML before
+// <p>Hello, World!</p>
+
+$("p").wrap("<div>");
+
+// HTML after
+// <div><p>Hello, World!</p></div>
+```
+
+Wrap multiple elements, this will wrap each `<li>` element with a `<div>` element:
+
+```javascript
+// HTML before
+// <p>Item 1</p>
+// <p>Item 2</p>
+// <p>Item 3</p>
+
+const div = $("<div>", {"class": "wrap"});
+$("p").wrap(div); // will be cloned for each item that is wrapped
+
+// HTML after
+// <div class="wrap"><p>Item 1</p></div>
+// <div class="wrap"><p>Item 2</p></div>
+// <div class="wrap"><p>Item 3</p></div>
+```

src/manipulation/wrapall/readme.md

@@ -0,0 +1,35 @@
+# .wrapAll()
+Wraps all elements in the collection with the provided new elements. Unlike .wrap(), this method wraps all elements with a single element, rather than wrapping each element individually.
+
+## Usage
+```javascript
+$(selector).wrapAll(html);
+```
+
+### html
+An HTML string, Node, array of Nodes, Dabby collection or a callback function.
+
+## Returns
+The original Dabby collection.
+
+## Differences to jQuery
+None.
+
+## Examples
+This will wrap all `<h2>` and `<p>` elements with a `<div>` element:
+
+```javascript
+// HTML before
+// <h2>Item 1</h2>
+// <p>Item 2</p>
+// <p>Item 3</p>
+
+$("h2, p").wrapAll("<div>");
+
+// HTML after
+// <div>
+//	<h2>Item 1</h2>
+//	<p>Item 2</p>
+//	<p>Item 3</p>
+// </div>
+```

src/utils/isplainobject/readme.md

@@ -0,0 +1,41 @@
+# $.isPlainObject()
+Tests a value to see if it is a plain object, that was defined with {} and has a prototype of Object.
+
+## Usage
+```javascript
+$.isPlainObject(obj);
+```
+
+### obj
+The value to be tested.
+
+## Returns
+A boolean indicating whether the input value is a plain object.
+
+## Differences to jQuery
+None.
+
+## Examples
+This will return `true` because the object was created using object literal notation:
+
+```javascript
+const myObject = {};
+console.log($.isPlainObject(myObject));
+// Expected output: true
+```
+
+This will return `false` because an array's prototype is `Array`, not `Object`:
+
+```javascript
+const myArray = [];
+console.log($.isPlainObject(myArray));
+// Expected output: false
+```
+
+This will return `false` because a `Date` object's prototype is `Date`:
+
+```javascript
+const myDate = new Date();
+console.log($.isPlainObject(myDate));
+// Expected output: false
+```