performance nit-picks for minify logic

Author: RandomHashTags

Sources/HTMLKitUtilities/HTMLElementType.swift

@@ -146,4 +146,12 @@ public enum HTMLElementType : String, CaseIterable, Sendable {
             return false
         }
     }
+
+    @inlinable
+    public var tagName : String {
+        switch self {
+        case .variable: return "var"
+        default: return rawValue
+        }
+    }
 }

Sources/HTMLKitUtilities/HTMLKitUtilities.swift

@@ -107,9 +107,14 @@ extension StringLiteralExprSyntax {
     }
 }
 extension Collection {
+    /// - Returns: The element at the given index, checking if the index is within bounds (`>= startIndex && < endIndex`).
     package func get(_ index: Index) -> Element? {
         return index >= startIndex && index < endIndex ? self[index] : nil
     }
+    /// - Returns: The element at the given index, only checking if the index is less than `endIndex`.
+    package func getPositive(_ index: Index) -> Element? {
+        return index < endIndex ? self[index] : nil
+    }
 }
 extension LabeledExprListSyntax {
     package func get(_ index: Int) -> Element? {

Sources/HTMLKitUtilities/Minify.swift

@@ -5,58 +5,49 @@
 //  Created by Evan Anderson on 3/31/25.
 //
 
-import SwiftSyntax
-
 extension HTMLKitUtilities {
-    static let defaultPreservedWhitespaceTags:Set<String> = Set([
-        "a", "abbr",
-        "b", "bdi", "bdo", "button",
-        "cite", "code",
-        "data", "dd", "dfn", "dt",
-        "em",
-        "h1", "h2", "h3", "h4", "h5", "h6",
-        "i",
-        "kbd",
-        "label", "li",
-        "mark",
-        "p",
-        "q",
-        "rp",
-        "rt",
-        "ruby",
-        "s", "samp", "small", "span", "strong", "sub", "sup",
-        "td", "time", "title", "tr",
-        "u",
-        "var",
-        "wbr"
-    ].map { "<" + $0 + ">" })
+    static let defaultPreservedWhitespaceTags:Set<Substring> = Set(Array<HTMLElementType>(arrayLiteral:
+        .a, .abbr,
+        .b, .bdi, .bdo, .button,
+        .cite, .code,
+        .data, .dd, .dfn, .dt,
+        .em,
+        .h1, .h2, .h3, .h4, .h5, .h6,
+        .i,
+        .kbd,
+        .label, .li,
+        .mark,
+        .p,
+        .q,
+        .rp,
+        .rt,
+        .ruby,
+        .s, .samp, .small, .span, .strong, .sub, .sup,
+        .td, .time, .title, .tr,
+        .u,
+        .variable,
+        .wbr
+    ).map { "<" + $0.tagName + ">" })
 
     /// Removes whitespace between elements.
     public static func minify(
         html: String,
-        preservingWhitespaceForTags: Set<String> = []
+        preservingWhitespaceForTags: Set<Substring> = []
     ) -> String {
-        var preservedWhitespaceTags:Set<String> = Self.defaultPreservedWhitespaceTags
-        preservedWhitespaceTags.formUnion(preservingWhitespaceForTags)
         var result:String = ""
         result.reserveCapacity(html.count)
         let tagRegex = "[^/>]+"
-        let openElementRegex = "(<\(tagRegex)>)"
-        let openElementRanges = html.ranges(of: try! Regex(openElementRegex))
-
-        let closeElementRegex = "(</\(tagRegex)>)"
-        let closeElementRanges = html.ranges(of: try! Regex(closeElementRegex))
+        let openElementRanges = html.ranges(of: try! Regex("(<\(tagRegex)>)"))
+        let closeElementRanges = html.ranges(of: try! Regex("(</\(tagRegex)>)"))
 
         var openingRangeIndex = 0
         var ignoredClosingTags:Set<Range<String.Index>> = []
         for openingRange in openElementRanges {
             let tag = html[openingRange]
             result += tag
-            let closure:(Character) -> Bool = preservedWhitespaceTags.contains(String(tag)) ? { _ in true } : {
-                !($0.isWhitespace || $0.isNewline)
-            }
+            let closure = Self.defaultPreservedWhitespaceTags.contains(tag) || preservingWhitespaceForTags.contains(tag) ? appendAll : appendIfPreserved
             let closestClosingRange = closeElementRanges.first(where: { $0.lowerBound > openingRange.upperBound })
-            if let nextOpeningRange = openElementRanges.get(openingRangeIndex + 1) {
+            if let nextOpeningRange = openElementRanges.getPositive(openingRangeIndex + 1) {
                 var i = openingRange.upperBound
                 var lowerBound = nextOpeningRange.lowerBound
                 if let closestClosingRange {
@@ -68,13 +59,7 @@ extension HTMLKitUtilities {
                     }
                 }
                 // anything after the opening tag, upto the end of the next closing tag
-                while i < lowerBound {
-                    let char = html[i]
-                    if closure(char) {
-                        result.append(char)
-                    }
-                    html.formIndex(after: &i)
-                }
+                closure(html, &i, lowerBound, &result)
                 // anything after the closing tag and before the next opening tag
                 while i < nextOpeningRange.lowerBound {
                     let char = html[i]
@@ -85,12 +70,8 @@ extension HTMLKitUtilities {
                 }
             } else if let closestClosingRange {
                 // anything after the opening tag and before the next closing tag
-                let slice = html[openingRange.upperBound..<closestClosingRange.lowerBound]
-                for char in slice {
-                    if closure(char) {
-                        result.append(char)
-                    }
-                }
+                var i = openingRange.upperBound
+                closure(html, &i, closestClosingRange.lowerBound, &result)
             }
             openingRangeIndex += 1
         }
@@ -101,4 +82,31 @@ extension HTMLKitUtilities {
         }
         return result
     }
+}
+
+// MARK: append
+extension HTMLKitUtilities {
+    fileprivate static func appendAll(
+        html: String,
+        i: inout String.Index,
+        bound: String.Index,
+        result: inout String
+    ) {
+        result += html[i..<bound]
+        i = bound
+    }
+    fileprivate static func appendIfPreserved(
+        html: String,
+        i: inout String.Index,
+        bound: String.Index,
+        result: inout String
+    ) {
+        while i < bound {
+            let char = html[i]
+            if !(char.isWhitespace || char.isNewline) {
+                result.append(char)
+            }
+            html.formIndex(after: &i)
+        }
+    }
 }

Tests/HTMLKitTests/MinifyTests.swift

@@ -12,7 +12,6 @@ import HTMLKit
 
 struct MinifyTests {
     @Test func minifyHTML() {
-        /////
         var expected = "<html><body><p>\ndude&dude </p>r ly<div>what</div></body></html>"
         var result:String = HTMLKitUtilities.minify(html: "\n<html>\n    <body><p>\ndude&dude </p>r ly\n<div>\nwh  at</div></body>\n</html>")
         #expect(expected == result)
@@ -25,7 +24,7 @@ struct MinifyTests {
             <path d="M3 6h18"></path>
             <path d="M19 6v14c0 1-1 2-2 2H7c-1 0-2-1-2-2V6"></path>
             <path d="M8 6V4c0-1 1-2 2-2h4c1 0 2 1 2 2v2"></path></svg>
-        """#, preservingWhitespaceForTags: ["svg", "path", "circle"])
+        """#)
         #expect(expected == result)
     }
 }