@swiftbrowser/swift 0.0.0-stage → 0.1.0

package/Package.swift

@@ -0,0 +1,23 @@
+// swift-tools-version: 6.0
+// The SwiftBrowser Swift package as @swiftbrowser/cli ships it: the SwiftUI
+// shim, Swift Charts, FoundationLite and FoundationBridge, library products only. `Sources/` is
+// copied from the repository's Sources/ at `npm pack` time (sync-sources.mjs);
+// in a repository checkout the CLI uses the repository's own Package.swift.
+import PackageDescription
+
+let package = Package(
+    name: "SwiftBrowser",
+    products: [
+        .library(name: "SwiftUI", targets: ["SwiftUI"]),
+        .library(name: "Charts", targets: ["Charts"]),
+        .library(name: "FoundationLite", targets: ["FoundationLite"]),
+        .library(name: "FoundationBridge", targets: ["FoundationBridge"]),
+    ],
+    targets: [
+        .target(name: "SwiftUI", path: "Sources/SwiftUI"),
+        .target(name: "_FoundationCommon", dependencies: ["SwiftUI"], path: "Sources/_FoundationCommon"),
+        .target(name: "FoundationLite", dependencies: ["SwiftUI", "_FoundationCommon"], path: "Sources/FoundationLite"),
+        .target(name: "FoundationBridge", dependencies: ["SwiftUI", "_FoundationCommon"], path: "Sources/FoundationBridge"),
+        .target(name: "Charts", dependencies: ["SwiftUI"], path: "Sources/Charts"),
+    ]
+)

package/README.md

@@ -1,3 +1,13 @@
-# Temporary Holding Version
+# @swiftbrowser/swift
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The SwiftBrowser Swift package (the `SwiftUI` shim, `Charts`, `FoundationLite`
+for lean builds, `FoundationBridge` for full-Foundation builds and the
+`_FoundationCommon` they share) packaged for npm, so that `@swiftbrowser/cli` builds apps
+against exactly the shim version it was released with. The CLI's generated
+staging package depends on it by path (`swiftPackagePath()`).
+
+In a repository checkout `Sources/` is not here; `swiftPackagePath()` then
+points at the repository root, whose package also declares the example
+executables (so an app named like one of them, `Counter` say, needs this
+package synced: `node packages/swift/sync-sources.mjs`). `npm pack` copies the
+sources in (`prepack`).

package/Sources/Charts/Charts.swift

@@ -0,0 +1,65 @@
+// Swift Charts for SwiftBrowser. The marks, axes and `Chart` itself are
+// defined in the SwiftUI target (Sources/SwiftUI/Charts); this module
+// re-exports them and adds the pieces that need Foundation's `Date` and
+// `Calendar`. See docs/ops-protocol.md, "Phase 7".
+
+@_exported import SwiftUI
+
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+#else
+import Foundation
+#endif
+
+/// Dates plot as seconds since 1970; the chart treats them as UTC
+/// (`Calendar.current` is UTC in the browser).
+extension Date: Plottable {
+    public var _plottableValue: _PlottableValue { .date(timeIntervalSince1970) }
+
+    public init?(_plottableValue value: _PlottableValue) {
+        guard case .date(let seconds) = value else { return nil }
+        self.init(timeIntervalSince1970: seconds)
+    }
+}
+
+/// Calendar bins over a date range: `DateBins(unit: .hour, by: 3, range:)`.
+/// `thresholds` are the bin boundaries, from the range's start (aligned to
+/// `unit`) in steps of `by` units up to and including the first boundary at or
+/// after the range's end.
+public struct DateBins: Sendable {
+    public let unit: Calendar.Component
+    public let stride: Int
+    public let range: ClosedRange<Date>
+    public let thresholds: [Date]
+
+    public init(unit: Calendar.Component, by stride: Int = 1, range: ClosedRange<Date>,
+                calendar: Calendar = .current) {
+        self.unit = unit
+        self.stride = max(1, stride)
+        self.range = range
+        var thresholds: [Date] = []
+        var date = calendar.dateInterval(of: unit, for: range.lowerBound)?.start ?? range.lowerBound
+        while thresholds.count < 10_000 {
+            thresholds.append(date)
+            if date >= range.upperBound { break }
+            guard let next = calendar.date(byAdding: unit, value: self.stride, to: date), next > date else { break }
+            date = next
+        }
+        self.thresholds = thresholds
+    }
+
+    /// Bins over the dates' span.
+    public init(unit: Calendar.Component, by stride: Int = 1, dates: [Date], calendar: Calendar = .current) {
+        let lower = dates.min() ?? Date(timeIntervalSince1970: 0)
+        let upper = dates.max() ?? lower
+        self.init(unit: unit, by: stride, range: lower...upper, calendar: calendar)
+    }
+
+    /// The bin a date falls in (an index into `thresholds`), clamped to the bins.
+    public func index(for date: Date) -> Int {
+        let bins = max(thresholds.count - 1, 1)
+        var index = 0
+        for (i, threshold) in thresholds.enumerated() where date >= threshold { index = i }
+        return min(index, bins - 1)
+    }
+}

package/Sources/FoundationBridge/FoundationBridge.swift

@@ -0,0 +1,77 @@
+/// What the SwiftUI shim needs from the real Foundation, for apps built with
+/// `--foundation full`: the SDK's swift-corelibs Foundation (with ICU data
+/// trimmed by the CLI) instead of FoundationEssentials + FoundationLite.
+///
+/// The shim itself never imports Foundation (that would link its 10 MB into
+/// every lean app), so it is generic over small protocols that this module
+/// conforms Foundation's types to: `IndexSet` for `onDelete` / `onMove` /
+/// `remove(atOffsets:)`, `Date` for `DatePicker`, and `FormatStyle` /
+/// `ParseableFormatStyle` for `Text(_:format:)` and `TextField(_:value:format:)`.
+/// `Timer.swift` adds the `Timer` and `RunLoop` that corelibs Foundation does
+/// not have on WASI.
+///
+/// Apps do not import this module themselves: the CLI's staging adds it next
+/// to `import Foundation`, together with typealiases that settle the names
+/// both the shim and Foundation declare (`CGFloat`, `CGPoint`, `CGSize`,
+/// `CGRect`, `Timer`, `RunLoop`) in the shim's favor. See
+/// docs/ops-protocol.md, "Phase 11".
+import Foundation
+import SwiftUI
+import _FoundationCommon
+
+// MARK: - Offset sets
+
+extension IndexSet: _OffsetSet {
+    public init(_offsets: [Int]) { self.init(_offsets) }
+    /// `IndexSet` iterates its integers in ascending order without duplicates.
+    public var _offsets: [Int] { Array(self) }
+}
+
+// MARK: - Dates
+
+extension Date: _DatePickerValue {
+    public var _secondsSince1970: Double { timeIntervalSince1970 }
+    public init(_secondsSince1970 seconds: Double) {
+        self.init(timeIntervalSince1970: seconds)
+    }
+}
+
+// MARK: - Format styles
+
+/// A Foundation parseable format style as the shim's `_TextFormat`.
+struct _ParseableFormatStyleText<F: ParseableFormatStyle>: _TextFormat where F.FormatOutput == String, F.Strategy.ParseInput == String {
+    let style: F
+    func _formatText(_ value: F.FormatInput) -> String { style.format(value) }
+    func _parseText(_ text: String) -> F.FormatInput? { try? style.parseStrategy.parse(text) }
+}
+
+extension Text {
+    /// `Text(price, format: .currency(code: "USD"))`, `Text(date, format: .dateTime.year())`.
+    public init<F: FormatStyle>(_ input: F.FormatInput, format: F) where F.FormatOutput == String {
+        self.init(verbatim: format.format(input))
+    }
+}
+
+extension TextField where Label == Text {
+    /// `TextField("Amount", value: $amount, format: .number)`: the field shows
+    /// the formatted value and sets it from what the user types when the
+    /// style's parse strategy accepts the text.
+    public init<S: StringProtocol, F: ParseableFormatStyle>(_ title: S, value: Binding<F.FormatInput>, format: F, prompt: Text? = nil)
+    where F.FormatOutput == String, F.Strategy.ParseInput == String {
+        self.init(_placeholder: prompt?._content ?? String(title), value: value, format: _ParseableFormatStyleText(style: format))
+    }
+
+    public init<F: ParseableFormatStyle>(_ titleKey: LocalizedStringKey, value: Binding<F.FormatInput>, format: F, prompt: Text? = nil)
+    where F.FormatOutput == String, F.Strategy.ParseInput == String {
+        self.init(_placeholder: prompt?._content ?? titleKey.key, value: value, format: _ParseableFormatStyleText(style: format))
+    }
+}
+
+// MARK: - Defaults and resources
+
+/// `UserDefaults` that persists through the browser and the `Bundle` that
+/// reads the app's resources (Sources/_FoundationCommon). The CLI's generated
+/// file aliases both in the app, over corelibs Foundation's (whose
+/// `UserDefaults` cannot persist on WASI and whose `Bundle.main` traps).
+public typealias UserDefaults = _FoundationCommon.UserDefaults
+public typealias Bundle = _FoundationCommon.Bundle

package/Sources/FoundationBridge/Locale.swift

@@ -0,0 +1,86 @@
+// `Locale.current` for the browser. swift-foundation has no way to set the
+// current locale on WASI: `LocaleCache.preferences()` returns a hard-coded
+// `en_001` (there are no CFPreferences and it does not read `LANG`), so a
+// French user would get English formatting whatever the browser says.
+//
+// The CLI links full-Foundation apps with
+// `--wrap=$s20FoundationEssentials11LocaleCacheV11preferencesAA0C11PreferencesV_SbtyF`
+// (and the same for `Locale.preferredLanguages`), so the one call to that
+// function, from `_currentAndCache`, lands here instead and reads the locale
+// the host chose (`SB_LOCALE`, a BCP 47 tag among the app's shipped locales).
+//
+// This depends on the SDK's swift-foundation: the struct below mirrors
+// `LocalePreferences` field for field (the non-framework build at Swift 6.4,
+// 60 bytes on wasm32), and the method is on a class so the cache pointer rides
+// in Swift's `self` slot like the original's. The SDK is pinned by the CLI
+// (`SWIFT_VERSION`), and CI checks French formatting in a full-mode build, so
+// a layout change in a future SDK shows up as a failed check, not a silent one.
+// See docs/ops-protocol.md, "Phase 11".
+
+#if os(WASI)
+import Foundation
+
+/// Mirror of `FoundationEssentials.LocalePreferences` (`package struct`, non-framework fields).
+public struct _LocalePreferencesMirror {
+    public enum MeasurementUnit: Int { case centimeters, inches }
+    public enum TemperatureUnit: Int { case fahrenheit, celsius }
+    public enum CalendarIdentifier: Int { case gregorian }
+    public var metricUnits: Bool?
+    public var languages: [String]?
+    public var locale: String?
+    public var collationOrder: String?
+    public var firstWeekday: [CalendarIdentifier: Int]?
+    public var minDaysInFirstWeek: [CalendarIdentifier: Int]?
+    public var numberSymbols: [UInt32: String]?
+    public var country: String?
+    public var measurementUnits: MeasurementUnit?
+    public var temperatureUnit: TemperatureUnit?
+    public var force24Hour: Bool?
+    public var force12Hour: Bool?
+    public init() {}
+}
+
+/// The locale the host asked for, as ICU (`fr_FR`) and BCP 47 (`fr-FR`) identifiers; nil when unset.
+func _requestedLocale() -> (icu: String, bcp47: String)? {
+    guard let raw = ProcessInfo.processInfo.environment["SB_LOCALE"]?.trimmingCharacters(in: .whitespaces), !raw.isEmpty else { return nil }
+    let parts = raw.split(whereSeparator: { $0 == "-" || $0 == "_" }).map(String.init)
+    guard let language = parts.first, (2...3).contains(language.count), language.allSatisfy(\.isLetter) else { return nil }
+    var icu = [language.lowercased()]
+    var bcp = [language.lowercased()]
+    for part in parts.dropFirst() {
+        if part.count == 4, part.allSatisfy(\.isLetter) {
+            let script = part.prefix(1).uppercased() + part.dropFirst().lowercased()
+            icu.append(script); bcp.append(script)
+        } else if part.count == 2 && part.allSatisfy(\.isLetter) || part.count == 3 && part.allSatisfy(\.isNumber) {
+            icu.append(part.uppercased()); bcp.append(part.uppercased())
+        }
+    }
+    return (icu.joined(separator: "_"), bcp.joined(separator: "-"))
+}
+
+/// Stands in for the `LocaleCache` instance: Swift passes `self` in its own
+/// slot (an explicit trailing parameter on wasm) and a class method is what
+/// puts it there. `self` is the cache's storage and is never touched.
+public final class _LocaleCacheHandle {
+    @_silgen_name("__wrap_$s20FoundationEssentials11LocaleCacheV11preferencesAA0C11PreferencesV_SbtyF")
+    public func _preferences() -> (_LocalePreferencesMirror, Bool) {
+        var prefs = _LocalePreferencesMirror()
+        if let locale = _requestedLocale() {
+            prefs.locale = locale.icu
+            prefs.languages = [locale.bcp47]
+        } else {
+            prefs.locale = "en_001"
+            prefs.languages = ["en-001"]
+        }
+        return (prefs, true)
+    }
+}
+
+/// Stands in for the `Locale` metatype of the static `preferredLanguages` getter.
+public final class _LocaleMetatypeHandle {
+    @_silgen_name("__wrap_$s20FoundationEssentials6LocaleV18preferredLanguagesSaySSGvgZ")
+    public func _preferredLanguages() -> [String] {
+        [_requestedLocale()?.bcp47 ?? "en-001"]
+    }
+}
+#endif

package/Sources/FoundationBridge/Timer.swift

@@ -0,0 +1,48 @@
+// `Timer` and `RunLoop` for full-Foundation apps in the browser. swift-corelibs
+// Foundation marks `RunLoop` unavailable on WASI and its `Timer` needs
+// CFRunLoop, which the WASI build does not have (the link fails), and
+// `Timer.publish` is Combine's anyway. These two classes have the same names;
+// the CLI's staging gives the app `typealias Timer = FoundationBridge.Timer`
+// and `typealias RunLoop = FoundationBridge.RunLoop`, so `Timer.publish(every:
+// 1, on: .main, in: .common).autoconnect()` and `Timer.scheduledTimer` resolve
+// here. Ticks come from the runtime's executor (`_IntervalPublisher` and
+// `_ExecutorTimer` in the SwiftUI shim), like FoundationLite's.
+
+import Foundation
+import SwiftUI
+
+public final class RunLoop: @unchecked Sendable {
+    public struct Mode: Hashable, Sendable {
+        public let rawValue: String
+        public init(rawValue: String) { self.rawValue = rawValue }
+        public static let `default` = Mode(rawValue: "default")
+        public static let common = Mode(rawValue: "common")
+    }
+    nonisolated(unsafe) public static let main = RunLoop()
+    public static var current: RunLoop { main }
+}
+
+public final class Timer: @unchecked Sendable {
+    /// Emits the current date every `interval` seconds once subscribed.
+    public typealias TimerPublisher = _IntervalPublisher<Date>
+
+    public static func publish(every interval: TimeInterval, tolerance: TimeInterval? = nil, on runLoop: RunLoop = .main, in mode: RunLoop.Mode = .default, options: Never? = nil) -> TimerPublisher {
+        _IntervalPublisher(every: interval) { Date() }
+    }
+
+    private var core: _ExecutorTimer!
+
+    public var isValid: Bool { core.isValid }
+    public var timeInterval: TimeInterval { core.timeInterval }
+
+    init(interval: TimeInterval, repeats: Bool, block: @escaping @Sendable (Timer) -> Void) {
+        core = _ExecutorTimer(interval: interval, repeats: repeats) { _ in block(self) }
+    }
+
+    @discardableResult
+    public static func scheduledTimer(withTimeInterval interval: TimeInterval, repeats: Bool, block: @escaping @Sendable (Timer) -> Void) -> Timer {
+        Timer(interval: interval, repeats: repeats, block: block)
+    }
+
+    public func invalidate() { core.invalidate() }
+}

package/Sources/FoundationBridge/UITextChecker.swift

@@ -0,0 +1,30 @@
+// A stand-in for UIKit's `UITextChecker`, which SwiftUI apps reach through
+// SwiftUI's re-export of UIKit (Hacking with SwiftUI's WordScramble checks
+// spelling with it). Full-Foundation builds only (NSRange is Foundation's). The
+// browser has no spell checker to ask, so every word
+// passes: `rangeOfMisspelledWord` is always `NSNotFound`, `guesses` and
+// `completions` are nil. Enough for the code to compile and run; the game
+// just stops rejecting misspellings.
+
+import Foundation
+
+public final class UITextChecker: @unchecked Sendable {
+    public init() {}
+
+    /// Always "no misspelling": `NSRange(location: NSNotFound, length: 0)`.
+    public func rangeOfMisspelledWord(in stringToCheck: String, range: NSRange, startingAt startingOffset: Int,
+                                      wrap wrapFlag: Bool, language: String) -> NSRange {
+        NSRange(location: NSNotFound, length: 0)
+    }
+
+    public func guesses(forWordRange range: NSRange, in string: String, language: String) -> [String]? { nil }
+    public func completions(forPartialWordRange range: NSRange, in string: String, language: String) -> [String]? { nil }
+
+    public static let availableLanguages: [String] = ["en"]
+    public static func hasLearnedWord(_ word: String) -> Bool { false }
+    public static func learnWord(_ word: String) {}
+    public static func unlearnWord(_ word: String) {}
+    public func ignoreWord(_ wordToIgnore: String) {}
+    public func ignoredWords() -> [String]? { nil }
+    public func setIgnoredWords(_ words: [String]?) {}
+}

package/Sources/FoundationLite/Common.swift

@@ -0,0 +1,3 @@
+// `UserDefaults` and `Bundle` for the browser are shared with FoundationBridge
+// (Sources/_FoundationCommon); they are part of this module's API.
+@_exported import _FoundationCommon

package/Sources/FoundationLite/FoundationLite.swift

@@ -0,0 +1,171 @@
+/// The slice of Foundation's formatting API that SwiftUI apps lean on, for
+/// platforms where only `FoundationEssentials` is linked (WebAssembly, Linux):
+/// the CLI's lean mode and the repository's own examples.
+///
+/// Full Foundation on Wasm costs about 14 MB more than FoundationEssentials
+/// even with its ICU data trimmed (docs/ops-protocol.md, "Phase 11"), so apps
+/// that must stay small import `FoundationEssentials` plus this module; the
+/// CLI's default is the real Foundation with `FoundationBridge`.
+/// The spellings match Foundation's, so a file that does
+///
+///     #if canImport(FoundationEssentials)
+///     import FoundationEssentials
+///     import FoundationLite
+///     #else
+///     import Foundation
+///     #endif
+///
+/// compiles unchanged against Apple's SDKs. Output is fixed to US English
+/// conventions (`1,234.5`, `Nov 14, 2023`, `10:13 PM`), which is also what
+/// keeps headless snapshots byte-stable.
+#if canImport(FoundationEssentials)
+import FoundationEssentials
+
+// MARK: - Dates
+
+extension Date {
+    /// Namespaces for `formatted(date:time:)`, mirroring `Foundation.Date.FormatStyle`.
+    public struct FormatStyle: Sendable {
+        public enum DateStyle: Hashable, Sendable {
+            case omitted, numeric, abbreviated, long, complete
+        }
+
+        public enum TimeStyle: Hashable, Sendable {
+            case omitted, shortened, standard, complete
+        }
+    }
+
+    /// `11/14/2023, 10:13 PM`, `Nov 14, 2023`, `November 14, 2023`,
+    /// `Tuesday, November 14, 2023`; times `10:13 PM`, `10:13:20 PM`.
+    /// Uses `Calendar.current`, which is Gregorian/UTC on WebAssembly.
+    public func formatted(date dateStyle: FormatStyle.DateStyle = .numeric,
+                          time timeStyle: FormatStyle.TimeStyle = .shortened) -> String {
+        let calendar = Calendar.current
+        let c = calendar.dateComponents([.year, .month, .day, .weekday, .hour, .minute, .second], from: self)
+        let year = c.year ?? 1970, month = c.month ?? 1, day = c.day ?? 1
+        let monthName = _monthNames[(month - 1) % 12]
+        let datePart: String?
+        switch dateStyle {
+        case .omitted: datePart = nil
+        case .numeric: datePart = "\(month)/\(day)/\(year)"
+        case .abbreviated: datePart = "\(monthName.prefix(3)) \(day), \(year)"
+        case .long: datePart = "\(monthName) \(day), \(year)"
+        case .complete: datePart = "\(_weekdayNames[((c.weekday ?? 1) - 1) % 7]), \(monthName) \(day), \(year)"
+        }
+        let timePart: String?
+        if timeStyle == .omitted {
+            timePart = nil
+        } else {
+            let hour24 = c.hour ?? 0, minute = c.minute ?? 0, second = c.second ?? 0
+            let hour12 = hour24 % 12 == 0 ? 12 : hour24 % 12
+            let suffix = hour24 < 12 ? "AM" : "PM"
+            let base = "\(hour12):\(_twoDigits(minute))"
+            switch timeStyle {
+            case .shortened: timePart = "\(base) \(suffix)"
+            case .standard, .complete: timePart = "\(base):\(_twoDigits(second)) \(suffix)"
+            case .omitted: timePart = nil
+            }
+        }
+        switch (datePart, timePart) {
+        case (let d?, let t?): return "\(d), \(t)"
+        case (let d?, nil): return d
+        case (nil, let t?): return t
+        case (nil, nil): return ""
+        }
+    }
+
+    public func formatted() -> String { formatted(date: .numeric, time: .shortened) }
+}
+
+private let _monthNames = ["January", "February", "March", "April", "May", "June", "July",
+                           "August", "September", "October", "November", "December"]
+private let _weekdayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
+
+func _twoDigits(_ value: Int) -> String { value < 10 ? "0\(value)" : "\(value)" }
+
+// MARK: - Numbers
+
+/// Inserts thousands separators into a run of digits (optionally signed).
+func _grouped(_ digits: Substring) -> String {
+    var sign = ""
+    var body = digits
+    if body.first == "-" {
+        sign = "-"
+        body = body.dropFirst()
+    }
+    var out: [Character] = []
+    for (index, ch) in body.reversed().enumerated() {
+        if index > 0 && index % 3 == 0 { out.append(",") }
+        out.append(ch)
+    }
+    return sign + String(out.reversed())
+}
+
+/// Formats a decimal string (`-1234.5000`) the way `.number` does: grouped
+/// integer digits and at most `maxFractionDigits` fraction digits, trailing
+/// zeros dropped.
+func _formatDecimalString(_ text: String, maxFractionDigits: Int = 3) -> String {
+    let parts = text.split(separator: ".", maxSplits: 1, omittingEmptySubsequences: false)
+    let integer = _grouped(parts[0])
+    guard parts.count == 2 else { return integer }
+    var fraction = String(parts[1].prefix(maxFractionDigits))
+    while fraction.last == "0" { fraction.removeLast() }
+    return fraction.isEmpty ? integer : "\(integer).\(fraction)"
+}
+
+extension BinaryInteger {
+    /// `1234` → `1,234`.
+    public func formatted() -> String { _grouped(Substring(String(self))) }
+}
+
+extension BinaryFloatingPoint where Self: CustomStringConvertible {
+    /// `1234.5678` → `1,234.568`; whole numbers lose the `.0`.
+    public func formatted() -> String {
+        guard isFinite else { return isNaN ? "NaN" : (self < 0 ? "-∞" : "∞") }
+        // Round to 3 fraction digits in integer arithmetic to avoid exponents.
+        let scaled = (Double(self) * 1000).rounded()
+        let negative = scaled < 0
+        let magnitude = Int64(min(abs(scaled), Double(Int64.max / 2)))
+        let integer = magnitude / 1000
+        let fraction = magnitude % 1000
+        let text = "\(negative && magnitude != 0 ? "-" : "")\(integer)." + _threeDigits(fraction)
+        return _formatDecimalString(text)
+    }
+}
+
+/// Three-digit zero-padded fraction.
+private func _threeDigits(_ value: Int64) -> String {
+    let raw = String(value)
+    return String(repeating: "0", count: max(0, 3 - raw.count)) + raw
+}
+
+extension Decimal {
+    /// `Decimal(string: "3.75")! * 4` → `15`; `Decimal(string: "1234.5")!` → `1,234.5`.
+    public func formatted() -> String { _formatDecimalString(description) }
+}
+
+// MARK: - Strings
+
+extension StringProtocol {
+    public func localizedCaseInsensitiveContains<T: StringProtocol>(_ other: T) -> Bool {
+        lowercased().contains(other.lowercased())
+    }
+
+    public func localizedStandardContains<T: StringProtocol>(_ other: T) -> Bool {
+        localizedCaseInsensitiveContains(other)
+    }
+
+    public func localizedCompare<T: StringProtocol>(_ other: T) -> ComparisonResult {
+        let a = String(self), b = String(other)
+        return a == b ? .orderedSame : (a < b ? .orderedAscending : .orderedDescending)
+    }
+
+    public func localizedCaseInsensitiveCompare<T: StringProtocol>(_ other: T) -> ComparisonResult {
+        lowercased().localizedCompare(other.lowercased())
+    }
+
+    public func localizedStandardCompare<T: StringProtocol>(_ other: T) -> ComparisonResult {
+        localizedCaseInsensitiveCompare(other)
+    }
+}
+#endif