Update README.md

Author: jviide

README.md

@@ -10,85 +10,87 @@ $ npm install @hownetworks/ipv46
 
 # Usage
 
-On environments that support the **import** syntax:
-
-```js
-import parseIP from "@hownetworks/ipv46";
-```
-
-On environments that don't support the above syntax (e.g. default Node.js):
-
 ```js
-const parseIP = require("@hownetworks/ipv46").default;
+const { IP } = require("@hownetworks/ipv46");
 ```
 
-## parseIP(string)
+## IP.parse(string)
 
 Returns the given string parsed into an IPv4 or IPv6 address object.
 If the string is not a valid address then the result is null.
 
 ```js
-parseIP("192.0.2.1");             // IPv4 { ... }
-parseIP("2001:db8::1");           // IPv6 { ... }
-parseIP("non-address");           // null
+IP.parse("192.0.2.1");             // IPv4 { ... }
+IP.parse("2001:db8::1");           // IPv6 { ... }
+IP.parse("non-address");           // null
 ```
 
-**parseIP** supports IPv6 addresses with embedded IPv4 addresses.
+**IP.parse** supports IPv6 addresses with embedded IPv4 addresses.
 
 ```js
-parseIP("2001:db8::192.0.2.1");   // IPv6 { ... }
+IP.parse("2001:db8::192.0.2.1");   // IPv6 { ... }
 ```
 
-## ip.version
+## IP#version
 
 Valid IPv4/6 address objects have their version as an attribute.
 
 ```js
-parseIP("192.0.2.1").version;     // 4
-parseIP("2001:db8::1").version;   // 6
+IP.parse("192.0.2.1").version;     // 4
+IP.parse("2001:db8::1").version;   // 6
 ```
 
-## ip.toString()
+## IP#toString()
 
 Address objects implement the **toString** method for turning the addresses back into strings. The strings are printed lower-cased sans any extra leading zeroes. IPv6 formatting follows the [RFC 5952](https://tools.ietf.org/html/rfc5952) recommendations, except that formatting doesn't output IPv6 addresses with embedded IPv4 addresses.
 
 ```js
-parseIP("192.0.2.1").toString();            // '192.0.2.1'
-parseIP("2001:db8::1").toString();          // '2001:db8::1'
-parseIP("2001:db8::192.0.2.1").toString();  // '2001:db8::c000:201'
+IP.parse("192.0.2.1").toString();            // '192.0.2.1'
+IP.parse("2001:db8::1").toString();          // '2001:db8::1'
+IP.parse("2001:db8::192.0.2.1").toString();  // '2001:db8::c000:201'
 ```
 
-## ip.cmp(other)
+## IP.cmp(other)
 
-Compare and sort addresses. **a.cmp(b)** returns:
+Compare and sort addresses. **IP.cmp(a, b)** returns:
   * **-1** if **a** is sorted before **b**
   * **0** if **a** equals **b**
   * **1** otherwise
-  
+
 ```js
-const a = parseIP("192.0.2.1");
-const b = parseIP("203.0.113.0");
+const a = IP.parse("192.0.2.1");
+const b = IP.parse("203.0.113.0");
 
-a.cmp(a);         // 0
-a.cmp(b);         // -1
-b.cmp(a);         // 1
+IP.cmp(a, a);         // 0
+IP.cmp(a, b);         // -1
+IP.cmp(b, a);         // 1
 ```
 
 IPv4 addresses are always sorted before IPv6 addresses.
 
 ```js
-const ipv4 = parseIP("192.0.2.1");
-const ipv6 = parseIP("2001:db8::1");
+const ipv4 = IP.parse("192.0.2.1");
+const ipv6 = IP.parse("2001:db8::1");
 
-ipv4.cmp(ipv6);   // -1
+IP.cmp(ipv4, ipv6);   // -1
 ```
 
 Parsed addresses get normalized. For example extra leading zeroes don't
 matter in comparisons.
 
 ```js
-const a = parseIP("2001:0db8::1");
-const b = parseIP("2001:0db8:0000::0001")
+const a = IP.parse("2001:0db8::1");
+const b = IP.parse("2001:0db8:0000::0001")
+
+IP.cmp(a, b);         // 0
+```
+
+**IP.cmp** is directly compatible with **Array#sort**.
+
+```js
+const a = IP.parse("2001:0db8::2");
+const b = IP.parse("2001:0db8::1")
+const c = IP.parse("2001:0db8::")
 
-a.cmp(b);         // 0
+[a, b, c].sort(IP.cmp);  // [c, b, a]
 ```