@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/FoundationBridge/KeyValueObserving.swift

@@ -0,0 +1,138 @@
+// Key-value observation (`object.observe(\.property) { object, change in }`)
+// without the Objective-C runtime. On Apple platforms a setter of an
+// `@objc dynamic` property tells its observers; corelibs Foundation has no
+// KVO at all, and its classes' setters (`Progress.completedUnitCount`) are out
+// of reach. So an observation polls: once per frame (1/60 s, on the
+// executor's clock, so headless runs stay deterministic) it reads the key
+// path on the main actor and calls the handler when the value differs from
+// the last one it saw. That is what KVO does, a frame late at most, and
+// changes made and undone within one frame are not seen. Values compare with
+// `==` when they are `Equatable`, by identity when they are objects, and
+// otherwise by their description. `.prior` is accepted; no prior
+// notification is sent. ButtonKit follows a `Progress` this way.
+
+import Foundation
+import SwiftUI
+
+/// What an observation's change carries.
+public struct NSKeyValueObservingOptions: OptionSet, Sendable, Hashable {
+    public let rawValue: UInt
+    public init(rawValue: UInt) { self.rawValue = rawValue }
+
+    /// The change carries the new value.
+    public static let new = NSKeyValueObservingOptions(rawValue: 1 << 0)
+    /// The change carries the old value.
+    public static let old = NSKeyValueObservingOptions(rawValue: 1 << 1)
+    /// The handler is called at once with the current value.
+    public static let initial = NSKeyValueObservingOptions(rawValue: 1 << 2)
+    /// Accepted; no notification is sent before a change.
+    public static let prior = NSKeyValueObservingOptions(rawValue: 1 << 3)
+}
+
+/// The kind of change: a polled property was always set.
+public enum NSKeyValueChange: UInt, Sendable {
+    case setting = 1, insertion, removal, replacement
+}
+
+/// A change an observation reports.
+public struct NSKeyValueObservedChange<Value> {
+    public typealias Kind = NSKeyValueChange
+    public let kind: Kind
+    /// The value after the change, with `.new` (or `.initial`).
+    public let newValue: Value?
+    /// The value before the change, with `.old`.
+    public let oldValue: Value?
+    public let indexes: IndexSet?
+    /// Always false: no prior notification is sent.
+    public let isPrior: Bool
+}
+
+/// An observation in progress; it ends when invalidated or released, or
+/// when the observed object goes away.
+public final class NSKeyValueObservation: NSObject, @unchecked Sendable {
+    private var timer: _ExecutorTimer?
+
+    init(timer: _ExecutorTimer) {
+        self.timer = timer
+    }
+
+    /// Stops the observation.
+    public func invalidate() {
+        timer?.invalidate()
+        timer = nil
+    }
+
+    deinit { timer?.invalidate() }
+}
+
+/// The types `observe(_:options:changeHandler:)` is offered on: every `NSObject`.
+public protocol _KeyValueCodingAndObserving {}
+extension NSObject: _KeyValueCodingAndObserving {}
+
+extension _KeyValueCodingAndObserving where Self: AnyObject {
+    /// Calls `changeHandler` when the value at `keyPath` changes (seen by
+    /// polling once per frame on the main actor; see the file comment).
+    public func observe<Value>(_ keyPath: KeyPath<Self, Value>, options: NSKeyValueObservingOptions = [],
+                               changeHandler: @escaping (Self, NSKeyValueObservedChange<Value>) -> Void) -> NSKeyValueObservation {
+        let poller = _KeyValuePoller(object: self, keyPath: keyPath, options: options, handler: changeHandler)
+        if options.contains(.initial) { poller.report(old: nil, new: poller.last) }
+        let timer = _ExecutorTimer(interval: 1.0 / 60, repeats: true) { timer in
+            if !poller.poll() { timer.invalidate() }
+        }
+        return NSKeyValueObservation(timer: timer)
+    }
+}
+
+/// One observation's state: the object (held weakly), the last value seen and the handler.
+final class _KeyValuePoller<Root: AnyObject, Value>: @unchecked Sendable {
+    weak var object: Root?
+    let keyPath: KeyPath<Root, Value>
+    let options: NSKeyValueObservingOptions
+    let handler: (Root, NSKeyValueObservedChange<Value>) -> Void
+    var last: Value
+
+    init(object: Root, keyPath: KeyPath<Root, Value>, options: NSKeyValueObservingOptions,
+         handler: @escaping (Root, NSKeyValueObservedChange<Value>) -> Void) {
+        self.object = object
+        self.keyPath = keyPath
+        self.options = options
+        self.handler = handler
+        last = object[keyPath: keyPath]
+    }
+
+    /// Reads the value and reports a change; false once the object is gone.
+    func poll() -> Bool {
+        guard let object else { return false }
+        let value = object[keyPath: keyPath]
+        if !_keyValueEqual(value, last) {
+            let old = last
+            last = value
+            report(old: old, new: value)
+        }
+        return true
+    }
+
+    func report(old: Value?, new: Value) {
+        guard let object else { return }
+        handler(object, NSKeyValueObservedChange(kind: .setting,
+                                                 newValue: options.contains(.new) ? new : nil,
+                                                 oldValue: options.contains(.old) ? old : nil,
+                                                 indexes: nil, isPrior: false))
+    }
+}
+
+/// Whether two observed values are the same (see the file comment).
+func _keyValueEqual<Value>(_ a: Value, _ b: Value) -> Bool {
+    if let a = a as? any Equatable { return a._keyValueIsEqual(to: b) }
+    if type(of: a as Any) is AnyClass {
+        return (a as AnyObject) === (b as AnyObject)
+    }
+    return String(reflecting: a) == String(reflecting: b)
+}
+
+extension Equatable {
+    fileprivate func _keyValueIsEqual(to other: Any) -> Bool {
+        guard let other = other as? Self else { return false }
+        return self == other
+    }
+}

package/Sources/FoundationBridge/Links.swift

@@ -0,0 +1,127 @@
+// Opening URLs, and the text that holds them: `OpenURLAction` and
+// `EnvironmentValues.openURL`, `Link`, and `Text(AttributedString)`. These
+// need Foundation's `URL` and `AttributedString`, so they live here; the
+// SwiftUI shim keeps the string-based hook a text's links call
+// (`EnvironmentValues._openLink`, Text.swift).
+//
+// The system action opens the URL on the page: in a new tab (an `openURL`
+// host request). An app that sets its own action (Ice Cubes routes mentions,
+// hashtags and posts through one) gets every link tap first.
+
+import Foundation
+import SwiftUI
+
+public struct OpenURLAction: Sendable {
+    public struct Result: Sendable {
+        enum Kind: Sendable { case handled, discarded, systemAction(URL?) }
+        let kind: Kind
+        public static let handled = Result(kind: .handled)
+        public static let discarded = Result(kind: .discarded)
+        public static let systemAction = Result(kind: .systemAction(nil))
+        public static func systemAction(_ url: URL) -> Result { Result(kind: .systemAction(url)) }
+    }
+
+    let handler: @MainActor @Sendable (URL) -> Result
+
+    public init(handler: @escaping @MainActor @Sendable (URL) -> Result) {
+        self.handler = handler
+    }
+
+    /// The page's own action: open the URL in a new tab, or hand a URL in
+    /// one of the app's own schemes to its `onOpenURL` handlers (OpenURLHandlers.swift).
+    static let system = OpenURLAction { url in
+        if _OpenURLHandlers.deliver(url) { return .handled }
+        _Runtime.shared._openLinkOnPage(url.absoluteString)
+        return .handled
+    }
+
+    @MainActor public func callAsFunction(_ url: URL) {
+        callAsFunction(url) { _ in }
+    }
+
+    @MainActor public func callAsFunction(_ url: URL, completion: @escaping (Bool) -> Void) {
+        switch handler(url).kind {
+        case .handled: completion(true)
+        case .discarded: completion(false)
+        case .systemAction(let other):
+            _ = Self.system.handler(other ?? url)
+            completion(true)
+        }
+    }
+}
+
+private struct OpenURLKey: EnvironmentKey {
+    static var defaultValue: OpenURLAction? { nil }
+}
+
+extension EnvironmentValues {
+    /// What opens a URL: a link in a `Text`, a `Link`, or a call. Setting it
+    /// also routes the links of the texts below to it.
+    public var openURL: OpenURLAction {
+        get { self[OpenURLKey.self] ?? .system }
+        set {
+            self[OpenURLKey.self] = newValue
+            _openLink = { string in
+                if let url = URL(string: string) { newValue(url) }
+            }
+        }
+    }
+}
+
+/// A control that opens a URL: its label, tinted, as a button.
+public struct Link<Label: View>: View {
+    let destination: URL
+    let label: Label
+    @Environment(\.openURL) private var openURL
+
+    public init(destination: URL, @ViewBuilder label: () -> Label) {
+        self.destination = destination
+        self.label = label()
+    }
+
+    public var body: some View {
+        let open = openURL
+        let destination = destination
+        return Button { open(destination) } label: { label }
+    }
+}
+
+extension Link where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, destination: URL) {
+        self.init(destination: destination) { Text(titleKey) }
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, destination: URL) {
+        self.init(destination: destination) { Text(title) }
+    }
+}
+
+extension Text {
+    /// The attributed string's runs as styled text: Markdown's emphasis as
+    /// bold and italic, code as monospaced, strikethrough, links (which call
+    /// the environment's `openURL` when tapped), and the SwiftUI attributes
+    /// (TextAttributes.swift).
+    /// Disfavored: a string literal is a `LocalizedStringKey`, not this.
+    @_disfavoredOverload
+    public init(_ attributedContent: AttributedString) {
+        var result: Text?
+        for run in attributedContent.runs {
+            var piece = Text(verbatim: String(attributedContent[run.range].characters))
+            if let intent = run.inlinePresentationIntent {
+                if intent.contains(.stronglyEmphasized) { piece = piece.bold() }
+                if intent.contains(.emphasized) { piece = piece.italic() }
+                if intent.contains(.code) { piece = piece.monospaced() }
+                if intent.contains(.strikethrough) { piece = piece.strikethrough() }
+            }
+            if let kern = run.kern { piece = piece.kerning(kern) }
+            if let tracking = run.tracking { piece = piece.tracking(tracking) }
+            if let offset = run.baselineOffset { piece = piece.baselineOffset(offset) }
+            if let color = run.foregroundColor { piece = piece.foregroundColor(color) }
+            if let font = run.font { piece = piece.font(font) }
+            if let link = run.link { piece = piece._link(link.absoluteString) }
+            result = result.map { $0 + piece } ?? piece
+        }
+        self = result ?? Text(verbatim: "")
+    }
+}

package/Sources/FoundationBridge/ListFormatter.swift

@@ -0,0 +1,32 @@
+// `ListFormatter`, which corelibs Foundation lacks: joins items into a
+// phrase ("A, B, and C"). The browser build has English list patterns only,
+// whatever the locale: "A", "A and B", "A, B, and C".
+
+import Foundation
+
+open class ListFormatter: Formatter, @unchecked Sendable {
+    /// Formats each item; without it, an item is its description.
+    open var itemFormatter: Formatter?
+    open var locale: Locale! = .current
+
+    /// The strings joined into a list.
+    open class func localizedString(byJoining strings: [String]) -> String {
+        switch strings.count {
+        case 0: return ""
+        case 1: return strings[0]
+        case 2: return "\(strings[0]) and \(strings[1])"
+        default: return strings.dropLast().joined(separator: ", ") + ", and " + strings[strings.count - 1]
+        }
+    }
+
+    /// The items, each formatted by `itemFormatter`, joined into a list.
+    open func string(from items: [Any]) -> String? {
+        let strings = items.map { item in itemFormatter?.string(for: item) ?? String(describing: item) }
+        return Self.localizedString(byJoining: strings)
+    }
+
+    open override func string(for obj: Any?) -> String? {
+        guard let items = obj as? [Any] else { return nil }
+        return string(from: items)
+    }
+}

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/Localization.swift

@@ -0,0 +1,149 @@
+// Foundation's localized-string types that Linux's and WASI's Foundation
+// lack: `LocalizedStringResource` (what App Intents titles, `Text` and
+// `Tab` take), `String.LocalizationValue` and `String(localized:)`.
+//
+// A value is a key as Xcode writes it in a string catalog (`"%lld posts"` for
+// `"\(count) posts"`) with its arguments; `String(localized:)` looks the key
+// up in the app's string tables and formats it (SwiftUI's
+// Localization/Localization.swift), falling back to the default value, then
+// to the key itself.
+
+import Foundation
+import SwiftUI
+
+extension String {
+    /// A localizable string: its key, with a specifier per interpolation, and the interpolated values.
+    public struct LocalizationValue: Hashable, Sendable, Codable, ExpressibleByStringInterpolation, CustomStringConvertible {
+        /// The key, with `%%` for a literal percent sign when it has arguments.
+        let key: String
+        let arguments: [_LocalizationArgument]
+
+        public init(_ value: String) { key = value; arguments = [] }
+        public init(stringLiteral value: String) { key = value; arguments = [] }
+        public init(stringInterpolation: StringInterpolation) {
+            key = stringInterpolation.key
+            arguments = stringInterpolation.arguments
+        }
+
+        /// The text unlocalized: the key with its arguments filled in.
+        public var description: String { _Localization.formatted(key: key, arguments: arguments) }
+
+        /// Interpolations add Foundation's specifiers: `%@` for strings, `%lld` for `Int`, `%lf` for `Double`…
+        public struct StringInterpolation: StringInterpolationProtocol {
+            var key = ""
+            var arguments: [_LocalizationArgument] = []
+            public init(literalCapacity: Int, interpolationCount: Int) {}
+
+            mutating func add(_ argument: _LocalizationArgument, _ specifier: String) {
+                key += specifier
+                arguments.append(argument)
+            }
+
+            public mutating func appendLiteral(_ literal: String) { key += literal.replacingOccurrences(of: "%", with: "%%") }
+            public mutating func appendInterpolation(_ string: String) { add(.string(string), "%@") }
+            public mutating func appendInterpolation<T>(_ value: T) { add(.string(String(describing: value)), "%@") }
+            public mutating func appendInterpolation<T: _FormatSpecifiable>(_ value: T) { add(value._localizationArgument, T._specifier) }
+            public mutating func appendInterpolation<T>(_ value: T, specifier: String) {
+                add((value as? any _FormatSpecifiable)?._localizationArgument ?? .string(String(describing: value)), specifier)
+            }
+            public mutating func appendInterpolation<F: FormatStyle>(_ value: F.FormatInput, format: F) where F.FormatOutput == String {
+                add(.string(format.format(value)), "%@")
+            }
+            public mutating func appendInterpolation(_ resource: LocalizedStringResource) { add(.string(String(localized: resource)), "%@") }
+        }
+    }
+
+    public init(localized keyAndValue: String.LocalizationValue, table: String? = nil, bundle: Bundle? = nil,
+                locale: Locale = .current, comment: StaticString? = nil) {
+        self = _Localization.string(key: keyAndValue.key, arguments: keyAndValue.arguments, table: table,
+                                    bundlePath: (bundle ?? .main).bundlePath)
+    }
+
+    public init(localized key: StaticString, defaultValue: String.LocalizationValue, table: String? = nil,
+                bundle: Bundle? = nil, locale: Locale = .current, comment: StaticString? = nil) {
+        self = _Localization.string(key: "\(key)", arguments: defaultValue.arguments, table: table,
+                                    bundlePath: (bundle ?? .main).bundlePath, defaultValue: defaultValue.key)
+    }
+
+    @_disfavoredOverload
+    public init(localized resource: LocalizedStringResource) {
+        let bundlePath = switch resource.bundle {
+        case .main: Bundle.main.bundlePath
+        case .atURL(let url): url.path
+        }
+        self = _Localization.string(key: resource.key, arguments: resource.defaultValue.arguments, table: resource.table,
+                                    bundlePath: bundlePath, defaultValue: resource.defaultValue.key)
+    }
+}
+
+/// A string to localize later, with where to find its translation.
+public struct LocalizedStringResource: Hashable, Sendable, Codable, ExpressibleByStringInterpolation, CustomStringConvertible {
+    public typealias StringInterpolation = String.LocalizationValue.StringInterpolation
+
+    /// Where the translation lives. Every bundle is the app's in the browser.
+    public enum BundleDescription: Hashable, Sendable, Codable {
+        case main
+        case atURL(URL)
+        public static func forClass(_ aClass: AnyClass) -> BundleDescription { .main }
+    }
+
+    public var key: String
+    public var defaultValue: String.LocalizationValue
+    public var table: String?
+    public var locale: Locale
+    public var bundle: BundleDescription
+
+    public init(_ keyAndValue: String.LocalizationValue, table: String? = nil, locale: Locale = .current,
+                bundle: BundleDescription = .main, comment: StaticString? = nil) {
+        self.key = keyAndValue.key
+        self.defaultValue = keyAndValue
+        self.table = table
+        self.locale = locale
+        self.bundle = bundle
+    }
+
+    public init(_ key: StaticString, defaultValue: String.LocalizationValue, table: String? = nil,
+                locale: Locale = .current, bundle: BundleDescription = .main, comment: StaticString? = nil) {
+        self.key = "\(key)"
+        self.defaultValue = defaultValue
+        self.table = table
+        self.locale = locale
+        self.bundle = bundle
+    }
+
+    public init(stringLiteral value: String) { self.init(String.LocalizationValue(value)) }
+    public init(stringInterpolation: StringInterpolation) {
+        self.init(String.LocalizationValue(stringInterpolation: stringInterpolation))
+    }
+
+    /// The text, as `String(localized:)` resolves it.
+    public var description: String { String(localized: self) }
+}
+
+extension Text {
+    @_disfavoredOverload
+    public init(_ resource: LocalizedStringResource) {
+        self.init(verbatim: String(localized: resource))
+    }
+
+    /// A key from another table (`Localizable` by default) or bundle (a package's `Bundle.module`).
+    public init(_ key: LocalizedStringKey, tableName: String?, bundle: Bundle? = nil, comment: StaticString? = nil) {
+        self.init(key, _table: tableName, bundlePath: (bundle ?? .main).bundlePath)
+    }
+
+    public init(_ key: LocalizedStringKey, bundle: Bundle?, comment: StaticString? = nil) {
+        self.init(key, _table: nil, bundlePath: (bundle ?? .main).bundlePath)
+    }
+
+    /// A key with a comment for translators (`Text("Water", comment: "…")`).
+    public init(_ key: LocalizedStringKey, comment: StaticString?) {
+        self.init(key, _table: nil, bundlePath: Bundle.main.bundlePath)
+    }
+}
+
+/// `NSLocalizedString` with one of this module's bundles, which is what a
+/// package's `Bundle.module` is in the browser build (Foundation's takes
+/// Foundation's `Bundle`; calls without a bundle still go to it).
+public func NSLocalizedString(_ key: String, tableName: String? = nil, bundle: Bundle, value: String = "", comment: String) -> String {
+    bundle.localizedString(forKey: key, value: value, table: tableName)
+}

package/Sources/FoundationBridge/Locks.swift

@@ -0,0 +1,50 @@
+// Locks for code that imports only Foundation. On Apple platforms Foundation
+// brings Darwin along, `os_unfair_lock` with it, so a package's
+// `#if os(iOS)` branch locks with it after `import Foundation` alone
+// (SwiftSoup's `Mutex`); these come from the shim's os module. On WASI, the
+// libc module leaves out `pthread.h`, so a POSIX branch (`#if canImport(Darwin)
+// … #else pthread_mutex_lock`) finds no functions: here are the mutex ones,
+// for the page's single thread, where a lock is never contended.
+
+@_exported import struct os.os_unfair_lock
+@_exported import typealias os.os_unfair_lock_t
+@_exported import typealias os.os_unfair_lock_s
+@_exported import func os.os_unfair_lock_lock
+@_exported import func os.os_unfair_lock_unlock
+@_exported import func os.os_unfair_lock_trylock
+@_exported import func os.os_unfair_lock_assert_owner
+@_exported import func os.os_unfair_lock_assert_not_owner
+
+#if os(WASI)
+import WASILibc
+
+@discardableResult
+public func pthread_mutex_init(_ mutex: UnsafeMutablePointer<pthread_mutex_t>?, _ attributes: UnsafePointer<pthread_mutexattr_t>?) -> Int32 { 0 }
+
+@discardableResult
+public func pthread_mutex_destroy(_ mutex: UnsafeMutablePointer<pthread_mutex_t>?) -> Int32 { 0 }
+
+@discardableResult
+public func pthread_mutex_lock(_ mutex: UnsafeMutablePointer<pthread_mutex_t>?) -> Int32 { 0 }
+
+@discardableResult
+public func pthread_mutex_trylock(_ mutex: UnsafeMutablePointer<pthread_mutex_t>?) -> Int32 { 0 }
+
+@discardableResult
+public func pthread_mutex_unlock(_ mutex: UnsafeMutablePointer<pthread_mutex_t>?) -> Int32 { 0 }
+
+@discardableResult
+public func pthread_mutexattr_init(_ attributes: UnsafeMutablePointer<pthread_mutexattr_t>?) -> Int32 { 0 }
+
+@discardableResult
+public func pthread_mutexattr_destroy(_ attributes: UnsafeMutablePointer<pthread_mutexattr_t>?) -> Int32 { 0 }
+
+@discardableResult
+public func pthread_mutexattr_settype(_ attributes: UnsafeMutablePointer<pthread_mutexattr_t>?, _ type: Int32) -> Int32 { 0 }
+
+/// `PTHREAD_MUTEX_RECURSIVE` and friends, which the libc module leaves out with `pthread.h`.
+public var PTHREAD_MUTEX_NORMAL: Int32 { 0 }
+public var PTHREAD_MUTEX_RECURSIVE: Int32 { 1 }
+public var PTHREAD_MUTEX_ERRORCHECK: Int32 { 2 }
+public var PTHREAD_MUTEX_DEFAULT: Int32 { 0 }
+#endif