docs(examples): improve diff formatting and readability 🎨

- Clean up spacing in diff blocks across example files
- Remove unnecessary blank lines for better readability
- Improve consistency in code example formatting
- Streamline diff presentation for clearer understanding

Author: NeaByteLab

examples/prefer-array-every.md

@@ -7,81 +7,71 @@ This rule enforces the use of `Array.every()` over manual for loops that return
 ### Basic Array Validation
 
 ```diff
-- function validateUsers(users) {
+  function validateUsers(users) {
 -   for (let i = 0; i < users.length; i++) {
 -     if (!users[i].isActive) {
 -       return false
 -     }
 -   }
 -   return true
-- }
-+ function validateUsers(users) {
 +   return users.every(user => user.isActive)
-+ }
+  }
 ```
 
 ### Number Array Validation
 
 ```diff
-- function checkNumbers(numbers) {
+  function checkNumbers(numbers) {
 -   for (let i = 0; i < numbers.length; i++) {
 -     if (numbers[i] <= 0) {
 -       return false
 -     }
 -   }
 -   return true
-- }
-+ function checkNumbers(numbers) {
 +   return numbers.every(number => number > 0)
-+ }
+  }
 ```
 
 ### Method Call Validation
 
 ```diff
-- function processItems(items) {
+  function processItems(items) {
 -   for (let i = 0; i < items.length; i++) {
 -     if (!items[i].isValid()) {
 -       return false
 -     }
 -   }
 -   return true
-- }
-+ function processItems(items) {
 +   return items.every(item => item.isValid())
-+ }
+  }
 ```
 
 ### Complex Condition Validation
 
 ```diff
-- function validateComplex(items) {
+function validateComplex(items) {
 -   for (let i = 0; i < items.length; i++) {
 -     if (!items[i].active || items[i].value <= threshold) {
 -       return false
 -     }
 -   }
 -   return true
-- }
-+ function validateComplex(items) {
 +   return items.every(item => item.active && item.value > threshold)
-+ }
+  }
 ```
 
 ### Property Access Validation
 
 ```diff
-- function checkUsers(users) {
+  function checkUsers(users) {
 -   for (let i = 0; i < users.length; i++) {
 -     if (!users[i].profile.isActive) {
 -       return false
 -     }
 -   }
 -   return true
-- }
-+ function checkUsers(users) {
 +   return users.every(user => user.profile.isActive)
-+ }
+  }
 ```
 
 ## Rule Scope

examples/prefer-array-flat.md

@@ -11,6 +11,8 @@ This rule enforces the use of `Array.flat()` over manual flattening patterns lik
 + const flattened = nestedArray.flat()
 ```
 
+### Array.prototype.concat.apply Pattern
+
 ```diff
 - const flattened = Array.prototype.concat.apply([], nestedArray)
 + const flattened = nestedArray.flat()
@@ -19,14 +21,14 @@ This rule enforces the use of `Array.flat()` over manual flattening patterns lik
 ### Function Returns
 
 ```diff
-- function flattenArray(arr) {
+  function flattenArray(arr) {
 -   return Array.prototype.concat.apply([], arr)
-- }
-+ function flattenArray(arr) {
 +   return arr.flat()
-+ }
+  }
 ```
 
+### Arrow Function Returns
+
 ```diff
 - const flattenData = (data) => Array.prototype.concat.apply([], data)
 + const flattenData = (data) => data.flat()
@@ -35,16 +37,12 @@ This rule enforces the use of `Array.flat()` over manual flattening patterns lik
 ### Class Methods
 
 ```diff
-- class ArrayUtils {
--   flatten(arr) {
+  class ArrayUtils {
+    flatten(arr) {
 -     return Array.prototype.concat.apply([], arr)
--   }
-- }
-+ class ArrayUtils {
-+   flatten(arr) {
 +     return arr.flat()
-+   }
-+ }
+    }
+  }
 ```
 
 ### Complex Expressions
@@ -54,6 +52,8 @@ This rule enforces the use of `Array.flat()` over manual flattening patterns lik
 + const flattened = getNestedArrays().flat()
 ```
 
+### Spread Operator Pattern
+
 ```diff
 - const result = [].concat(...getData())
 + const result = getData().flat()
@@ -66,6 +66,8 @@ This rule enforces the use of `Array.flat()` over manual flattening patterns lik
 + const flattened = (condition ? arr1 : arr2).flat()
 ```
 
+### Simple Array Processing
+
 ```diff
 - const processed = [].concat(...items)
 + const processed = items.flat()

examples/prefer-array-includes.md

@@ -8,13 +8,13 @@ This rule enforces the use of `Array.includes()` over manual `indexOf() !== -1`
 
 ```diff
 - if (arr.indexOf(item) !== -1) {
--   console.log('Item found')
-- }
 + if (arr.includes(item)) {
-+   console.log('Item found')
-+ }
+    console.log('Item found')
+  }
 ```
 
+### Variable Assignment
+
 ```diff
 - const found = arr.indexOf(item) !== -1
 + const found = arr.includes(item)
@@ -23,14 +23,14 @@ This rule enforces the use of `Array.includes()` over manual `indexOf() !== -1`
 ### Function Returns
 
 ```diff
-- function hasItem(arr, item) {
+  function hasItem(arr, item) {
 -   return arr.indexOf(item) !== -1
-- }
-+ function hasItem(arr, item) {
 +   return arr.includes(item)
-+ }
+  }
 ```
 
+### Arrow Function Returns
+
 ```diff
 - const checkExists = (items, target) => items.indexOf(target) !== -1
 + const checkExists = (items, target) => items.includes(target)
@@ -40,13 +40,13 @@ This rule enforces the use of `Array.includes()` over manual `indexOf() !== -1`
 
 ```diff
 - if (getArray().indexOf(getItem()) !== -1) {
--   console.log('Found')
-- }
 + if (getArray().includes(getItem())) {
-+   console.log('Found')
-+ }
+    console.log('Found')
+  }
 ```
 
+### Simple Variable Assignment
+
 ```diff
 - const exists = items.indexOf(item) !== -1
 + const exists = items.includes(item)
@@ -56,11 +56,9 @@ This rule enforces the use of `Array.includes()` over manual `indexOf() !== -1`
 
 ```diff
 - if (obj.items.indexOf(item) !== -1) {
--   console.log('Item in collection')
-- }
 + if (obj.items.includes(item)) {
-+   console.log('Item in collection')
-+ }
+    console.log('Item in collection')
+  }
 ```
 
 ```diff

examples/prefer-array-some.md

@@ -7,81 +7,71 @@ This rule enforces the use of `Array.some()` over manual for loops that return `
 ### Basic Array Search
 
 ```diff
-- function hasActiveUsers(users) {
+  function hasActiveUsers(users) {
 -   for (let i = 0; i < users.length; i++) {
 -     if (users[i].isActive) {
 -       return true
 -     }
 -   }
 -   return false
-- }
-+ function hasActiveUsers(users) {
 +   return users.some(user => user.isActive)
-+ }
+  }
 ```
 
 ### Number Array Search
 
 ```diff
-- function hasPositiveNumbers(numbers) {
+  function hasPositiveNumbers(numbers) {
 -   for (let i = 0; i < numbers.length; i++) {
 -     if (numbers[i] > 0) {
 -       return true
 -     }
 -   }
 -   return false
-- }
-+ function hasPositiveNumbers(numbers) {
 +   return numbers.some(number => number > 0)
-+ }
+  }
 ```
 
 ### Method Call Search
 
 ```diff
-- function hasValidItems(items) {
+  function hasValidItems(items) {
 -   for (let i = 0; i < items.length; i++) {
 -     if (items[i].isValid()) {
 -       return true
 -     }
 -   }
 -   return false
-- }
-+ function hasValidItems(items) {
 +   return items.some(item => item.isValid())
-+ }
+  }
 ```
 
 ### Complex Condition Search
 
 ```diff
-- function hasComplexMatch(items) {
+  function hasComplexMatch(items) {
 -   for (let i = 0; i < items.length; i++) {
 -     if (items[i].active && items[i].value > threshold) {
 -       return true
 -     }
 -   }
 -   return false
-- }
-+ function hasComplexMatch(items) {
 +   return items.some(item => item.active && item.value > threshold)
-+ }
+  }
 ```
 
 ### Property Access Search
 
 ```diff
-- function hasActiveUsers(users) {
+  function hasActiveUsers(users) {
 -   for (let i = 0; i < users.length; i++) {
 -     if (users[i].profile.isActive) {
 -       return true
 -     }
 -   }
 -   return false
-- }
-+ function hasActiveUsers(users) {
 +   return users.some(user => user.profile.isActive)
-+ }
+  }
 ```
 
 ## Rule Scope

examples/prefer-arrow-callback.md

@@ -35,13 +35,10 @@ This rule enforces the use of arrow functions over regular function expressions
 
 ```diff
 - const results = numbers.map(function (num) {
--   const doubled = num * 2
--   return doubled
-- })
 + const results = numbers.map(num => {
-+   const doubled = num * 2
-+   return doubled
-+ })
+    const doubled = num * 2
+    return doubled
+  })
 ```
 
 ### Destructuring Callback

examples/prefer-const-assertions.md

@@ -21,23 +21,19 @@ This rule enforces the use of const assertions (`as const`) on array and object
 ### Return Statement Array
 
 ```diff
-- function getColors() {
+  function getColors() {
 -   return ['red', 'green', 'blue']
-- }
-+ function getColors() {
 +   return ['red', 'green', 'blue'] as const
-+ }
+  }
 ```
 
 ### Return Statement Object
 
 ```diff
-- function getConfig() {
+  function getConfig() {
 -   return { apiUrl: 'https://api.example.com', timeout: 5000 }
-- }
-+ function getConfig() {
 +   return { apiUrl: 'https://api.example.com', timeout: 5000 } as const
-+ }
+  }
 ```
 
 ### Arrow Function Return