diff --git a/Documentation/API.md b/Documentation/API.md
index b66d9ce..374ceb7 100644
--- a/Documentation/API.md
+++ b/Documentation/API.md
@@ -1,5 +1,8 @@
 # `API` — networking for LCEssentials
 
+Part of the reference set: [Extensions.md](Extensions.md) ·
+[SwiftUI.md](SwiftUI.md) · [UIKit.md](UIKit.md).
+
 `API` is an `actor` that wraps `URLSession` for JSON REST calls and multipart
 uploads. One line to send a typed request, decode the response, and get a
 consistent error — instead of re-writing the same `URLRequest` / status-code /
diff --git a/Documentation/Extensions.md b/Documentation/Extensions.md
new file mode 100644
index 0000000..4a02881
--- /dev/null
+++ b/Documentation/Extensions.md
@@ -0,0 +1,2018 @@
+# LCEssentials — Extensions
+
+Foundation, value-type, string, collection, numeric, date, and crypto helpers, plus
+the `LCEssentials` namespace itself. UIKit extensions live in
+[UIKit.md](UIKit.md); SwiftUI helpers in [SwiftUI.md](SwiftUI.md).
+
+Every section is a collapsible block — click a heading to expand it.
+
+## Contents
+
+- [API & Networking](#api--networking)
+- [Strings & Text](#strings--text)
+- [Collections & Sequences](#collections--sequences)
+- [Numbers & Geometry](#numbers--geometry)
+- [Date, Data & Files](#date-data--files)
+- [Encoding & Errors](#encoding--errors)
+- [Crypto](#crypto)
+- [Core — the `LCEssentials` namespace](#core--the-lcessentials-namespace)
+
+---
+
+## API & Networking
+
+`API` is an `actor` wrapping `URLSession` for typed JSON requests and multipart
+uploads. This is a summary — the **[full guide is in API.md](API.md)** (all
+parameters, error model, client certificates, custom body types, and the
+rationale vs. a hand-rolled `URLSession`).
+
+<details>
+<summary><b>API</b> — typed async requests &amp; uploads</summary>
+
+### `API.shared`
+
+The shared `actor` instance. Every call is `await`; nothing runs on the main
+thread unless you hop there yourself.
+
+```swift
+struct User: Decodable, Sendable { let id: Int; let name: String }
+
+let user: User = try await API.shared.request(
+    url: "https://api.example.com/users/{id}",
+    method: .get,
+    pathParams: ["id": "42"]
+)
+```
+
+### `request(url:method:body:pathParams:headers:debug:timeoutInterval:networkServiceType:persistConnection:)`
+
+Sends a request and decodes the JSON response into `T: Decodable & Sendable`.
+Non-2xx responses throw an `NSError` whose `code` is the HTTP status and whose
+`localizedFailureReason` is the response body. When `T == String` the raw body
+is returned without JSON decoding.
+
+```swift
+struct CreateUser: Encodable, Sendable { let name: String }
+
+// JSON body
+let created: User = try await API.shared.request(
+    url: "https://api.example.com/users",
+    method: .post,
+    body: jsonBody(CreateUser(name: "Ana"))
+)
+
+// form-url-encoded body
+let token: Token = try await API.shared.request(
+    url: "https://api.example.com/oauth/token",
+    method: .post,
+    body: .form(["grant_type": "password", "username": "ana"])
+)
+```
+
+### `upload(url:method:form:pathParams:headers:debug:timeoutInterval:networkServiceType:)` and its `onProgress:` overload
+
+Uploads a `multipart/form-data` body serialised to a temp file (removed
+afterwards) and streamed from disk, so large files never fully load into memory.
+
+```swift
+var form = MultipartForm()
+form.field("caption", "Sunset")
+form.file("photo", data: jpegData, filename: "p.jpg")
+form.file("video", url: localVideoURL)          // streamed from disk
+
+let result: UploadResult = try await API.shared.upload(
+    url: "https://api.example.com/media",
+    form: form,
+    onProgress: { fraction in
+        Task { @MainActor in progressView.progress = Float(fraction) }
+    }
+)
+```
+
+### Body types — `HTTPBody`
+
+`jsonBody(_:)` wraps any `Encodable & Sendable`; `FormURLEncodedBody` (a.k.a.
+`.form([:])`) percent-escapes every value and never drops one; `RawBody` lets you
+supply the bytes and `Content-Type` yourself. Conform your own type to `HTTPBody`
+and `API` accepts it with no change.
+
+```swift
+struct CSVBody: HTTPBody {
+    let rows: [[String]]
+    func encoded() throws -> (data: Data, contentType: String) {
+        let text = rows.map { $0.joined(separator: ",") }.joined(separator: "\n")
+        return (Data(text.utf8), "text/csv; charset=UTF-8")
+    }
+}
+```
+
+### `await API.shared.setupCertification(certData:password:)`
+
+Registers a client certificate (`.p12`) for mutual-TLS on subsequent requests.
+
+```swift
+let p12 = try Data(contentsOf: certURL)
+await API.shared.setupCertification(certData: p12, password: "cert-pw")
+```
+
+</details>
+
+## Strings & Text
+
+<details>
+<summary><b>String</b> — validation, parsing, formatting, masks, HTML, dates</summary>
+
+### URLs
+
+#### `var isValidUrl: Bool` / `var isValidHttpsUrl: Bool` / `var isValidHttpUrl: Bool`
+`isValidUrl` is true when `URL(string:)` succeeds; the other two additionally
+require the `https` / `http` scheme.
+
+```swift
+"https://google.com".isValidUrl        // true
+"https://google.com".isValidHttpsUrl   // true
+"http://google.com".isValidHttpsUrl    // false
+```
+
+#### `var urlEncoded: String` / `var urlDecoded: String`
+Percent-encode (host-allowed set) / decode. `urlDecoded` returns the original
+string when it is not encoded.
+
+```swift
+"it's easy".urlEncoded       // "it's%20easy"
+"it's%20easy".urlDecoded     // "it's easy"
+```
+
+#### `mutating func urlEncode() -> String` / `mutating func urlDecode() -> String`
+In-place variants; also return the new value (`@discardableResult`).
+
+```swift
+var s = "a b"; s.urlEncode()   // s == "a%20b"
+```
+
+#### `func stringByAddingPercentEncodingForRFC3986() -> String`
+Percent-encodes for use as a query key/value, escaping `;/?:@&=+$,` and space.
+
+```swift
+"a&b=c".stringByAddingPercentEncodingForRFC3986()   // "a%26b%3Dc"
+```
+
+#### `var url: String?`
+First URL detected **inside** the string (via `NSDataDetector`), or `nil`.
+
+```swift
+"visit www.site.com.br now".url   // "www.site.com.br"
+```
+
+#### `var toURL: NSURL?`
+`NSURL(string:)` wrapper.
+
+```swift
+"https://x.com".toURL   // NSURL
+```
+
+### Validation
+
+#### `var isEmail: Bool`
+Regex check for a syntactically valid email (TLD 2–20 chars).
+
+```swift
+"user@example.com".isEmail   // true
+"nope".isEmail               // false
+```
+
+#### `var isCPF: Bool`
+Validates a Brazilian CPF including both check digits. Strips formatting first
+(`onlyNumbers`), requires 11 digits.
+
+```swift
+"123.456.789-09".isCPF   // true when the check digits match
+```
+
+#### `var isValidCNPJ: Bool`
+Validates a Brazilian CNPJ (14 digits, both check digits, rejects all-same-digit).
+
+```swift
+"11.222.333/0001-81".isValidCNPJ   // true when valid
+```
+
+#### `var isAlphabetic: Bool`
+Letters only, no digits.
+
+```swift
+"abc".isAlphabetic     // true
+"123abc".isAlphabetic  // false
+```
+
+#### `var isAlphaNumeric: Bool`
+Contains at least one letter **and** one digit and nothing else — handy for
+password rules.
+
+```swift
+"123abc".isAlphaNumeric   // true
+"abc".isAlphaNumeric      // false
+```
+
+#### `var isHTML: Bool`
+True if the string contains an HTML tag.
+
+```swift
+"<b>hi</b>".isHTML   // true
+```
+
+#### `func validateBolean(comparingBoolean: Bool = true) -> Bool`
+Loose truthy/falsy check against a large set of EN/PT words. With
+`comparingBoolean: true` returns whether the string means "true"
+(`YES`, `ON`, `SIM`, `ATIVO`, `1`, `T`, …); with `false`, whether it means "false".
+
+```swift
+"SIM".validateBolean()                        // true
+"nao".validateBolean(comparingBoolean: false) // true
+```
+
+### Conversion
+
+#### `var bool: Bool?`
+`"true"/"yes"/"1"` → `true`, `"false"/"no"/"0"` → `false`, else `nil` (trimmed, case-insensitive).
+
+```swift
+" YES ".bool   // true
+"maybe".bool   // nil
+```
+
+#### `var int: Int?` / `var float: Float?` / `var double: Double?`
+Plain `Int(self)` / `Float(self)` / `Double(self)`.
+
+```swift
+"101".int    // 101
+"1.5".double // 1.5
+"x".int      // nil
+```
+
+#### `func float(locale: Locale = .current) -> Float?` / `func double(locale:) -> Double?`
+Locale-aware parsing via `NumberFormatter` (accepts grouping separators).
+
+```swift
+"1,5".double(locale: Locale(identifier: "pt_BR"))   // 1.5
+```
+
+#### `var currencyStringToDouble: Double`
+Parses a `pt_BR` currency string to `Double`, `0.0` on failure.
+
+```swift
+"R$ 1.234,56".currencyStringToDouble   // 1234.56
+```
+
+#### `var btcToSats: Int` / `var bitcoinToSatoshis: Int`
+Multiplies a BTC amount string by 100,000,000. `bitcoinToSatoshis` is an alias.
+
+```swift
+"0.0001".btcToSats   // 10000
+```
+
+#### `var data: Data`
+UTF-8 bytes.
+
+```swift
+"hi".data   // 2 bytes
+```
+
+#### `var nsString: NSString` / `var fullNSRange: NSRange`
+Bridge to `NSString`; `NSRange` spanning the whole string (UTF-16 aware).
+
+```swift
+"café".fullNSRange   // {0, 4}
+```
+
+#### `func nsRange(from range: Range<String.Index>) -> NSRange?`
+Convert a Swift `Range` to an `NSRange` in the UTF-16 view.
+
+#### `var base64Encode: String?` / `var base64Decode: String?`
+Base64 encode the UTF-8 bytes / decode a Base64 string back to text.
+
+```swift
+"hi".base64Encode        // "aGk="
+"aGk=".base64Decode      // "hi"
+```
+
+#### `func date(withCurrFormatt:localeIdentifier:timeZone:) -> Date?`
+Parse the string to `Date` using the given input format (default
+`"yyyy-MM-dd HH:mm:ss"`, locale `pt-BR`, current time zone). A `" 0000"` suffix
+is normalised to `" +0000"`.
+
+```swift
+"2026-08-29 14:30:00".date()   // Date
+```
+
+#### `func date(withCurrFormatt:newFormatt:localeIdentifier:timeZone:) -> Date?`
+Parse with one format and round-trip through another (normalises the value).
+
+#### `var currentTimeZone: String`
+Current time-zone offset string, e.g. `"-0300"`.
+
+### Cleaning & filtering
+
+#### `var withoutSpacesAndNewLines: String`
+Removes every space and `\n`.
+
+```swift
+"  a \n b ".withoutSpacesAndNewLines   // "ab"
+```
+
+#### `var onlyNumbers: String` / `var numbers: String`
+Digits only. `onlyNumbers` uses a `\D` regex; `numbers` uses `decimalDigits`.
+
+```swift
+"(11) 98765-4321".onlyNumbers   // "11987654321"
+```
+
+#### `var letters: String` / `var lettersWithWhiteSpace: String`
+Keep only letters (optionally keeping spaces).
+
+```swift
+"a1 b2".letters                // "ab"
+"a1 b2".lettersWithWhiteSpace  // "a b"
+```
+
+#### `var alphanumeric: String` / `var alphanumericWithWhiteSpace: String`
+Keep only alphanumerics (optionally keeping spaces).
+
+```swift
+"a-b_c 1".alphanumeric   // "abc1"
+```
+
+#### `var removeSpecialChars: String`
+Keeps `[A-Za-z0-9 -]` only.
+
+```swift
+"a@b#c".removeSpecialChars   // "abc"
+```
+
+#### `var removeHTMLTags: String` / `var removeEmoji: String`
+Strip HTML tags / strip emoji (`CharacterSet.symbols`).
+
+```swift
+"<p>hi</p>".removeHTMLTags   // "hi"
+"hi 😀".removeEmoji           // "hi "
+```
+
+### Slicing & padding
+
+#### `var first: String` / `var last: String`
+First / last character **as a String** (`""` when empty).
+
+#### `var uppercaseFirst: String`
+Capitalises the first character only.
+
+```swift
+"hello".uppercaseFirst   // "Hello"
+```
+
+#### `var firstCharacterAsString: String?` / `var lastCharacterAsString: String?`
+Optional variants — `nil` when empty.
+
+#### `func paddingStart(_ length: Int, with: String = " ") -> String` / `func paddingEnd(...)`
+Pad to `length` with a repeating pad string at the start / end. No-op if already long enough.
+
+```swift
+"hue".paddingStart(10)             // "       hue"
+"hue".paddingEnd(10, with: "br")   // "huebrbrbrb"
+```
+
+#### `func truncated(toLength: Int, trailing: String? = "...") -> String`
+Non-mutating truncation.
+
+```swift
+"This is long".truncated(toLength: 7)   // "This is..."
+```
+
+#### `mutating func truncate(toLength: Int, trailing: String? = "...") -> String`
+In-place truncation (`@discardableResult`).
+
+#### `mutating func trim() -> String`
+Trim leading/trailing whitespace and newlines, in place (`@discardableResult`).
+
+```swift
+var s = "  hi \n"; s.trim()   // s == "hi"
+```
+
+#### `mutating func reverse() -> String`
+Reverse in place (`@discardableResult`).
+
+#### `mutating func insertAtIndexEnd(string:ind:)` / `insertAtIndexStart(string:ind:)`
+Insert `string` at an offset measured from `endIndex` (negative `ind` moves left).
+
+```swift
+var s = "abcd"; s.insertAtIndexEnd(string: "-", ind: -1)   // "abc-d"
+```
+
+### Replacing
+
+#### `func replace(from:to:)` / `func findAndReplace(from:to:)`
+Simple substring replacement (`findAndReplace` is generic over `StringProtocol`).
+
+```swift
+"a.b.c".replace(from: ".", to: "-")   // "a-b-c"
+```
+
+#### `func replacing(range: CountableClosedRange<Int>, with: String) -> String`
+Replace by integer character range.
+
+```swift
+"abcdef".replacing(range: 1...3, with: "X")   // "aXef"
+```
+
+#### `func replacingLastOccurrenceOfString(_:with:caseInsensitive: Bool = true) -> String`
+Replace only the last match.
+
+```swift
+"a-b-c".replacingLastOccurrenceOfString("-", with: "+")   // "a-b+c"
+```
+
+#### `func replaceAll(of pattern: String, with: String, options: = []) -> String`
+Regex replace-all; returns the original on a bad pattern.
+
+```swift
+"a1b2c3".replaceAll(of: "[0-9]", with: "#")   // "a#b#c#"
+```
+
+#### `@discardableResult func replaceURL(_ withDict: [String: Any]) -> String`
+Substitute `{key}` placeholders — used by `API.request(pathParams:)`.
+
+```swift
+"/users/{id}/posts/{p}".replaceURL(["id": 7, "p": "x"])   // "/users/7/posts/x"
+```
+
+### Words & search
+
+#### `func words() -> [String]` / `func wordCount() -> Int`
+Split on whitespace + punctuation, dropping empties.
+
+```swift
+"Swift is amazing".words()      // ["Swift", "is", "amazing"]
+"Swift is amazing".wordCount()  // 3
+```
+
+#### `func contains(_:caseSensitive: Bool = true) -> Bool`
+Substring check with optional case-insensitivity.
+
+```swift
+"Hello".contains("ell")                       // true
+"Hello".contains("HELLO", caseSensitive: false) // true
+```
+
+### Formatting helpers
+
+#### `func applyMask(toText: String, mask: String) -> String`
+Apply a `#`-placeholder mask; literal characters in the mask are inserted.
+
+```swift
+"11987654321".applyMask(toText: "11987654321", mask: "(##) #####-####")
+// "(11) 98765-4321"
+```
+
+#### `func exponentize(str: String) -> String`
+Turn `^`-prefixed digits into Unicode superscripts.
+
+```swift
+"x^2 + y^3".exponentize(str: "x^2 + y^3")   // "x² + y³"
+```
+
+#### `func stringFromTimeInterval(_ interval: TimeInterval) -> NSString`
+Format a `TimeInterval` as `HH:MM:SS.mmm`.
+
+```swift
+"".stringFromTimeInterval(3661.5)   // "01:01:01.500"
+```
+
+#### `func toSlug() -> String`
+Lowercase, de-accent, spaces → `-`, strip other punctuation.
+
+```swift
+"Olá Mundo!".toSlug()   // "ola-mundo"
+```
+
+#### `func localized(comment: String = "") -> String`
+`NSLocalizedString(self, comment:)`.
+
+```swift
+"welcome_title".localized()
+```
+
+### Generators & misc
+
+#### `static func loremIpsum(ofLength length: Int = 445) -> String`
+Lorem-ipsum text truncated to `length` (max 445).
+
+```swift
+String.loremIpsum(ofLength: 20)   // "Lorem ipsum dolor si"
+```
+
+#### `func randomString(length: Int) -> String`
+Random `[A-Za-z0-9]` string. (Instance method — the receiver is ignored.)
+
+```swift
+"".randomString(length: 8)   // e.g. "a9Fk2Lp0"
+```
+
+#### `var JSONStringToDictionary: [String: Any]?`
+Parse a JSON object string to a dictionary (`nil` + logs on failure).
+
+```swift
+#"{"a":1}"#.JSONStringToDictionary   // ["a": 1]
+```
+
+#### `var convertToHTML: NSAttributedString?`
+Render an HTML string to `NSAttributedString` (UIKit path uses the CSS converter below).
+
+#### `func convertHtmlToAttributedStringWithCSS(font:csscolor:lineheight:csstextalign:customCSS:) -> NSAttributedString?` — *UIKit only*
+HTML → `NSAttributedString` with an injected `<style>` block. Returns the plain
+HTML rendering when `font` is `nil`.
+
+```swift
+"<b>Hi</b>".convertHtmlToAttributedStringWithCSS(
+    font: .systemFont(ofSize: 16), csscolor: "#333",
+    lineheight: 0, csstextalign: "left"
+)
+```
+
+#### `func height(withConstrainedWidth:font:) -> CGFloat` / `func width(withConstraintedHeight:font:) -> CGFloat` — *UIKit only*
+Measured bounding height/width for the string at a fixed width/height and font.
+
+```swift
+"Some label text".height(withConstrainedWidth: 200, font: .systemFont(ofSize: 14))
+```
+
+</details>
+
+<details>
+<summary><b>Character</b> — classification, conversion, repetition</summary>
+
+### `var isEmoji: Bool`
+True when the scalar falls in a known emoji range.
+
+```swift
+Character("😀").isEmoji   // true
+Character("a").isEmoji    // false
+```
+
+### `var int: Int?` / `var string: String`
+Digit value (or `nil`) / one-character `String`.
+
+```swift
+Character("7").int   // 7
+Character("A").int   // nil
+```
+
+### `var lowercased: Character` / `var uppercased: Character`
+Case-flipped character.
+
+```swift
+Character("a").uppercased   // "A"
+```
+
+### `func unicodeScalarCodePoint() -> UInt32`
+First Unicode scalar value.
+
+```swift
+Character("A").unicodeScalarCodePoint()   // 65
+```
+
+### `static func randomAlphanumeric() -> Character`
+Random `[A-Za-z0-9]` character.
+
+```swift
+Character.randomAlphanumeric()   // e.g. "k"
+```
+
+### `static func * (Character, Int) -> String` / `static func * (Int, Character) -> String`
+Repeat a character into a string.
+
+```swift
+Character("-") * 5   // "-----"
+5 * Character("-")   // "-----"
+```
+
+</details>
+
+<details>
+<summary><b>NSString</b></summary>
+
+### `var string: String?`
+`String(describing:)` of the `NSString`.
+
+### `func randomAlphaNumericString(_ length: Int = 8) -> String`
+Random `[A-Za-z0-9]` string of the given length.
+
+```swift
+("" as NSString).randomAlphaNumericString(12)
+```
+
+</details>
+
+<details>
+<summary><b>NSAttributedString / NSMutableAttributedString</b></summary>
+
+### `NSAttributedString(html: String)` — *failable init*
+Build an attributed string from an HTML fragment.
+
+```swift
+label.attributedText = NSAttributedString(html: "<b>Hello</b> world")
+```
+
+### `NSMutableAttributedString` builders — *UIKit only*, all `@discardableResult` and chainable
+
+| Method | Effect |
+|---|---|
+| `customize(_:withFont:color:lineSpace:alignment:changeCurrentText:)` | append (or restyle) a run with font/color/spacing/alignment |
+| `underline(_:withFont:color:changeCurrentText:)` | underlined run |
+| `strikethrough(_:changeCurrentText:)` | strikethrough run |
+| `linkTouch(_:url:withFont:color:changeCurrentText:)` | tappable link run |
+| `supperscript(_:withFont:color:offset:changeCurrentText:)` | baseline-offset (superscript) run |
+| `appendImageToText(_:)` | append an inline `UIImage` attachment |
+| `normal(_:)` | append an unstyled run |
+
+`changeCurrentText: true` restyles the first occurrence of the text already in
+the string instead of appending.
+
+```swift
+let s = NSMutableAttributedString()
+    .customize("Total: ", withFont: .systemFont(ofSize: 14))
+    .customize("R$ 10", withFont: .boldSystemFont(ofSize: 14), color: .label)
+    .supperscript("00", withFont: .systemFont(ofSize: 9), offset: 6)
+label.attributedText = s
+```
+
+### `func canSetAsLink(textToFind: String, linkURL: String) -> Bool`
+Adds a `.link` attribute to the first match; returns whether it was found.
+
+### `func attributtedString() -> NSAttributedString`
+Immutable copy of the whole string.
+
+### `func height(withConstrainedWidth:) -> CGFloat` / `func width(withConstrainedHeight:) -> CGFloat`
+Bounding size for the attributed content.
+
+</details>
+
+<details>
+<summary><b>Bytes</b> — <code>Sequence where Element == UInt8</code></summary>
+
+### `var data: Data`
+Wrap the byte sequence in `Data`.
+
+### `var base64Decoded: Data?`
+Interpret the bytes as Base64 text and decode.
+
+### `var string: String?`
+Decode the bytes as UTF-8.
+
+```swift
+let bytes: [UInt8] = [0x68, 0x69]
+bytes.data       // 2 bytes
+bytes.string     // "hi"
+```
+
+</details>
+
+## Collections & Sequences
+
+<details>
+<summary><b>Array</b> — dedup, mutation helpers (<code>Element: Equatable</code>)</summary>
+
+### `var unique: [Element]` / `func withoutDuplicates() -> [Element]`
+New array with duplicates dropped, first occurrence kept (order preserved).
+
+```swift
+[1, 2, 2, 3].unique   // [1, 2, 3]
+```
+
+### `mutating func removeDuplicates() -> [Element]`
+In-place dedup (`@discardableResult`).
+
+### `func withoutDuplicates<E: Equatable>(keyPath:) -> [Element]` / `<E: Hashable>(keyPath:)`
+Dedup by a key path. The `Hashable` overload is O(n).
+
+```swift
+users.withoutDuplicates(keyPath: \.id)
+```
+
+### `var removeNilElements: [Element]`
+`compactMap { $0 }` — only meaningful when `Element` is itself optional.
+
+### `mutating func removeAll(_ item: Element) -> [Element]` / `removeAll(_ items: [Element])`
+Remove every occurrence of one value / of any value in a list (`@discardableResult`).
+
+```swift
+var a = [1, 2, 2, 3]; a.removeAll(2)          // [1, 3]
+var b = [1, 2, 3, 4]; b.removeAll([2, 4])     // [1, 3]
+```
+
+### `mutating func prepend(_ newElement: Element)`
+Insert at index 0.
+
+### `mutating func safeSwap(from:to:)`
+Swap two indices; silently no-ops if either is out of bounds or equal.
+
+```swift
+var a = [1, 2, 3]; a.safeSwap(from: 0, to: 2)   // [3, 2, 1]
+a.safeSwap(from: 0, to: 9)                       // unchanged
+```
+
+</details>
+
+<details>
+<summary><b>Collection</b> — safe indexing, chunking, indices, averages</summary>
+
+### `var fullRange: Range<Index>`
+`startIndex..<endIndex`.
+
+### `subscript(safe index:) -> Element?` / `subscript(exist index:) -> Element?`
+Bounds-checked access, `nil` instead of a crash.
+
+```swift
+let a = [1, 2, 3]
+a[safe: 1]    // 2
+a[safe: 9]    // nil
+```
+
+### `func group(by size: Int) -> [[Element]]?`
+Split into chunks of `size` (last chunk may be shorter). `nil` when empty or `size <= 0`.
+
+```swift
+[0, 2, 4, 7, 6].group(by: 2)   // [[0, 2], [4, 7], [6]]
+```
+
+### `func forEach(slice: Int, body: ([Element]) -> Void)`
+Iterate in chunks without building the intermediate array.
+
+```swift
+[0, 2, 4, 7].forEach(slice: 2) { print($0) }   // [0, 2] then [4, 7]
+```
+
+### `func indices(where condition:) -> [Index]?`
+All indices matching a predicate, `nil` if none.
+
+```swift
+[1, 7, 1, 2, 1].indices(where: { $0 == 1 })   // [0, 2, 4]
+```
+
+### `func indices(of item: Element) -> [Index]` — *(`Element: Equatable`)*
+All indices equal to `item`.
+
+### `func adjacentPairs() -> AnySequence<(Element, Element)>`
+Every unordered pair `(i, j)` with `i` before `j`.
+
+```swift
+Array([1, 2, 3].adjacentPairs())   // [(1, 2), (1, 3), (2, 3)]
+```
+
+### `func forEachInParallel(_:)`
+`DispatchQueue.concurrentPerform` over the elements. No ordering guarantee.
+
+### `func average() -> Double` *(`Element: BinaryInteger`)* / `func average() -> Element` *(`Element: FloatingPoint`)*
+Mean, `0` for an empty collection.
+
+```swift
+[1, 2, 3, 4].average()        // 2.5
+[1.2, 2.3, 4.5].average()     // 2.666…
+```
+
+</details>
+
+<details>
+<summary><b>BidirectionalCollection</b></summary>
+
+### `subscript(offset distance: Int) -> Element`
+Positive offset from the start, negative from the end.
+
+```swift
+let a = [1, 2, 3, 4, 5]
+a[offset: 1]    // 2
+a[offset: -2]   // 4
+```
+
+### `func last<T: Equatable>(where keyPath:, equals value:) -> Element?`
+Last element whose key-path value equals `value`.
+
+```swift
+events.last(where: \.type, equals: .login)
+```
+
+</details>
+
+<details>
+<summary><b>Sequence</b> — predicates, key-path sorting, sums, dedup</summary>
+
+### `func all(matching:)` / `func none(matching:)` / `func any(matching:)`
+Whether the predicate holds for all / no / at least one element.
+
+```swift
+[2, 4, 6].all(matching: { $0 % 2 == 0 })   // true
+[1, 3].any(matching: { $0 % 2 == 0 })      // false
+```
+
+### `func reject(where:) -> [Element]`
+Inverse of `filter`.
+
+```swift
+[2, 3, 4, 7].reject(where: { $0 % 2 == 0 })   // [3, 7]
+```
+
+### `func count(where:) -> Int`
+Number of elements matching a predicate.
+
+### `func forEachReversed(_:)` / `func forEach(where:body:)`
+Iterate right-to-left / iterate only matching elements.
+
+### `func accumulate<U>(initial:next:) -> [U]`
+Like `reduce` but returns every interim result.
+
+```swift
+[1, 2, 3].accumulate(initial: 0, next: +)   // [1, 3, 6]
+```
+
+### `func filtered<T>(_ isIncluded:, map transform:) -> [T]`
+`filter` + `map` in one lazy pass.
+
+```swift
+[1, 2, 3, 4].filtered({ $0 % 2 == 0 }, map: { "\($0)" })   // ["2", "4"]
+```
+
+### `func single(where:) -> Element?`
+The one matching element, or `nil` if zero or more than one match.
+
+```swift
+[1, 4, 7].single(where: { $0 % 2 == 0 })      // 4
+[2, 4].single(where: { $0 % 2 == 0 })         // nil
+```
+
+### `func divided(by condition:) -> (matching:, nonMatching:)`
+Partition into two arrays.
+
+```swift
+let (even, odd) = [0, 1, 2, 3].divided { $0 % 2 == 0 }   // ([0, 2], [1, 3])
+```
+
+### `func withoutDuplicates<T: Hashable>(transform:) -> [Element]`
+Dedup by a derived hashable value.
+
+```swift
+[(1, "a"), (2, "b"), (1, "c")].withoutDuplicates { $0.0 }   // [(1, "a"), (2, "b")]
+```
+
+### `func sorted(by keyPath:)` / `sorted(by keyPath:with:)` / `sorted(by:and:)` / `sorted(by:and:and:)`
+Sort by one, two, or three key paths (later paths break ties). The `with:`
+variant takes an explicit comparator.
+
+```swift
+people.sorted(by: \.lastName, and: \.firstName)
+scores.sorted(by: \.value, with: >)
+```
+
+### `func sum() -> Element` *(`Element: AdditiveArithmetic`)* / `func sum<T: AdditiveArithmetic>(for keyPath:) -> T`
+Total of the elements, or of a numeric property.
+
+```swift
+[1, 2, 3].sum()                         // 6
+["ab", "cde"].sum(for: \.count)         // 5
+```
+
+### `func first<T: Equatable>(where keyPath:, equals value:) -> Element?`
+First element matching on a key path.
+
+### `func contains(_ elements: [Element]) -> Bool` *(`Element: Equatable` or `Hashable`)*
+Whether every element of `elements` is present (the `Hashable` overload is O(m+n)).
+
+### `func containsDuplicates() -> Bool` / `func duplicates() -> [Element]` *(`Element: Hashable`)*
+Whether any value repeats / the set of repeated values.
+
+```swift
+[1, 2, 2, 3, 3].duplicates().sorted()   // [2, 3]
+```
+
+</details>
+
+<details>
+<summary><b>RangeReplaceableCollection</b> — rotate, take/skip, offset subscripts</summary>
+
+### `init(expression:count:)`
+Build a collection by evaluating an autoclosure `count` times.
+
+```swift
+Array(expression: Int.random(in: 0..<10), count: 3)   // e.g. [4, 9, 1]
+```
+
+### `func rotated(by places: Int) -> Self` / `mutating func rotate(by:) -> Self`
+Rotate elements; positive moves the tail to the front.
+
+```swift
+[1, 2, 3, 4].rotated(by: 1)    // [4, 1, 2, 3]
+[1, 2, 3, 4].rotated(by: -1)   // [2, 3, 4, 1]
+```
+
+### `mutating func removeFirst(where:) -> Element?`
+Remove and return the first match (`@discardableResult`).
+
+### `mutating func removeRandomElement() -> Element?`
+Remove and return a random element.
+
+### `mutating func keep(while:) -> Self` / `func take(while:) -> Self` / `func skip(while:) -> Self`
+`keep`/`take` return the leading run that matches; `skip` returns everything
+after it.
+
+```swift
+[0, 2, 4, 7, 6].take(while: { $0 % 2 == 0 })   // [0, 2, 4]
+[0, 2, 4, 7, 6].skip(while: { $0 % 2 == 0 })   // [7, 6]
+```
+
+### `mutating func removeDuplicates<E>(keyPath:)`
+In-place dedup by an `Equatable` or `Hashable` key path.
+
+### `subscript(offset: Int) -> Element` / `subscript<R: RangeExpression>(range:) -> SubSequence`
+Get/set by integer offset or integer range.
+
+```swift
+var a = [10, 20, 30]; a[1] = 99      // [10, 99, 30]
+a[0..<2]                              // [10, 99]
+```
+
+### `mutating func appendIfNonNil(_:)` / `appendIfNonNil(contentsOf:)`
+Append only when the optional value / sequence is non-nil.
+
+```swift
+var a = [1]; a.appendIfNonNil(Optional<Int>.none)   // [1]
+a.appendIfNonNil(2)                                  // [1, 2]
+```
+
+</details>
+
+<details>
+<summary><b>Dictionary</b> — key paths, JSON, key/value maps, merge operators</summary>
+
+### `subscript(path path: [Key]) -> Any?`
+Deep get/set through nested dictionaries.
+
+```swift
+var d: [String: Any] = ["a": ["b": ["c": 1]]]
+d[path: ["a", "b", "c"]]              // 1
+d[path: ["a", "b", "c"]] = 2
+```
+
+### `var queryString: String`
+`key=value&key=value` (no percent-encoding — encode yourself if needed).
+
+```swift
+["a": 1, "b": 2].queryString   // "a=1&b=2" (order not guaranteed)
+```
+
+### `var convertToJSON: String`
+Pretty-printed JSON, or an error description string on failure.
+
+### `init(grouping sequence: by keyPath:)`
+Group a sequence into `[Key: [Element]]` by a key path.
+
+```swift
+Dictionary(grouping: people, by: \.city)
+```
+
+### `func toObjetct<T: Codable & Sendable>() throws -> T`
+Encode to JSON then decode into `T`. Throws `DecodingError` on a shape mismatch.
+
+```swift
+let user: User = try ["id": 1, "name": "Ana"].toObjetct()
+```
+
+### `func has(key:) -> Bool`
+Key presence check.
+
+### `mutating func removeAll<S: Sequence>(keys:)` / `static func - (lhs:keys:)` / `static func -= (lhs:keys:)`
+Remove a set of keys — mutating, or as a new dictionary via `-` / `-=`.
+
+```swift
+var d = ["a": 1, "b": 2, "c": 3]
+d -= ["a", "b"]                       // ["c": 3]
+```
+
+### `mutating func removeValueForRandomKey() -> Value?`
+Remove and return one random entry's value.
+
+### `func jsonData(prettify: Bool = false) -> Data?` / `func jsonString(prettify: Bool = false) -> String?`
+Serialise to `Data` / `String`, `nil` if the dictionary isn't a valid JSON object.
+
+### `func mapKeysAndValues<K, V>(_:) -> [K: V]` / `func compactMapKeysAndValues<K, V>(_:) -> [K: V]`
+Transform both keys and values in one pass; the `compact` variant drops `nil` results.
+
+```swift
+["a": 1].mapKeysAndValues { ($0.key.uppercased(), $0.value * 10) }   // ["A": 10]
+```
+
+### `func pick(keys: [Key]) -> [Key: Value]`
+Sub-dictionary limited to the given keys.
+
+### `static func + (lhs:rhs:)` / `static func += (lhs:rhs:)`
+Merge two dictionaries (right wins on key clash).
+
+### `func keys(forValue value:) -> [Key]` *(`Value: Equatable`)*
+All keys mapping to a value.
+
+### `mutating func lowercaseAllKeys()` *(`Key: StringProtocol`)*
+Lowercase every key in place.
+
+### `var uniqueValues: [Key: Value]` *(`Value: Hashable`)*
+Keep only the first entry seen for each distinct value.
+
+</details>
+
+<details>
+<summary><b>Optional</b> — safe unwrap, conditional assignment</summary>
+
+### `func unwrapped(or defaultValue: Wrapped) -> Wrapped`
+`self ?? defaultValue`, read nicely.
+
+```swift
+let name: String? = nil
+name.unwrapped(or: "Guest")   // "Guest"
+```
+
+### `func unwrapped(or error: Error) throws -> Wrapped`
+Unwrap or throw a chosen error.
+
+```swift
+let id = try userId.unwrapped(or: AppError.missingID)
+```
+
+### `func run(_ block: (Wrapped) -> Void)`
+Run a block only when non-nil (like `if let`, expression-style).
+
+```swift
+token.run { print("have token \($0)") }
+```
+
+### `static func ??= (lhs: inout Optional, rhs: Optional)`
+Assign only if the right side is non-nil.
+
+```swift
+var params: String? = "a"; params ??= nil   // still "a"
+```
+
+### `static func ?= (lhs: inout Optional, rhs: @autoclosure)`
+Assign only if the left side is currently nil.
+
+```swift
+var text: String? = nil
+text ?= "first"     // "first"
+text ?= "second"    // still "first"
+```
+
+### `var isNilOrEmpty: Bool` / `var nonEmpty: Wrapped?` *(`Wrapped: Collection`)*
+Nil-or-empty check; `nonEmpty` returns the collection only when it has content.
+
+```swift
+let list: [Int]? = []
+list.isNilOrEmpty   // true
+list.nonEmpty       // nil
+```
+
+### `static func == / != (Optional, Wrapped.RawValue?)` *(`Wrapped: RawRepresentable`)*
+Compare an optional enum directly against an optional raw value.
+
+```swift
+let status: Status? = .active
+status == "active"   // true
+```
+
+</details>
+
+<details>
+<summary><b>Comparable</b></summary>
+
+### `func isBetween(_ range: ClosedRange<Self>) -> Bool`
+Range membership.
+
+```swift
+7.isBetween(6...12)   // true
+```
+
+### `func clamped(to range: ClosedRange<Self>) -> Self`
+Constrain a value to a range.
+
+```swift
+1.clamped(to: 3...8)      // 3
+0.32.clamped(to: 0.1...0.29)   // 0.29
+```
+
+</details>
+
+<details>
+<summary><b>Bool</b></summary>
+
+### `var int: Int` / `var string: String` / `var data: Data`
+`1`/`0`, `"true"`/`"false"`, or a single-byte `Data`.
+
+```swift
+true.int      // 1
+false.string  // "false"
+```
+
+</details>
+
+## Numbers & Geometry
+
+<details>
+<summary><b>Int</b> — conversions, digits, primes, roman numerals, operators</summary>
+
+### `var double: Double` / `var float: Float` / `var cgFloat: CGFloat` / `var uInt: UInt` / `var uInt32: UInt32` / `var uInt64: UInt64`
+Straight numeric conversions (`uInt32`/`uInt64` truncate).
+
+```swift
+5.double    // 5.0
+(-1).uInt32 // 4294967295
+```
+
+### `var countableRange: CountableRange<Int>`
+`0..<self`.
+
+```swift
+3.countableRange   // 0..<3
+```
+
+### `var degreesToRadians: Double` / `var radiansToDegrees: Double`
+Angle conversion.
+
+```swift
+180.degreesToRadians   // 3.14159…
+```
+
+### `var digits: [Int]` / `var digitsCount: Int`
+Decimal digits of `abs(self)`, and how many.
+
+```swift
+1234.digits       // [1, 2, 3, 4]
+1234.digitsCount  // 4
+```
+
+### `var kFormatted: String`
+Compact "k"/"kk" formatting for values ≥ 1000.
+
+```swift
+5300.kFormatted     // "5k"
+2_500_000.kFormatted // "25kk"
+```
+
+### `var timestampToDate: Date`
+`Date(timeIntervalSince1970:)`.
+
+```swift
+1_700_000_000.timestampToDate   // 2023-11-14 …
+```
+
+### `var satsToBTC: String` / `var convertToBTC: String` / `var toBTC: String`
+Satoshis → BTC string, 8 decimal places. All three are the same.
+
+```swift
+150_000_000.satsToBTC   // "1.50000000"
+```
+
+### `func isPrime() -> Bool`
+Primality test (trial division up to √n).
+
+```swift
+7.isPrime()   // true
+9.isPrime()   // false
+```
+
+### `func romanNumeral() -> String?`
+Roman numerals for positive integers, `nil` for 0 or negative.
+
+```swift
+2024.romanNumeral()   // "MMXXIV"
+```
+
+### `func roundToNearest(_ number: Int) -> Int`
+Round to the closest multiple of `number`.
+
+```swift
+47.roundToNearest(10)   // 50
+```
+
+### Operators
+| Operator | Meaning | Example |
+|---|---|---|
+| `a ** b` | exponentiation → `Double` | `2 ** 3` → `8.0` |
+| `√ n` (prefix) | square root → `Double` | `√ 9` → `3.0` |
+| `a ± b` (infix) | `(a+b, a-b)` | `5 ± 3` → `(8, 2)` |
+| `± n` (prefix) | `(n, -n)` | `± 2` → `(2, -2)` |
+
+</details>
+
+<details>
+<summary><b>Float / Double</b></summary>
+
+### `var int: Int` / `var double: Double` (Float) / `var float: Float` (Double) / `var cgFloat: CGFloat`
+Numeric conversions.
+
+### `var satsToBTC / convertToBTC / toBTC`
+Satoshis → BTC (`Double` here, unlike `Int` which returns a `String`).
+
+```swift
+150_000_000.0.satsToBTC   // 1.5
+```
+
+### `func rounded(toPlaces places: Int) -> Float` — *(Float only)*
+Round to N decimal places.
+
+```swift
+Float(3.14159).rounded(toPlaces: 2)   // 3.14
+```
+
+### Operator `a ** b`
+Exponentiation, staying in the same type (`Float ** Float → Float`, `Double ** Double → Double`).
+
+```swift
+4.4 ** 0.5   // 2.0976…
+```
+
+</details>
+
+<details>
+<summary><b>Decimal</b></summary>
+
+### `mutating func round(_ scale: Int, _ roundingMode:)` / `func rounded(_ scale:, _ roundingMode:) -> Decimal`
+Decimal rounding via `NSDecimalRound` — mutating and non-mutating.
+
+```swift
+Decimal(2.567).rounded(2, .plain)   // 2.57
+```
+
+</details>
+
+<details>
+<summary><b>BinaryInteger</b></summary>
+
+### `var bytes: [UInt8]`
+Big-endian raw byte representation.
+
+```swift
+Int16(-128).bytes   // [255, 128]
+```
+
+### `init?(bytes: [UInt8])`
+Reconstruct an integer from bytes (traps if the byte count exceeds the type size;
+`nil` if the value doesn't fit exactly).
+
+```swift
+Int16(bytes: [0xFF, 0xFD])   // -3
+```
+
+</details>
+
+<details>
+<summary><b>BinaryFloatingPoint</b></summary>
+
+### `func rounded(numberOfDecimalPlaces: Int, rule: FloatingPointRoundingRule) -> Self`
+Round to N places with an explicit rule (negative places treated as 0).
+
+```swift
+3.1415927.rounded(numberOfDecimalPlaces: 3, rule: .up)   // 3.142
+```
+
+</details>
+
+<details>
+<summary><b>SignedNumeric</b></summary>
+
+### `var string: String`
+`String(describing:)`.
+
+### `var asLocaleCurrency: String?` / `func asCurrency(locale: Locale = pt_BR) -> String?`
+Currency formatting in the current locale / a specified locale.
+
+```swift
+1234.5.asCurrency()                                  // "R$ 1.234,50"
+1234.5.asCurrency(locale: Locale(identifier: "en_US")) // "$1,234.50"
+```
+
+### `func spelledOutString(locale: Locale = .current) -> String?`
+Number spelled out in words.
+
+```swift
+92.spelledOutString(locale: Locale(identifier: "en"))   // "ninety-two"
+```
+
+</details>
+
+<details>
+<summary><b>CGFloat</b></summary>
+
+### `var abs / ceil / floor` / `var int / float / double`
+Math and numeric conversions.
+
+```swift
+CGFloat(-3.2).abs    // 3.2
+CGFloat(3.2).ceil    // 4.0
+```
+
+### `var isPositive: Bool` / `var isNegative: Bool`
+Sign checks.
+
+### `var degreesToRadians: CGFloat` / `var radiansToDegrees: CGFloat`
+Angle conversion.
+
+</details>
+
+<details>
+<summary><b>CGRect</b></summary>
+
+### `var center: CGPoint`
+Rect centre.
+
+### `init(center: CGPoint, size: CGSize)`
+Build a rect from its centre and size.
+
+```swift
+CGRect(center: CGPoint(x: 50, y: 50), size: CGSize(width: 20, height: 10))
+// origin (40, 45), size 20×10
+```
+
+### `func resizing(to size: CGSize, anchor: CGPoint = (0.5, 0.5)) -> CGRect`
+Resize while keeping the given normalised anchor point fixed.
+
+```swift
+rect.resizing(to: CGSize(width: 100, height: 100), anchor: CGPoint(x: 0, y: 1))
+// grows from the bottom-left corner
+```
+
+</details>
+
+<details>
+<summary><b>CGSize</b></summary>
+
+### `var aspectRatio: CGFloat` / `var maxDimension: CGFloat` / `var minDimension: CGFloat`
+`width / height` (0 when height is 0), and the larger / smaller side.
+
+```swift
+CGSize(width: 16, height: 9).aspectRatio   // 1.777…
+```
+
+### `func aspectFit(to boundingSize:) -> CGSize` / `func aspectFill(to boundingSize:) -> CGSize`
+Scale to fit inside / fill a bounding size, preserving ratio.
+
+```swift
+CGSize(width: 120, height: 80).aspectFit(to: CGSize(width: 100, height: 50))
+// 75 × 50
+```
+
+### Operators
+`+`, `-`, `*` and their `+=`/`-=`/`*=` forms, between two `CGSize`s, a `CGSize`
+and a `(width, height)` tuple, or a `CGSize` and a scalar.
+
+```swift
+CGSize(width: 5, height: 10) + CGSize(width: 3, height: 4)   // 8 × 14
+CGSize(width: 5, height: 10) * 3                              // 15 × 30
+```
+
+</details>
+
+<details>
+<summary><b>CGPoint / CGRect / CGSize — <code>Hashable</code></summary>
+
+When SwiftUI is available, `CGPoint`, `CGRect`, and `CGSize` are made
+`Hashable` (retroactive conformance) so they can be used as dictionary keys or
+in `Set`s and as SwiftUI identifiers.
+
+```swift
+var seen: Set<CGPoint> = []
+seen.insert(CGPoint(x: 1, y: 2))
+```
+
+</details>
+
+## Date, Data & Files
+
+<details>
+<summary><b>Date</b> — components, comparisons, formatting, arithmetic, init</summary>
+
+### Calendar-component accessors
+Read (and, where noted, write) individual components using the user's current calendar.
+
+| Property | Get | Set |
+|---|---|---|
+| `year` | ✅ | ✅ |
+| `month` | ✅ | ✅ (clamped to valid range) |
+| `day` | ✅ | ✅ (clamped) |
+| `hour` / `minute` / `second` | ✅ | ✅ (clamped) |
+| `nanosecond` / `millisecond` | ✅ | ✅ (clamped) |
+| `weekday` / `weekOfMonth` / `weekOfYear` / `quarter` / `era` | ✅ | — |
+| `calendar` | ✅ (`Calendar.current`) | — |
+
+```swift
+var d = Date()
+d.year = 2030          // shifts the date to 2030, keeping everything else
+d.minute = 0
+Date().weekday          // 1 = Sunday (Gregorian)
+```
+
+### Relative checks
+`isInFuture`, `isInPast`, `isInToday`, `isInYesterday`, `isInTomorrow`,
+`isInWeekend`, `isWorkday`, `isInCurrentWeek`, `isInCurrentMonth`, `isInCurrentYear`.
+
+```swift
+someDate.isInToday        // Bool
+someDate.isInWeekend      // Bool
+```
+
+### `func isInCurrent(_ component: Calendar.Component) -> Bool`
+Same granularity check, for an arbitrary component.
+
+```swift
+Date().isInCurrent(.year)   // true
+```
+
+### `var iso8601String: String` / `var unixTimestamp: Double`
+`yyyy-MM-dd'T'HH:mm:ss.SSS` + `Z` (GMT); seconds since 1970.
+
+```swift
+Date().iso8601String    // "2026-08-29T14:51:29.574Z"
+```
+
+### Rounding
+`nearestFiveMinutes`, `nearestTenMinutes`, `nearestQuarterHour`, `nearestHalfHour`, `nearestHour` — all return a new `Date`.
+
+```swift
+var d = Date(); d.minute = 44
+d.nearestFiveMinutes    // :45
+d.nearestHour           // rounds up because minute ≥ 30
+```
+
+### `var yesterday: Date` / `var tomorrow: Date`
+±1 day.
+
+### `func adding(_:value:) -> Date` / `mutating func add(_:value:)`
+Add multiples of a calendar component.
+
+```swift
+Date().adding(.day, value: 7)         // one week later
+var d = Date(); d.add(.month, value: -1)
+```
+
+### `func changing(_:value:) -> Date?`
+Set one component to a specific value (validated; `nil` if out of range).
+
+```swift
+Date().changing(.hour, value: 9)      // 9am today
+```
+
+### `func beginning(of component:) -> Date?` / `func end(of component:) -> Date?`
+Start / end instant of the enclosing `.day` / `.month` / `.year` / `.hour` / week, etc.
+
+```swift
+Date().beginning(of: .month)    // 1st, 00:00:00
+Date().end(of: .day)            // 23:59:59
+```
+
+### Differences
+`secondsSince(_:)`, `minutesSince(_:)`, `hoursSince(_:)`, `daysSince(_:)` — signed `Double`.
+
+```swift
+endDate.hoursSince(startDate)   // e.g. 3.5
+```
+
+### `func isBetween(_ start: Date, _ end: Date, includeBounds: Bool = false) -> Bool`
+Range check.
+
+### `func isWithin(_ value: UInt, _ component: Calendar.Component, of date: Date) -> Bool`
+Whether two dates are within N components of each other.
+
+```swift
+a.isWithin(3, .day, of: b)   // true if ≤ 3 days apart
+```
+
+### Formatting
+| Method | Example output |
+|---|---|
+| `string(withFormat: String = "dd/MM/yyyy HH:mm")` | `"29/08/2026 14:30"` |
+| `dateString(ofStyle: .medium)` | `"Aug 29, 2026"` |
+| `dateTimeString(ofStyle: .short)` | `"8/29/26, 2:30 PM"` |
+| `timeString(ofStyle: .short)` | `"2:30 PM"` |
+| `dayName(ofStyle: .full / .threeLetters / .oneLetter)` | `"Saturday"` / `"Sat"` / `"S"` |
+| `monthName(ofStyle: .full / .threeLetters / .oneLetter)` | `"August"` / `"Aug"` / `"A"` |
+
+```swift
+Date().string(withFormat: "yyyy-MM-dd")   // "2026-08-29"
+Date().dayName(ofStyle: .threeLetters)     // "Sat"
+```
+
+### Random dates
+`static func random(in: Range<Date>) -> Date`, plus `ClosedRange` and
+`using generator:` variants.
+
+```swift
+Date.random(in: startDate...endDate)
+```
+
+### Initializers
+- `init?(calendar:timeZone:era:year:month:day:hour:minute:second:nanosecond:)` — every field defaults to "now".
+- `init?(iso8601String:)` — parse `yyyy-MM-dd'T'HH:mm:ss.SSSZ`.
+- `init(unixTimestamp:)` — seconds since 1970.
+- `init?(integerLiteral:)` — parse a packed `yyyyMMdd` integer.
+
+```swift
+Date(year: 2010, month: 1, day: 12)
+Date(iso8601String: "2026-01-12T16:48:00.959Z")
+Date(integerLiteral: 2026_12_25)
+```
+
+</details>
+
+<details>
+<summary><b>Data</b> — JSON, hashing, hex, XOR, decoding</summary>
+
+### `var prettyJson: String?`
+Pretty-printed JSON if the data is a valid JSON value.
+
+```swift
+responseData.prettyJson
+```
+
+### `var toDictionay: [String: Any]?`
+Parse a JSON object to a dictionary (note the spelling — `toDictionay`).
+
+### `var toHexString: String` / `func toHexadecimalString() -> String`
+Lower-case hex representation of the bytes.
+
+```swift
+Data([0x0f, 0xa0]).toHexString   // "0fa0"
+```
+
+### `var bool: Bool`
+`first != 0`.
+
+### `init?(hexString:)`
+Parse a hex string (spaces allowed) to bytes; `nil` on an invalid nibble.
+
+```swift
+Data(hexString: "0f a0")   // 2 bytes
+```
+
+### `func SHA256() -> Data` / `func SHA512() -> Data`
+CommonCrypto digests (empty `Data` if CommonCrypto is unavailable).
+
+```swift
+Data("abc".utf8).SHA256().toHexString
+```
+
+### `func HMACSHA512(key: Data) -> Data` — *iOS 13+*
+CryptoKit HMAC-SHA512.
+
+```swift
+message.HMACSHA512(key: secret)
+```
+
+### `func XOR(with other: Data) -> Data`
+Byte-wise XOR (result length = shorter of the two).
+
+```swift
+a.XOR(with: pad)
+```
+
+### `static func MD5(string:) -> Data` — *iOS 13+*
+MD5 of a string (insecure — legacy interop only). Returns the hex digest **as UTF-8 bytes**.
+
+```swift
+Data.MD5(string: "Hello").toHexString
+```
+
+### `func object<T: Codable & Sendable>() -> T?`
+Decode JSON data to `T`, `nil` + logs on failure.
+
+```swift
+let user: User? = responseData.object()
+```
+
+</details>
+
+<details>
+<summary><b>URL</b></summary>
+
+### `var params: [String: String]`
+Query items as a dictionary (missing values become `""`).
+
+```swift
+URL(string: "https://x.com?a=1&b=2")!.params   // ["a": "1", "b": "2"]
+```
+
+</details>
+
+<details>
+<summary><b>FileManager</b> — Documents-directory helpers</summary>
+
+### `func createDirectory(_ directoryName: String) -> URL?`
+Create (if missing) a folder under Documents; returns its URL.
+
+```swift
+let dir = FileManager.default.createDirectory("cache")
+```
+
+### `func retrieveFile(_ directoryAndFile: String) -> URL`
+Build a `file://` URL under Documents for the given relative path (no existence check).
+
+### `func convertToURL(path: String) -> URL?`
+Directory URL under Documents, or `nil` if it can't be listed.
+
+### `func saveFileToDirectory(_ sourceURL: URL, toPathURL: URL) -> Bool`
+`moveItem(at:to:)`, returning success.
+
+### `func saveImageToDirectory(_ imageWithPath: String, imagem: UIImage) -> Bool` — *UIKit only*
+Write a `UIImage` as PNG to an absolute path.
+
+```swift
+FileManager.default.saveImageToDirectory(path, imagem: photo)
+```
+
+### `func removeFile(_ directoryAndFile: String) -> Bool`
+`removeItem(atPath:)`, returning success.
+
+### `func retrieveAllFilesFromDirectory(directoryName: String) -> [String]?`
+File names in a Documents sub-folder (`.DS_Store` filtered out).
+
+### `func directoryExistsAtPath(_ path: String) -> Bool`
+Exists **and** is a directory.
+
+</details>
+
+<details>
+<summary><b>UserDefaults</b> — Codable storage, common flags (<code>@MainActor</code>)</summary>
+
+### `var isLoggedIn: Bool` / `var isFirstTimeOnApp: Bool`
+Ready-made boolean flags (keys `"isLoggedIn"` / `"isFirstTimeOnApp"`), auto-`synchronize()` on set.
+
+```swift
+UserDefaults.standard.isFirstTimeOnApp = false
+```
+
+### `func set<T: Codable>(object: T, forKey key: String, usingEncoder: = JSONEncoder())`
+Encode and store any `Codable` value.
+
+### `func object<T: Codable>(_ type: T.Type, with key: String, usingDecoder: = JSONDecoder()) -> T?`
+Decode a stored `Codable` value.
+
+```swift
+UserDefaults.standard.set(object: user, forKey: "user")
+let user = UserDefaults.standard.object(User.self, with: "user")
+```
+
+### `func removeSavedObject(forKey:) -> Bool`
+Remove a value **only if it is a String**; returns whether it removed anything.
+
+### `func removeAllSaved()`
+Wipe the app's entire persistent domain.
+
+### `func showEverything() -> [String: Any]`
+Full `dictionaryRepresentation()` — handy for debugging.
+
+</details>
+
+## Encoding & Errors
+
+<details>
+<summary><b>Encodable</b> — dictionary / JSON conversion</summary>
+
+### `var dictionary: [String: Any]`
+JSON-encode `self`, then reparse to a dictionary (`[:]` on failure).
+
+```swift
+struct Point: Encodable { let x = 1; let y = 2 }
+Point().dictionary   // ["x": 1, "y": 2]
+```
+
+### `var json: String` / `var data: Data`
+Dictionary → JSON string / `Data`.
+
+### `subscript(key: String) -> Any?`
+Read one value from the encoded form.
+
+```swift
+Point()["x"]   // 1
+```
+
+</details>
+
+<details>
+<summary><b>JSONDecoder</b> — decoding helpers</summary>
+
+All return `T: Decodable & Sendable` and throw a **readable** `NSError` naming the
+missing key / mismatched type / missing value on failure.
+
+### `static func decode<T>(data: Data) throws -> T`
+
+```swift
+let user: User = try JSONDecoder.decode(data: responseData)
+```
+
+### `static func decode<T>(_ json: String, using encoding: String.Encoding = .utf8) throws -> T`
+
+```swift
+let user: User = try JSONDecoder.decode(#"{"id":1,"name":"Ana"}"#)
+```
+
+### `static func decode<T>(fromURL url: URL) throws -> T`
+Read a file/URL then decode.
+
+### `static func decode<T>(dictionary: Any) throws -> T`
+Re-encode a dictionary/array to JSON then decode (uses `.convertFromSnakeCase`).
+
+```swift
+let user: User = try JSONDecoder.decode(dictionary: ["user_id": 1, "full_name": "Ana"])
+```
+
+</details>
+
+<details>
+<summary><b>NSError</b></summary>
+
+### `static func createErrorWith(code: Int, description: String, reasonForError: String) -> NSError`
+Build an `NSError` in the `LoverdeCoErrorDomain` with a localized description and
+failure reason. Used throughout `API` for HTTP errors.
+
+```swift
+throw NSError.createErrorWith(code: 404, description: "Not found", reasonForError: body)
+```
+
+</details>
+
+## Crypto
+
+<details>
+<summary><b>RIPEMD_160</b> — RIPEMD-160 digest</summary>
+
+### `static func hash(_ message: Data) -> Data`
+
+Returns the 20-byte RIPEMD-160 digest of `message`. Pure Swift, no system
+dependency. Mainly useful for Bitcoin-style address hashing (`RIPEMD160(SHA256(x))`).
+
+```swift
+let digest = RIPEMD_160.hash(Data("abc".utf8))
+digest.count                                   // 20
+digest.map { String(format: "%02x", $0) }.joined()
+// "8eb208f7e05d987a9b044a8e98c6b087f15a0bfc"
+```
+
+</details>
+
+<details>
+<summary><b>LCECryptoKitManager</b> — OTP / peppered-login bridge (needs the <code>LCECryptoKit</code> binary)</summary>
+
+A thin facade over the optional `LCECryptoKit` binary product (enabled by the
+`LCE_ENABLE_CRYPTO_BINARY` build flag). **When the binary is not linked every
+method is a no-op** returning `nil` / `""` / `false`, so calling code still
+compiles and runs.
+
+### `init()` / `init(privateKey:)`
+
+Create a manager. The `privateKey` (a.k.a. "hash key") is only needed by the
+`*WithKey` methods.
+
+```swift
+let crypto = LCECryptoKitManager()
+let keyed  = LCECryptoKitManager(privateKey: serverHashKey)
+```
+
+### `static func generateKey() -> String`
+
+Generates a random AES key string.
+
+```swift
+let key = LCECryptoKitManager.generateKey()
+```
+
+### `func encodeTP(email:password:) -> String?` / `func decodeOTP(_:) -> String?`
+
+Encode an email+password pair into an OTP seed hash, and decode it back.
+
+```swift
+let hash = crypto.encodeTP(email: "ana@x.com", password: "s3cr3t")
+let back = crypto.decodeOTP(hash ?? "")
+```
+
+### `func encodeOTPWithKey(email:password:) -> String?` / `func decodeOTPWithKey(_:) -> Bool`
+
+Same as above but bound to the instance's `privateKey`; `decodeOTPWithKey`
+returns whether the hash validates against that key rather than the decoded value.
+
+```swift
+let keyed = LCECryptoKitManager(privateKey: serverHashKey)
+let hash  = keyed.encodeOTPWithKey(email: "ana@x.com", password: "s3cr3t")
+let ok    = keyed.decodeOTPWithKey(hash ?? "")     // Bool
+```
+
+### `static func generateSalt() -> String`
+
+Random salt for the salted/iterated/peppered login flow.
+
+```swift
+let salt = LCECryptoKitManager.generateSalt()
+```
+
+### `static func computeClientHash(email:password:salt:) -> String`
+
+Client-side hash of the credentials with the given salt — sent to the server
+instead of the raw password.
+
+```swift
+let clientHash = LCECryptoKitManager.computeClientHash(
+    email: "ana@x.com", password: "s3cr3t", salt: salt
+)
+```
+
+### `static func computeLoginBearerToken(userId:clientHash:) -> String?`
+
+Derives the login bearer token from a user id and the client hash.
+
+```swift
+let token = LCECryptoKitManager.computeLoginBearerToken(userId: "42", clientHash: clientHash)
+```
+
+### `static func otpEncode(_:) -> String?` / `static func otpDecode(_:) -> String?`
+
+One-time-pad encode/decode of an arbitrary string.
+
+```swift
+let enc = LCECryptoKitManager.otpEncode("secret-value")
+let dec = LCECryptoKitManager.otpDecode(enc ?? "")     // "secret-value"
+```
+
+</details>
+
+## Core — the `LCEssentials` namespace
+
+<details>
+<summary><b>Logging</b> — <code>printLog</code> / <code>printInfo</code> / <code>printWarn</code> / <code>printError</code></summary>
+
+Four global functions used across the package. Each takes `title:` + `msg: Any`
+and an optional `prettyPrint: Bool` (wraps the message in a START/END banner and,
+for info/warn/error, prints the call-site file/function/line).
+
+```swift
+printLog(title: "STATE", msg: viewModel.state)
+printError(title: "Decode", msg: error.localizedDescription, prettyPrint: true)
+```
+
+### Operator `a ^^ b`
+Float exponentiation.
+
+```swift
+2.0 ^^ 10.0   // 1024.0
+```
+
+</details>
+
+<details>
+<summary><b>LCEssentials</b> — app / device / environment info (static, <code>@MainActor</code>)</summary>
+
+### App info
+
+| Property | Value |
+|---|---|
+| `appDisplayName` | `CFBundleDisplayName` |
+| `appBundleID` | `Bundle.main.bundleIdentifier` |
+| `appBuild` | build number string |
+| `appVersion` | short version string |
+| `applicationIconBadgeNumber` | get/set the icon badge (iOS/tvOS) |
+
+```swift
+LCEssentials.appVersion        // "2.0.0"
+LCEssentials.applicationIconBadgeNumber = 0
+```
+
+### Device / screen
+
+| Property | Value |
+|---|---|
+| `currentDevice` | `UIDevice.current` / `WKInterfaceDevice.current()` |
+| `screenWidth` / `screenHeight` | main screen bounds |
+| `deviceOrientation` | `UIDeviceOrientation` (iOS) |
+| `batteryLevel` | `Float` (iOS) |
+| `systemVersion` | OS version string |
+| `isPad` / `isPhone` | idiom checks (iOS) |
+| `isMultitaskingSupported` | iOS |
+
+```swift
+if LCEssentials.isPad { … }
+LCEssentials.screenWidth
+```
+
+### Environment
+
+| Property | Value |
+|---|---|
+| `isInDebuggingMode` | built in Debug |
+| `isInTestFlight` | running a TestFlight build |
+| `isRunningOnSimulator` | simulator target |
+| `isRegisteredForRemoteNotifications` | push registration state |
+| `isStatusBarHidden` | status-bar visibility (iOS) |
+| `keyWindow` | current key `UIWindow` (iOS/tvOS) |
+| `sharedApplication` | `UIApplication.shared` |
+
+```swift
+guard !LCEssentials.isRunningOnSimulator else { return }
+```
+
+### `static func sourceFileName(filePath: String) -> String`
+Last path component of a `#file` string.
+
+### `static func getTopViewController(base: UIViewController? = nil, aboveBars: Bool = true) -> UIViewController?`
+Walk the presentation/navigation/tab hierarchy to the front-most controller.
+`aboveBars: false` descends into the visible child of nav/tab containers.
+
+```swift
+let top = LCEssentials.getTopViewController()
+top?.present(alert, animated: true)
+```
+
+</details>
+
+<details>
+<summary><b>LCEssentials</b> — threading, timing, sharing (static methods)</summary>
+
+### `static func backgroundThread(delay: Double = 0, background: (@Sendable () -> Void)? = nil, completion: (@Sendable () -> Void)? = nil)`
+Run `background` off the main queue, then `completion` on the main queue after `delay`.
+
+```swift
+LCEssentials.backgroundThread(delay: 0.3, background: {
+    let result = heavyWork()
+}, completion: {
+    updateUI()
+})
+```
+
+### `static func dispatchAsync(completion: @escaping () -> Void)`
+`DispatchQueue.main.async` shorthand.
+
+### `@discardableResult static func delay(milliseconds: Double, queue: DispatchQueue = .main, completion:) -> DispatchWorkItem`
+Delayed call; keep the returned item to `.cancel()` it.
+
+```swift
+let task = LCEssentials.delay(milliseconds: 500) { fire() }
+task.cancel()   // if no longer needed
+```
+
+### `static func debounce(millisecondsDelay: Int, queue: DispatchQueue = .main, action:) -> () -> Void`
+Returns a debounced wrapper — call it repeatedly, `action` runs at most once per idle window.
+
+```swift
+let search = LCEssentials.debounce(millisecondsDelay: 300) { runSearch() }
+textField.onChange = search
+```
+
+### `static func didTakeScreenShot(_ action: @escaping (Notification) -> Void)` — *iOS/tvOS*
+Observe `userDidTakeScreenshotNotification`.
+
+### `static func shareApp(message: String = "", url: String = "")` — *UIKit*
+Present a `UIActivityViewController` from the top view controller.
+
+### `static func call(_ number: String)` / `static func openSafari(_ urlStr: String)` — *UIKit*
+Open `tel://` / open a URL.
+
+```swift
+LCEssentials.call("+5511999999999")
+LCEssentials.openSafari("https://loverde.com.br")
+```
+
+</details>
+
+<details>
+<summary><b>LCEssentials</b> — cached file download (iOS)</summary>
+
+A shared 50 MB memory / 200 MB disk `URLCache` backs these.
+
+### `static func downloadFileWithCache(from url: URL, completion: @escaping (Result<URL, Error>) -> Void)`
+Return a local temp-file URL for a remote file, hitting the cache first.
+
+```swift
+LCEssentials.downloadFileWithCache(from: pdfURL) { result in
+    if case .success(let localURL) = result { showPDF(localURL) }
+}
+```
+
+### `static func cachedFileURL(for url: URL) -> URL?`
+Temp-file URL if the response is already cached, else `nil`.
+
+### `static func cleanExpiredCache(expiration: TimeInterval = 7 days)`
+Drop cached responses and temp files older than `expiration`.
+
+</details>
+
+<details>
+<summary><b>LCESingletonDelegate</b></summary>
+
+### `@objc protocol LCESingletonDelegate: AnyObject`
+Optional callback `singleton(object: Any?, withData: Any)` — the delegate contract
+for the package's singleton-style helpers.
+
+```swift
+final class Foo: NSObject, LCESingletonDelegate {
+    func singleton(object: Any?, withData: Any) { … }
+}
+```
+
+</details>
diff --git a/Documentation/SwiftUI.md b/Documentation/SwiftUI.md
new file mode 100644
index 0000000..993dc3b
--- /dev/null
+++ b/Documentation/SwiftUI.md
@@ -0,0 +1,117 @@
+# LCEssentials — SwiftUI
+
+SwiftUI components and `View` helpers. Foundation/value-type helpers are in
+[Extensions.md](Extensions.md); UIKit-era helpers in [UIKit.md](UIKit.md).
+
+Every section is a collapsible block — click a heading to expand it.
+
+## Contents
+
+- [Navigation](#navigation)
+- [View helpers](#view-helpers)
+
+---
+
+## Navigation
+
+<details>
+<summary><b>LCENavigationView</b> — customizable navigation bar (iOS 15+)</summary>
+
+A drop-in replacement for the system navigation bar with left/right buttons,
+title + subtitle, background colour, and a hide toggle. Configuration methods
+return `self`, so they chain. **Per the workspace iOS standards, this component
+is mandatory on new SwiftUI screens instead of a hand-rolled bar.**
+
+`@available(iOS 15, *)`, iOS only.
+
+### `init(title: (any View) = Text(""), subTitle: (any View) = Text(""), @ViewBuilder content: () -> Content)`
+
+The `content` closure is everything shown **below** the bar.
+
+```swift
+LCENavigationView(title: Text("Profile")) {
+    ScrollView {
+        ProfileForm()
+    }
+}
+```
+
+### `func setTitle(text: (any View) = Text(""), subTitle: (any View)? = nil) -> LCENavigationView`
+
+Set (or replace) the title and optional subtitle. Passing no `subTitle` hides
+the subtitle row.
+
+```swift
+LCENavigationView { Content() }
+    .setTitle(text: Text("Orders"), subTitle: Text("32 open"))
+```
+
+### `func setLeftButton(text: Text = Text(""), image: (any View)? = nil, action: @escaping () -> Void) -> LCENavigationView`
+
+Configure the leading button. If the trailing button has no text/image yet, a
+transparent placeholder is added on that side so the title stays centred.
+
+```swift
+.setLeftButton(text: Text("Back"), image: Image(systemName: "chevron.left")) {
+    dismiss()
+}
+```
+
+### `func setRightButton(text: Text = Text(""), image: (any View)? = nil, action: @escaping () -> Void) -> LCENavigationView`
+
+Configure the trailing button (same placeholder behaviour for the leading side).
+
+```swift
+.setRightButton(image: Image(systemName: "plus")) {
+    showingNewItem = true
+}
+```
+
+### `func hideNavigationView(_ hide: Bool) -> LCENavigationView`
+
+Show or hide the whole bar (the content stays).
+
+```swift
+.hideNavigationView(isFullScreenMedia)
+```
+
+### `func setNavigationBarBackgroundColor(_ color: Color) -> LCENavigationView`
+
+Bar background colour (extends into the top safe area). Defaults to `.clear`.
+
+```swift
+.setNavigationBarBackgroundColor(.blue.opacity(0.1))
+```
+
+### Full example
+
+```swift
+struct OrdersScreen: View {
+    @Environment(\.dismiss) private var dismiss
+    @State private var showingNew = false
+
+    var body: some View {
+        LCENavigationView(title: Text("Orders")) {
+            OrdersList()
+        }
+        .setLeftButton(text: Text("Back"),
+                       image: Image(systemName: "chevron.left")) { dismiss() }
+        .setRightButton(image: Image(systemName: "plus")) { showingNew = true }
+        .setNavigationBarBackgroundColor(Color(.systemBackground))
+    }
+}
+```
+
+> `LCENavigationState` (the `@Published` backing store) and the reflection-based
+> `Text.string` / tag helpers in `View+Ext.swift` are `internal` implementation
+> details — not part of the public API.
+
+</details>
+
+---
+
+## View helpers
+
+There are currently no public standalone `View` extensions — the `getTag` /
+`extractTag` reflection utilities in `SwiftUI/View+Ext.swift` are `internal` and
+exist only to support `LCENavigationView`'s subtitle handling.
diff --git a/Documentation/UIKit.md b/Documentation/UIKit.md
new file mode 100644
index 0000000..eddf114
--- /dev/null
+++ b/Documentation/UIKit.md
@@ -0,0 +1,815 @@
+# LCEssentials — UIKit
+
+UIKit-era helpers: programmatic layout & constraints, view/control extensions,
+navigation, table/collection helpers, and drop-in components (image picker, image
+zoom, snackbar, GIF loading).
+
+Foundation/value-type helpers are in [Extensions.md](Extensions.md); SwiftUI
+helpers in [SwiftUI.md](SwiftUI.md).
+
+Every section is a collapsible block — click a heading to expand it.
+
+## Contents
+
+- [Layout & Constraints](#layout--constraints)
+- [Views & Controls](#views--controls)
+- [Navigation & Controllers](#navigation--controllers)
+- [Collections & Tables](#collections--tables)
+- [Media & Components](#media--components)
+
+---
+
+## Layout & Constraints
+
+<details>
+<summary><b>UIView</b> — programmatic constraints, chainable anchors</summary>
+
+### `enum AnchorType`
+The anchor to pin when using `setConstraintsTo`. Cases: `all`, `top`, `bottom`,
+`leading`, `trailing`, `left`, `right`, `centerX`, `centerY`, `width`, `heigth`
+*(sic)*, `topToBottom`, `bottomToTop`, `leadingToTrailing`, `trailingToLeading`,
+plus `…GreaterThanOrEqualTo` / `…LessThanOrEqualTo` variants.
+
+### `@discardableResult func setConstraintsTo(parentView: UIView, anchorType: AnchorType, value: CGFloat, safeArea: Bool = false) -> Self`
+Activate one constraint against `parentView`. Remembers `parentView` (in
+`viewReference`) so follow-up calls can omit it. `safeArea: true` pins top/bottom
+to the safe-area guide (iOS 11+).
+
+```swift
+card.addSubview(label)
+label.setConstraintsTo(parentView: card, anchorType: .top, value: 12, safeArea: false)
+     .setConstraints(.leading, 16)
+     .setConstraints(.trailing, -16)
+```
+
+### `@discardableResult func setConstraintsTo(_ parentView:_ anchorType:_ value:_ safeArea: Bool = false) -> Self`
+Positional-argument shorthand for the above.
+
+### `@discardableResult func setConstraintsTo(anchorType: AnchorType, value: CGFloat, safeArea: Bool = false) -> UIView`
+Reuse the last `parentView` (`viewReference`). **Traps** with `fatalError` if no
+`parentView` was set first.
+
+### `@discardableResult func setConstraints(_ anchorType: AnchorType, _ value: CGFloat, _ safeArea: Bool = false) -> UIView`
+Positional shorthand for the reuse form — the one you chain.
+
+### `func setConstraints(_ toScrollView: UIScrollView, direction: UICollectionView.ScrollDirection = .vertical)`
+Pin `self` as the single content view of a scroll view (edges + matching
+width/height, with a low-priority constraint on the scroll axis). Traps if
+`self` is itself a `UIScrollView`.
+
+```swift
+scrollView.addSubview(content)
+content.setConstraints(scrollView, direction: .vertical)
+```
+
+### Constraint accessors
+`widthConstraint`, `heightConstraint`, `leadingConstraint`, `trailingConstraint`,
+`topConstraint`, `bottomConstraint`, `centerXConstraints`, `centerYConstraints` —
+the first matching `NSLayoutConstraint` found by walking up the hierarchy.
+
+```swift
+box.widthConstraint?.constant = 120
+UIView.animate(withDuration: 0.2) { self.view.layoutIfNeeded() }
+```
+
+### `func findConstraint(attribute: NSLayoutConstraint.Attribute, for view: UIView) -> NSLayoutConstraint?`
+Search self and ancestors for a constraint on `attribute` involving `view`.
+
+### `func constraints(on anchor:) -> [NSLayoutConstraint]`
+Constraints touching a given `NSLayoutYAxisAnchor` / `XAxisAnchor` / `Dimension` of `self`.
+
+### `@discardableResult func setHeight(size:) -> Self` / `setHeight(min:)` / `setWidth(size:)` / `setWidth(min:)`
+Activate a fixed or minimum dimension constraint.
+
+```swift
+avatar.setWidth(size: 44).setHeight(size: 44)
+```
+
+### `func setWidth(_ toView: UIView? = nil, constant: CGFloat, _ multiplier: CGFloat = 0) -> Self` / `setHeight(...)`
+Dimension relative to another view (`multiplier`) or fixed (`multiplier == 0`).
+
+### Frame setters
+`setX(x:)`, `setY(y:)`, `setFrameWidth(width:)`, `setFrameHeight(height:)` — mutate
+`self.frame` directly (manual layout, not Auto Layout).
+
+</details>
+
+<details>
+<summary><b>UIView</b> — hierarchy, appearance, effects</summary>
+
+### `static var className: String`
+`String(describing: self)`.
+
+```swift
+UIButton.className   // "UIButton"
+```
+
+### `func addSubview(_ subview:, translatesAutoresizingMaskIntoConstraints: Bool = false)` / `addSubviews(_ subviews: [UIView], …)`
+Add a view (or many) and set `translatesAutoresizingMaskIntoConstraints` in one call.
+
+```swift
+view.addSubviews([header, body, footer])   // all ready for Auto Layout
+```
+
+### `func subviews<T>(ofType _: T.Type) -> [T]`
+All descendants of a type, recursively.
+
+```swift
+formView.subviews(ofType: UITextField.self)
+```
+
+### `func findAView<T>(_ ofType: T.Type) -> T?`
+First descendant of a type.
+
+### `var parentViewController: UIViewController?`
+Nearest owning view controller (walks the responder chain).
+
+### `var borderColor: UIColor?` / `var borderWidth: CGFloat` / `var cornerRadius: CGFloat`
+Layer border/corner shortcuts (`cornerRadius` also sets `masksToBounds`).
+
+```swift
+card.cornerRadius = 12
+card.borderWidth = 1
+card.borderColor = .separator
+```
+
+### `func setRadius(top: Bool, bottom: Bool, radius: CGFloat = 8)`
+Round only the top and/or bottom corners.
+
+```swift
+sheet.setRadius(top: true, bottom: false, radius: 16)
+```
+
+### `func applyShadow(color:offSet:radius:opacity:shouldRasterize: Bool = true, rasterizationScaleTo: = UIScreen.main.scale)` / `func removeShadow()`
+Layer shadow with rasterisation on by default.
+
+```swift
+card.applyShadow(color: .black, offSet: CGSize(width: 0, height: 2),
+                 radius: 6, opacity: 0.15)
+```
+
+### `func insertBlurView(style: UIBlurEffect.Style, color: UIColor = .black, alpha: CGFloat = 0.9)`
+Insert a full-bleed `UIVisualEffectView` behind the content.
+
+### `func drawCircle(inCoord x:y:with radius:strokeColor: = .red, fillColor: = .gray, isEmpty: Bool = false) -> [String: Any]`
+Add a circular `CAShapeLayer`; returns `["path": UIBezierPath, "layer": CAShapeLayer]`.
+
+### `var isRightToLeft: Bool`
+Effective RTL layout direction.
+
+### `var screenshot: UIImage?` / `func asImage() -> UIImage`
+Render the view to an image (`screenshot` via the legacy context, `asImage` via `UIGraphicsImageRenderer`).
+
+```swift
+let png = chartView.asImage().pngData()
+```
+
+### `var globalPoint: CGPoint?` / `var globalFrame: CGRect?` / `var absolutePosition: CGRect`
+Origin/frame converted to window coordinates.
+
+### `func fadeIn(withDuration: TimeInterval = 1, withDelay: TimeInterval = 0, completionHandler: @escaping (Bool) -> Void)` / `func fadeOut(...)`
+Animate `alpha` to 1 / 0. *(Completion-handler API — pre-dates async/await.)*
+
+```swift
+overlay.fadeOut { _ in overlay.removeFromSuperview() }
+```
+
+### `var viewReference: UIView?`
+Scratch reference used internally by the chained `setConstraintsTo` calls.
+
+</details>
+
+<details>
+<summary><b>GradientOrientation / EnumBorderSide</b></summary>
+
+### `enum GradientOrientation`
+`topRightBottomLeft`, `topLeftBottomRight`, `horizontal`, `vertical` — maps to a
+`CAGradientLayer` start/end point pair. Passed to gradient helpers elsewhere in
+the package.
+
+### `enum EnumBorderSide`
+`top`, `bottom`, `left`, `right` — which edge to draw a single-side border on.
+
+</details>
+
+<details>
+<summary><b>UIStackView</b> — convenience init, bulk arranged-subview ops (iOS 9+)</summary>
+
+### `convenience init(arrangedSubviews: [UIView]? = nil, axis: = .vertical, spacing: = 0, alignment: = .fill, distribution: = .fill, layoutMargins: = .zero, isMarginsRelative: Bool = true)`
+One-call configured stack view.
+
+```swift
+let stack = UIStackView(arrangedSubviews: [title, subtitle],
+                        axis: .vertical, spacing: 4)
+```
+
+### `func addArrangedSubviews(_ views: [UIView], translateAutoresizing: Bool = false)`
+Add many arranged subviews, setting their autoresizing flag.
+
+### `func removeAllArrangedSubviews(deactivateConstraints: Bool = true)`
+Remove and dispose every arranged subview.
+
+### `func removeSubview(view: UIView, deactivateConstraints: Bool = true)`
+Remove one arranged subview (optionally deactivating its constraints and removing from the hierarchy).
+
+### `func addSpace(_ size: CGFloat, backgroundColor: UIColor = .clear)`
+Insert a fixed-size spacer view sized along the stack's axis.
+
+```swift
+stack.addArrangedSubviews([row1, row2])
+stack.addSpace(24)
+stack.addArrangedSubview(row3)
+```
+
+</details>
+
+> `NSLayoutConstraint` helpers (`constraintWithMultiplier`, `matches(view:anchor:)`)
+> and `[NSLayoutConstraint].filtered(view:anchor:)` are `internal` — used by the
+> `UIView.constraints(on:)` accessors above, not called directly.
+
+## Views & Controls
+
+<details>
+<summary><b>UIButton</b> — per-state accessors, all-state setters</summary>
+
+### Per-state properties
+`imageForNormal` / `imageForHighlighted` / `imageForSelected` / `imageForDisabled`,
+`titleForNormal` / `…Highlighted` / `…Selected` / `…Disabled`,
+`titleColorForNormal` / `…Highlighted` / `…Selected` / `…Disabled` — get/set
+shortcuts for the matching `UIControl.State` (also `@IBInspectable`).
+
+```swift
+button.titleForNormal = "Save"
+button.titleColorForDisabled = .tertiaryLabel
+```
+
+### `func setTitleForAllStates(_:)` / `func setTitleColorForAllStates(_:)` / `func setImageForAllStates(_:)`
+Apply one value to `.normal`, `.selected`, `.highlighted`, `.disabled` at once.
+
+```swift
+button.setTitleColorForAllStates(.white)
+```
+
+### `func centerTextAndImage(spacing: CGFloat)`
+Balance title/image edge insets so text + icon sit centred with `spacing` between them.
+
+```swift
+button.centerTextAndImage(spacing: 8)
+```
+
+</details>
+
+<details>
+<summary><b>UILabel</b></summary>
+
+### `func lineNumbers() -> Int`
+Rendered line count at the current width.
+
+```swift
+if bodyLabel.lineNumbers() > 3 { showMoreButton() }
+```
+
+### `var getEstimatedHeight: CGFloat`
+Height the label would need to show its full text/attributed text unclipped.
+
+</details>
+
+<details>
+<summary><b>UITextField</b></summary>
+
+### `var placeholderColor: UIColor`
+Get/set the placeholder text colour (rebuilds `attributedPlaceholder`; setter is a
+no-op if no placeholder text is set).
+
+```swift
+field.placeholder = "Email"
+field.placeholderColor = .secondaryLabel
+```
+
+### `func addPaddingLeft(_ padding: CGFloat)`
+Inset the text from the left with an empty spacer view.
+
+### `func addPaddingLeftIcon(_ image: UIImage, padding: CGFloat)`
+Left view = an icon plus trailing padding.
+
+```swift
+field.addPaddingLeftIcon(UIImage(systemName: "magnifyingglass")!, padding: 8)
+```
+
+</details>
+
+<details>
+<summary><b>UIImageView</b> (<code>@MainActor</code>)</summary>
+
+### `func changeColorOfImage(_ color: UIColor, image: UIImage?) -> UIImageView`
+Set a template-rendered image tinted to `color`; returns `self`.
+
+```swift
+iconView.changeColorOfImage(.systemBlue, image: UIImage(named: "star"))
+```
+
+### `var encodeToBase64: String?`
+JPEG (quality 0.6) of the current image as a Base64 string.
+
+### `func addAspectRatioConstraint()` / `func removeAspectRatioConstraint()`
+Add / remove a width-to-height constraint matching the current image's ratio.
+
+```swift
+photoView.image = photo
+photoView.addAspectRatioConstraint()
+```
+
+</details>
+
+<details>
+<summary><b>UIImage</b> — recolour, resize, thumbnails, masks, init</summary>
+
+### `func imageWithColor(color: UIColor) -> UIImage` / `func tintImage(color: UIColor) -> UIImage`
+Return a copy filled / tinted with `color` (keeps the alpha shape).
+
+```swift
+let redIcon = icon.tintImage(color: .systemRed)
+```
+
+### `func backgroundColorTransparent(initialColor: UIColor, finalColor: UIColor) -> UIImage?`
+Make pixels in a colour range transparent.
+
+### `class func outlinedEllipse(size: CGSize, color: UIColor, lineWidth: CGFloat = 1) -> UIImage?`
+Generate a stroked-ellipse image.
+
+```swift
+UIImage.outlinedEllipse(size: CGSize(width: 24, height: 24), color: .label)
+```
+
+### `func resizeImage(newWidth: CGFloat) -> UIImage`
+Scale to `newWidth`, keeping the aspect ratio.
+
+### `func createThumbnail(_ maxPixelSize: UInt) -> UIImage`
+Fast down-sampled thumbnail via `CGImageSource`.
+
+```swift
+let thumb = fullImage.createThumbnail(200)
+```
+
+### `func maskWithAlphaImage(maskImage: UIImage) -> UIImage`
+Use another image's alpha as a mask.
+
+### `func isAnimated() -> Bool`
+Whether the image has more than one frame.
+
+### `init?(base64String: String, scale: CGFloat = 1)`
+Decode a Base64 string to an image.
+
+### `init(view: UIView)` — *`@MainActor`*
+Rasterise a view into an image.
+
+```swift
+let snapshot = UIImage(view: cardView)
+```
+
+</details>
+
+<details>
+<summary><b>UIColor</b> — hex, components</summary>
+
+### `convenience init(hex: String)`
+Parse `#RGB`, `#RGBA`, `#RRGGBB`, or `#RRGGBBAA` (with or without `#`).
+
+```swift
+view.backgroundColor = UIColor(hex: "#1E88E5")
+UIColor(hex: "FF0000CC")   // red at 80% alpha
+```
+
+### `var hexString: String?`
+`#RRGGBB` (or `#RRGGBBAA` when alpha < 1).
+
+### `var redValue` / `var greenValue` / `var blueValue` / `var alphaValue`
+Individual channel values (`CGFloat`, via `CIColor`).
+
+```swift
+UIColor.systemBlue.redValue   // 0.0…1.0
+```
+
+</details>
+
+<details>
+<summary><b>UIScrollView</b> — snapshot, visible rect, paged scrolling</summary>
+
+### `var snapshot: UIImage?`
+Image of the **entire** content size (not just the visible part) — works on
+`UITableView` / `UICollectionView` too.
+
+### `var visibleRect: CGRect`
+The currently visible content region.
+
+### `var offsetInPage: CGFloat`
+Fractional position within the current page height (`0.0`…`1.0`).
+
+### `func scrollUp(animated:)` / `scrollDown(animated:)` / `scrollLeft(animated:)` / `scrollRight(animated:)`
+Move one page (respects `isPagingEnabled`). `animated` defaults to `true`.
+
+```swift
+nextButton.onTap = { scrollView.scrollRight() }
+```
+
+### `enum orientation`
+`horizontal` / `vertical` — helper enum used by scroll utilities.
+
+</details>
+
+<details>
+<summary><b>UITapGestureRecognizer</b></summary>
+
+### `func didTapAttributedTextInLabel(label: UILabel, textToTouch: String) -> Bool`
+Whether the tap landed on a given substring of a label's attributed text — for
+making part of a label tappable.
+
+```swift
+@objc func handleTap(_ g: UITapGestureRecognizer) {
+    if g.didTapAttributedTextInLabel(label: termsLabel, textToTouch: "Terms of Use") {
+        openTerms()
+    }
+}
+```
+
+</details>
+
+## Navigation & Controllers
+
+<details>
+<summary><b>UINavigationController</b> — completion-handler push/pop, transparent bar</summary>
+
+### `func pushViewController(_:animated: Bool = true, completion: (() -> Void)? = nil)`
+### `func popViewController(animated: Bool = true, _ completion: (() -> Void)? = nil)`
+### `func popToViewController(_:animated: Bool = true, _ completion: (() -> Void)? = nil)`
+The standard transitions with a completion block (wrapped in a `CATransaction`).
+
+```swift
+navigationController?.pushViewController(detail) {
+    print("detail is on screen")
+}
+```
+
+### `func pushViewController(_:hidesBottomBar: Bool = false, animated: Bool = true)` — *not tvOS*
+Push while setting `hidesBottomBarWhenPushed`.
+
+### `func makeTransparent(withTint tint: UIColor = .white)`
+Clear background + shadow, translucent, tinted bar/title.
+
+```swift
+navigationController?.makeTransparent(withTint: .label)
+```
+
+</details>
+
+<details>
+<summary><b>UIViewController</b> — state, instantiation, dismissal, toasts, keyboard, observers</summary>
+
+### `var isVisible: Bool` / `var isLoaded: Bool`
+View is loaded **and** in a window. (`isLoaded` is an alias.)
+
+### `var isModal: Bool`
+Whether the controller is presented modally (vs. pushed).
+
+### `static var className: String` / `static var identifier: String` / `static var segueID: String`
+`"MyVC"`, `"idMyVC"`, `"idSegueMyVC"`.
+
+### `static func instantiate<T>(storyBoard: String, identifier: String? = nil, bundle: Bundle? = …) -> T`
+Load a controller from a storyboard by (default) `T.identifier`.
+
+```swift
+let vc: ProfileVC = ProfileVC.instantiate(storyBoard: "Main")
+```
+
+### `static func instatiate<T>(nibName: String, bundle: Bundle? = nil) -> T` *(sic — "instatiate")*
+Load from a nib and force an initial layout pass.
+
+### `func present(viewControllerToPresent:completion: @escaping () -> Void)`
+`present(_:animated:)` with a completion block.
+
+### `func closeController(jumpToController: UIViewController? = nil, completion: @escaping () -> Void)`
+Dismiss if modal, else pop (to `jumpToController` if given), then call `completion`.
+
+```swift
+closeController { self.refreshList() }
+```
+
+### `func show(toastWith message:, font: = system 12, toastPosition: ToastPosition, backgroundColor: = .black, textColor: = .white, duration: = 3)`
+Show a temporary rounded toast label. `ToastPosition` is `.top` / `.down`
+(notch-aware at the top).
+
+```swift
+show(toastWith: "Saved", toastPosition: .down)
+```
+
+### `func addNotificationObserver(name:selector:)` / `func removeNotificationObserver(name:)` / `func removeNotificationsObserver()`
+`NotificationCenter` registration shortcuts (last one removes all).
+
+### `@objc func dismissSystemKeyboard(_ sender: UITapGestureRecognizer)`
+Ready-made selector for a tap-to-dismiss-keyboard gesture.
+
+```swift
+view.addGestureRecognizer(UITapGestureRecognizer(target: self,
+    action: #selector(dismissSystemKeyboard(_:))))
+```
+
+</details>
+
+<details>
+<summary><b>UITabBarController</b> — badges, animated tab switching</summary>
+
+### `func setBadges(badgeValues: [Int], font: UIFont = Helvetica-Light 11)`
+Set numeric badges for every tab at once (`0` = no badge). Custom-drawn
+(`CustomTabBadge` label), so they position above each tab item.
+
+```swift
+tabBarController?.setBadges(badgeValues: [0, 3, 0, 12])
+```
+
+### `func addBadge(index:value:color:font:)`
+Add a single custom badge.
+
+### `func setSelectedView(atIndex:withAnimation: Bool = false, completion:)`
+Select a tab (pops that tab's nav stack to root first).
+
+### `func setSelectedView(withNoPop atIndex:withAnimation: Bool = false, completion:)`
+Same, without popping to root.
+
+### `func animateToTab(toIndex: Int)`
+Slide-transition between tabs.
+
+### `func changeViewControllerToItem(withViewController:Item:)`
+Replace a tab's root controller then switch to that tab.
+
+```swift
+tabBarController?.changeViewControllerToItem(withViewController: NewHome(), Item: 0)
+```
+
+### `class CustomTabBadge: UILabel`
+The badge label type used above (`init(font:)`).
+
+</details>
+
+<details>
+<summary><b>UIApplication</b> — environment, app info, open URL</summary>
+
+### `enum Environment` + `static var inferredEnvironment: Environment`
+`.debug` / `.testFlight` / `.appStore`, inferred from build config, simulator, and
+the provisioning/receipt files.
+
+```swift
+if UIApplication.inferredEnvironment == .appStore { enableAnalytics() }
+```
+
+### `static var displayName: String?` / `static var buildNumber: String?` / `static var version: String?`
+Bundle info values. (`LCEssentials.appVersion` etc. forward to these.)
+
+### `static func openURL(urlStr: String)`
+Open a URL string if it can be opened.
+
+```swift
+UIApplication.openURL(urlStr: "https://loverde.com.br")
+```
+
+</details>
+
+<details>
+<summary><b>UIResponder</b></summary>
+
+### `var getParentViewController: UIViewController?`
+Walk the responder chain to the owning view controller.
+
+```swift
+someView.getParentViewController?.present(alert, animated: true)
+```
+
+</details>
+
+<details>
+<summary><b>UIDevice</b> — notch metrics, model name</summary>
+
+### `static var topNotch: CGFloat` / `static var bottomNotch: CGFloat` / `static var hasNotch: Bool`
+Safe-area top/bottom insets and whether the device has a notch / Dynamic Island.
+
+```swift
+let headerY: CGFloat = UIDevice.hasNotch ? 44 : 20
+```
+
+### `var modelName: String`
+Marketing name from the hardware identifier (`"iPhone 15 Pro"`, `"iPad Air (5th generation)"`, …); falls back to the raw identifier for unknown devices. Reads `SIMULATOR_MODEL_IDENTIFIER` on the simulator.
+
+```swift
+UIDevice.current.modelName   // "iPhone 16 Pro"
+```
+
+</details>
+
+## Collections & Tables
+
+<details>
+<summary><b>UITableView</b> — typed dequeue, safe indexing, cell animations</summary>
+
+### `func dequeueReusableCell<T: UITableViewCell>(withClass name: T.Type) -> T` / `…(withClass:for indexPath:) -> T`
+Dequeue a cell by its class name as the identifier. **Traps** if the cell isn't registered.
+
+```swift
+let cell = tableView.dequeueReusableCell(withClass: OrderCell.self, for: indexPath)
+```
+
+### `func dequeueReusableHeaderFooterView<T: UITableViewHeaderFooterView>(withClass name: T.Type) -> T`
+Same, for section header/footer views.
+
+### `func dequeueCell<T: UITableViewCell>(indexPath: IndexPath) -> T`
+Dequeue using `T.identifier` (`"id" + class name`).
+
+### `func reloadData(_ completion: @escaping () -> Void)`
+`reloadData()` with a callback for when layout settles.
+
+### `func isValidIndexPath(_:) -> Bool`
+Bounds check against the current section/row counts.
+
+### `func safeScrollToRow(at:at scrollPosition:animated:)`
+`scrollToRow` that silently no-ops for an out-of-range index path.
+
+### `func makeMoveUpWithFadeAnimation(rowHeight:duration:delayFactor:) -> UITableViewCellAnimation`
+Build a staggered slide-up + fade-in cell animation closure.
+
+```swift
+let animator = UITableViewAnimator(
+    animation: tableView.makeMoveUpWithFadeAnimation(rowHeight: 64, duration: 0.35, delayFactor: 0.03)
+)
+
+func tableView(_ t: UITableView, willDisplay cell: UITableViewCell, forRowAt ip: IndexPath) {
+    animator.animate(cell: cell, at: ip, in: t)
+}
+```
+
+### `typealias UITableViewCellAnimation = (UITableViewCell, IndexPath, UITableView) -> Void`
+### `class UITableViewAnimator`
+`init(animation:)` + `animate(cell:at:in:)` — runs a cell animation closure.
+
+### `UITableViewCell.identifier` / `UITableViewCell.prepareDisclosureIndicator()`
+`"id" + class name`; and re-tint the disclosure chevron to a template image so it
+picks up `tintColor`.
+
+</details>
+
+<details>
+<summary><b>UICollectionView</b> — setup, counts, safe indexing, carousel layout</summary>
+
+### `static var identifier: String`
+`"id" + class name`.
+
+### `func setupCollectionView(flowLayout: = UICollectionViewFlowLayout(), spacings: = 0, direction: = .horizontal, edgesInset: = .zero, allowMulpleSelection: Bool = false, automaticSize: CGSize? = nil)`
+Configure layout spacing/direction/insets, multi-selection, and self-sizing in one call.
+
+```swift
+collectionView.setupCollectionView(spacings: 8, direction: .vertical,
+                                   edgesInset: .init(top: 12, left: 16, bottom: 12, right: 16))
+```
+
+### `func reloadData(_ completion: @escaping () -> Void)`
+Reload with a completion callback.
+
+### `func numberOfItems() -> Int`
+Total items across all sections.
+
+### `var lastSection: Int` / `var indexPathForLastItem: IndexPath?` / `func indexPathForLastItem(inSection:) -> IndexPath?`
+Last section index; index path of the last item overall or in a section.
+
+### `func isValidIndexPath(_:) -> Bool` / `func safeScrollToItem(at:at scrollPosition:animated:)`
+Bounds check; scroll that no-ops on an invalid index path.
+
+### `enum CollectionViewFlowLayoutSpacingMode`
+`.fixed(spacing:)` / `.overlap(visibleOffset:)` — spacing strategy for the carousel layout below.
+
+### `open class CollectionViewFlowLayout: UICollectionViewFlowLayout`
+A centred, paginated "cover-flow" style layout: the centred item is full size,
+side items scale and fade. Tunables: `sideItemScale` (0.6), `sideItemAlpha`
+(0.6), `sideItemShift` (0), `spacingMode` (`.fixed(40)`).
+
+```swift
+let layout = CollectionViewFlowLayout()
+layout.itemSize = CGSize(width: 240, height: 320)
+layout.sideItemScale = 0.7
+layout.spacingMode = .overlap(visibleOffset: 30)
+collectionView.collectionViewLayout = layout
+```
+
+</details>
+
+## Media & Components
+
+<details>
+<summary><b>LCSnackBarView</b> — in-app notification banner</summary>
+
+A chainable banner shown from the top or bottom of a controller. Configure with
+`configure(...)` calls, then `present()`.
+
+### `init(style: LCSnackBarViewType = .default, orientation: LCSnackBarOrientation = .top, delegate: LCSnackBarViewDelegate? = nil)`
+
+### Enums
+- `LCSnackBarViewType` — `.default` (rectangular) / `.rounded`
+- `LCSnackBarOrientation` — `.top` / `.bottom`
+- `LCSnackBarTimer: CGFloat` — `.infinity` (0, manual dismiss), `.minimum` (2s), `.medium` (5s), `.maximum` (10s)
+
+### Configuration (each returns `Self`)
+| Method | Sets |
+|---|---|
+| `configure(text: String)` | the message |
+| `configure(textColor: UIColor)` | text colour |
+| `configure(textFont: UIFont, alignment: NSTextAlignment = .center)` | font + alignment |
+| `configure(backgroundColor: UIColor)` | banner background |
+| `configure(exibition timer: LCSnackBarTimer)` | how long it stays |
+| `configure(imageIconBefore icon: UIImageView, withTintColor: UIColor? = nil)` | leading icon |
+
+### `func present(completion: (() -> Void)? = nil)`
+Show on the top-most view controller.
+
+### `weak var delegate: LCSnackBarViewDelegate?`
+`snackbar(didStartExibition:)`, `snackbar(didTouchOn:)`, `snackbar(didEndExibition:)` — all optional.
+
+### Full example
+
+```swift
+LCSnackBarView(style: .rounded, orientation: .bottom)
+    .configure(text: "Profile saved")
+    .configure(backgroundColor: .systemGreen)
+    .configure(exibition: .minimum)
+    .present()
+```
+
+</details>
+
+<details>
+<summary><b>ImagePickerController</b> — camera / photo-library picker with permissions</summary>
+
+Wraps `UIImagePickerController`, handling camera & photo-library authorization
+(including the "go to Settings" path) and presenting a source-choice alert.
+
+### `init()`
+### `weak var delegate: ImagePickerControllerDelegate?`
+### `var isEditable: Bool` — allow in-picker cropping (default `false`)
+### `func openImagePicker()`
+Check permissions, then present the camera/library choice.
+
+### `protocol ImagePickerControllerDelegate: AnyObject`
+`imagePicker(didSelect image: UIImage?)` — the picked (or edited) image, or `nil` on cancel/failure.
+
+```swift
+let picker = ImagePickerController()
+picker.delegate = self
+picker.isEditable = true
+present(picker, animated: false) { picker.openImagePicker() }
+
+// ImagePickerControllerDelegate
+func imagePicker(didSelect image: UIImage?) {
+    avatarView.image = image
+}
+```
+
+</details>
+
+<details>
+<summary><b>ImageZoomController</b> — full-screen pinch-zoom / pan viewer</summary>
+
+### `init(_ withImage: UIImage)`
+### `var minimumZoomScale: CGFloat` (default `1.0`) / `var maximumZoomScale: CGFloat` (default `6.0`)
+### `var addGestureToDismiss: Bool` (default `true`) — drag down to close
+### `weak var delegate: ImageZoomControllerDelegate?`
+### `func present(completion: (() -> Void)? = nil)` / `func dismiss(completion: (() -> Void)? = nil)`
+Present from / dismiss to the top-most controller.
+
+### `@objc protocol ImageZoomControllerDelegate`
+`imageZoomController(controller:didZoom:)`, `imageZoomController(controller:didClose:)` — both optional.
+
+```swift
+let viewer = ImageZoomController(photo)
+viewer.maximumZoomScale = 4
+viewer.present()
+```
+
+</details>
+
+<details>
+<summary><b>GifHelper</b> — animated GIF loading</summary>
+
+### `UIImageView.loadGif(name: String)` / `UIImageView.loadGif(asset: String)` *(iOS 9+)*
+Decode a bundled `.gif` (or an asset-catalog data set) off the main thread and
+assign the resulting animated `UIImage`.
+
+```swift
+bannerView.loadGif(name: "loading")        // loading.gif in the bundle
+bannerView.loadGif(asset: "confetti")      // NSDataAsset "confetti"
+```
+
+### `UIImage.gif(data: Data) -> UIImage?` / `gif(url: String) -> UIImage?` / `gif(name: String) -> UIImage?` / `gif(asset: String) -> UIImage?`
+Build an animated `UIImage` from GIF bytes / a URL string / a bundled file / an
+asset-catalog entry. Frame delays are honoured (via the GCD of per-frame delays).
+
+```swift
+let spinner = UIImage.gif(name: "spinner")
+imageView.image = spinner
+```
+
+</details>
diff --git a/README.md b/README.md
index f252ffe..ae18fd9 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,17 @@ This is a repository of essential scripts written in Swift for Loverde Co. used
 
 ## Features
 - [x] Many usefull scripts extensions
-- [x] `API` — typed async networking + multipart uploads. See **[Documentation/API.md](Documentation/API.md)**
+- [x] `API` — typed async networking + multipart uploads
+- [x] SwiftUI components (`LCENavigationView`) and UIKit-era helpers
+
+## Documentation
+
+| Guide | Covers |
+| --- | --- |
+| **[API.md](Documentation/API.md)** | `API` networking — requests, multipart uploads, client certificates, error handling, and why it beats a hand-rolled `URLSession` |
+| **[Extensions.md](Documentation/Extensions.md)** | Foundation / value-type / string / collection / numeric / date / crypto extensions and the `LCEssentials` namespace |
+| **[SwiftUI.md](Documentation/SwiftUI.md)** | SwiftUI components and `View` helpers |
+| **[UIKit.md](Documentation/UIKit.md)** | Programmatic layout & constraints, view/control extensions, navigation, tables, and drop-in components |
 
 
 Installation
@@ -80,6 +90,5 @@ Any question or doubts, please send thru email
 Daniel Arantes Loverde - <daniel@loverde.com.br>
 
 [![Alt text](https://loverde.com.br/_signature/loverde_github_mail.gif "My Resume")](https://github.com/loverde-co/resume/)
-[![Alt text](https://loverde.com.br/_signature/loverde_github_mail.gif "Loverde Co. Github")](https://github.com/loverde-co)
 
 Autor: Daniel Arantes Loverde