Fixed readme

infusion · infusion · commit c4e0ed6c9f63 · 2024-10-04T19:34:00.000+02:00
diff --git a/README.md b/README.md
@@ -8,15 +8,15 @@ BitSet.js is an infinite [Bit-Array](http://en.wikipedia.org/wiki/Bit_array) (ak
 
 ## Examples
 
-###Basic usage
+### Basic usage
 
 ```javascript
 let bs = new BitSet;
 bs.set(128, 1); // Set bit at position 128
 console.log(bs.toString(16)); // Print out a hex dump with one bit set
 ```
 
-###Flipping bits
+### Flipping bits
 
 ```javascript
 let bs = new BitSet;
@@ -31,14 +31,14 @@ if (str === "111111111111111111111111111000000011111111111111111111111111111") {
 }
 ```
 
-###Range Set
+### Range Set
 
 ```javascript
 let bs = new BitSet;
 bs.setRange(10, 18, 1); // Set a 1 between 10 and 18, inclusive
 ```
 
-###User permissions
+### User permissions
 
 If you want to store user permissions in your database and use BitSet for the bit twiddling, you can start with the following Linux-style snippet:
 ```javascript
@@ -56,7 +56,7 @@ let world = new BitSet(P_EXEC);
 console.log("0" + user.toString(8) + group.toString(8) + world.toString(8));
 ```
 
-##Installation
+## Installation
 
 
 ```
@@ -67,7 +67,7 @@ or
 bower install bitset.js
 ```
 
-##Using BitSet.js with the browser
+## Using BitSet.js with the browser
 
 ```html
 <script src="bitset.js"></script>
@@ -76,7 +76,7 @@ bower install bitset.js
 </script>
 ```
 
-##Using BitSet.js with require.js
+## Using BitSet.js with require.js
 
 ```html
 <script src="require.js"></script>
@@ -88,7 +88,7 @@ function(BitSet) {
 </script>
 ```
 
-##Constructor
+## Constructor
 
 The default `BitSet` constructor accepts a single value of one the following types :
 
@@ -106,117 +106,117 @@ The default `BitSet` constructor accepts a single value of one the following typ
   - A BitSet object, which get copied over
 
 
-##Functions
+## Functions
 
 
 The data type Mixed can be either a BitSet object, a String or an integer representing a native bitset with 31 bits.
 
 
-###BitSet set(ndx[, value=1])
+### BitSet set(ndx[, value=1])
 
 Mutable; Sets value 0 or 1 to index `ndx` of the bitset
 
 int get(ndx)
 ---
 Gets the value at index ndx
 
-###BitSet setRange(from, to[, value=1])
+### BitSet setRange(from, to[, value=1])
 
 Mutable; Helper function for set, to set an entire range to a given value
 
-###BitSet clear([from[, to]])
+### BitSet clear([from[, to]])
 
 Mutable; Sets a portion of a given bitset to zero
 
 - If no param is given, the whole bitset gets cleared
 - If one param is given, the bit at this index gets cleared
 - If two params are given, the range is cleared
 
-###BitSet slice([from[, to]])
+### BitSet slice([from[, to]])
 
 Immutable; Extracts a portion of a given bitset as a new bitset
 
 - If no param is given, the bitset is getting cloned
 - If one param is given, the index is used as offset
 - If two params are given, the range is returned as new BitSet
 
-###BitSet flip([from[, to]])
+### BitSet flip([from[, to]])
 
 Mutable; Toggles a portion of a given bitset
 
 - If no param is given, the bitset is inverted
 - If one param is given, the bit at the index is toggled
 - If two params are given, the bits in the given range are toggled
 
-###BitSet not()
+### BitSet not()
 
 Immutable; Calculates the bitwise complement
 
-###BitSet and(Mixed x)
+### BitSet and(Mixed x)
 
 Immutable; Calculates the bitwise intersection of two bitsets
 
-###BitSet or(Mixed x)
+### BitSet or(Mixed x)
 
 Immutable; Calculates the bitwise union of two bitsets
 
-###BitSet xor(Mixed x)
+### BitSet xor(Mixed x)
 
 Immutable; Calculates the bitwise xor between two bitsets
 
-###BitSet andNot(Mixed x)
+### BitSet andNot(Mixed x)
 
 Immutable; Calculates the bitwise difference of two bitsets (this is not the nand operation!)
 
-###BitSet clone()
+### BitSet clone()
 
 Immutable; Clones the actual object
 
-###Array toArray()
+### Array toArray()
 
 Returns an array with all indexes set in the bitset
 
-###String toString([base=2])
+### String toString([base=2])
 
 Returns a string representation with respect to the base
 
-###int cardinality()
+### int cardinality()
 
 Calculates the number of bits set
 
-###int msb()
+### int msb()
 
 Calculates the most significant bit (the left most)
 
-###int ntz()
+### int ntz()
 
 Calculates the number of trailing zeros (zeros on the right). If all digits are zero, `Infinity` is returned, since BitSet.js is an arbitrary large bit vector implementation.
 
-###int lsb()
+### int lsb()
 
 Calculates the least significant bit (the right most)
 
-###bool isEmpty()
+### bool isEmpty()
 
 Checks if the bitset has all bits set to zero
 
-###bool equals()
+### bool equals()
 
 Checks if two bitsets are the same
 
-###BitSet.fromBinaryString(str)
+### BitSet.fromBinaryString(str)
 
 Alternative constructor to pass with a binary string
 
-###BitSet.fromHexString(str)
+### BitSet.fromHexString(str)
 
 Alternative constructor to pass a hex string
 
-###BitSet.Random([n=32])
+### BitSet.Random([n=32])
 
 Create a random BitSet with a maximum length of n bits
 
-##Iterator Interface
+## Iterator Interface
 
 A `BitSet` object is iterable. The iterator gets all bits up to the most significant bit. If no bits are set, the iteration stops immediately.
 
@@ -230,11 +230,11 @@ for (let b of bs) {
 Note: If the bitset is inverted so that all leading bits are 1, the iterator must be stopped by the user!
 
 
-##Coding Style
+## Coding Style
 
 As every library I publish, BitSet.js is also built to be as small as possible after compressing it with Google Closure Compiler in advanced mode. Thus the coding style orientates a little on maxing-out the compression rate. Please make sure you keep this style if you plan to extend the library.
 
-##Building the library
+## Building the library
 
 After cloning the Git repository run:
 
@@ -243,7 +243,7 @@ npm install
 npm run build
 ```
 
-##Run a test
+## Run a test
 
 Testing the source against the shipped test suite is as easy as
 
