WebEngine.swift

// SPDX-License-Identifier: LGPL-3.0-only WITH LGPL-3.0-linking-exception
#if !SKIP_BRIDGE
import Foundation
import SwiftUI
#if !SKIP
import WebKit
import UniformTypeIdentifiers
import CryptoKit
#else
import android.graphics.Bitmap
import android.graphics.Canvas
import androidx.webkit.WebViewCompat
import androidx.webkit.WebViewFeature
import kotlin.coroutines.suspendCoroutine
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlin.coroutines.resume
import kotlinx.coroutines.async
import kotlinx.coroutines.launch
#endif

#if SKIP || os(iOS)


public struct SkipWebSnapshotRect: Equatable, Sendable {
    public static let null = SkipWebSnapshotRect(x: 0.0, y: 0.0, width: -1.0, height: -1.0)

    public var x: Double
    public var y: Double
    public var width: Double
    public var height: Double

    public init(x: Double, y: Double, width: Double, height: Double) {
        self.x = x
        self.y = y
        self.width = width
        self.height = height
    }

    public var isNull: Bool {
        width < 0.0 || height < 0.0
    }

    fileprivate var asCGRect: CGRect {
        isNull ? .null : CGRect(x: x, y: y, width: width, height: height)
    }
}

/// Snapshot configuration for `WebEngine.takeSnapshot(configuration:)`.
///
/// This mirrors the key behavior of `WKSnapshotConfiguration`:
/// - `rect`: view-coordinate capture region (`.null` means full visible bounds)
/// - `snapshotWidth`: optional output width while preserving aspect ratio
/// - `afterScreenUpdates`: capture after pending updates when possible
public struct SkipWebSnapshotConfiguration {
    public var rect: SkipWebSnapshotRect
    public var snapshotWidth: Double?
    public var afterScreenUpdates: Bool

    public init(rect: SkipWebSnapshotRect = .null, snapshotWidth: Double? = nil, afterScreenUpdates: Bool = true) {
        self.rect = rect
        self.snapshotWidth = snapshotWidth
        self.afterScreenUpdates = afterScreenUpdates
    }
}

/// A captured web-view snapshot stored as PNG bytes plus pixel dimensions.
public struct SkipWebSnapshot {
    public let pngData: Data
    public let pixelWidth: Int
    public let pixelHeight: Int

    public init(pngData: Data, pixelWidth: Int, pixelHeight: Int) {
        self.pngData = pngData
        self.pixelWidth = pixelWidth
        self.pixelHeight = pixelHeight
    }
}

public enum WebSnapshotError: Error {
    case viewNotLaidOut
    case afterScreenUpdatesUnavailable
    case invalidRect
    case emptySnapshot
    case pngEncodingFailed
}

/// Portable cookie representation shared by iOS and Android implementations.
public struct WebCookie: Equatable, Hashable, Sendable {
    public var name: String
    public var value: String
    public var domain: String?
    public var path: String?
    public var expires: Date?
    public var isSecure: Bool
    public var isHTTPOnly: Bool

    public init(
        name: String,
        value: String,
        domain: String? = nil,
        path: String? = nil,
        expires: Date? = nil,
        isSecure: Bool = false,
        isHTTPOnly: Bool = false
    ) {
        self.name = name
        self.value = value
        self.domain = domain
        self.path = path
        self.expires = expires
        self.isSecure = isSecure
        self.isHTTPOnly = isHTTPOnly
    }
}

public enum WebCookieError: Error {
    case invalidCookieName
    case missingCookieDomain
    case invalidCookie
}

public enum WebProfile: Equatable, Hashable, Sendable {
    case `default`
    case named(String)

    fileprivate var normalizedNamedIdentifier: String? {
        guard case .named(let rawIdentifier) = self else {
            return nil
        }
        let identifier = rawIdentifier.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !identifier.isEmpty else {
            return nil
        }
        if identifier.lowercased() == "default" {
            return nil
        }
        return identifier
    }
}

public enum WebProfileError: Error, Equatable {
    case unsupportedOnAndroid
    case invalidProfileName
    case profileSetupFailed
}

public enum WebSiteDataType: String, CaseIterable, Hashable, Sendable {
    case cookies
    case diskCache
    case memoryCache
    case offlineWebApplicationCache
    case localStorage
    case sessionStorage
    case webSQLDatabases
    case indexedDBDatabases
}

public enum WebDataRemovalError: Error, Equatable {
    case unsupportedModifiedSinceOnAndroid
}

enum WebDataRemovalBucket: Hashable {
    case cookies
    case cache
    case storage
}

extension WebSiteDataType {
    var androidRemovalBucket: WebDataRemovalBucket {
        switch self {
        case .cookies:
            return .cookies
        case .diskCache, .memoryCache, .offlineWebApplicationCache:
            return .cache
        case .localStorage, .sessionStorage, .webSQLDatabases, .indexedDBDatabases:
            return .storage
        }
    }

    #if !SKIP
    var webKitDataType: String {
        switch self {
        case .cookies:
            return WKWebsiteDataTypeCookies
        case .diskCache:
            return WKWebsiteDataTypeDiskCache
        case .memoryCache:
            return WKWebsiteDataTypeMemoryCache
        case .offlineWebApplicationCache:
            return WKWebsiteDataTypeOfflineWebApplicationCache
        case .localStorage:
            return WKWebsiteDataTypeLocalStorage
        case .sessionStorage:
            return WKWebsiteDataTypeSessionStorage
        case .webSQLDatabases:
            return WKWebsiteDataTypeWebSQLDatabases
        case .indexedDBDatabases:
            return WKWebsiteDataTypeIndexedDBDatabases
        }
    }
    #endif
}

extension WebCookie {
    func matches(url: URL, now: Date = Date()) -> Bool {
        guard let host = url.host?.lowercased(), !host.isEmpty else {
            return false
        }
        if isSecure && (url.scheme?.lowercased() != "https") {
            return false
        }
        if let expires, expires <= now {
            return false
        }

        if let domain = normalizedDomain, !domain.isEmpty {
            // Treat no-dot domains as host-only so they don't leak to subdomains.
            if isHostOnlyDomain {
                if host != domain {
                    return false
                }
            } else if host != domain && !host.hasSuffix("." + domain) {
                return false
            }
        }

        let requestPath = normalizedRequestPath(url.path)
        let cookiePath = normalizedCookiePath
        // Enforce RFC-style path boundary matching ("/a" does not match "/ab").
        return requestPathMatchesCookiePath(requestPath, cookiePath: cookiePath)
    }

    static func parseRequestCookieHeader(_ header: String) -> [WebCookie] {
        let rawComponents = header.split(separator: ";")
        var cookies: [WebCookie] = []
        for rawComponent in rawComponents {
            let component = String(rawComponent).trimmingCharacters(in: .whitespacesAndNewlines)
            if component.isEmpty {
                continue
            }
            guard let equalIndex = component.firstIndex(of: "=") else {
                continue
            }
            let name = String(component[..<equalIndex]).trimmingCharacters(in: .whitespacesAndNewlines)
            let valueIndex = component.index(after: equalIndex)
            let value = String(component[valueIndex...]).trimmingCharacters(in: .whitespacesAndNewlines)
            if name.isEmpty {
                continue
            }
            cookies.append(WebCookie(name: name, value: value))
        }
        return cookies
    }

    static func parseSetCookieHeaders(_ headers: [String], responseURL: URL) -> [WebCookie] {
        #if !SKIP
        var parsedCookies: [WebCookie] = []
        for header in headers {
            let trimmed = header.trimmingCharacters(in: .whitespacesAndNewlines)
            if trimmed.isEmpty {
                continue
            }
            let nativeCookies = HTTPCookie.cookies(
                withResponseHeaderFields: ["Set-Cookie": trimmed],
                for: responseURL
            )
            for nativeCookie in nativeCookies {
                parsedCookies.append(WebCookie(nativeCookie: nativeCookie))
            }
        }
        return parsedCookies
        #else
        var parsedCookies: [WebCookie] = []
        for header in headers {
            if let cookie = parseSingleSetCookieHeader(header, responseURL: responseURL) {
                parsedCookies.append(cookie)
            }
        }
        return parsedCookies
        #endif
    }

    fileprivate static func parseSingleSetCookieHeader(_ header: String, responseURL: URL) -> WebCookie? {
        let segments = header.split(separator: ";")
        guard let firstSegment = segments.first else {
            return nil
        }
        let first = String(firstSegment).trimmingCharacters(in: .whitespacesAndNewlines)
        guard let firstEqualIndex = first.firstIndex(of: "=") else {
            return nil
        }

        let name = String(first[..<firstEqualIndex]).trimmingCharacters(in: .whitespacesAndNewlines)
        let valueStartIndex = first.index(after: firstEqualIndex)
        let value = String(first[valueStartIndex...]).trimmingCharacters(in: .whitespacesAndNewlines)
        if name.isEmpty {
            return nil
        }

        var domain: String? = responseURL.host
        var path: String? = "/"
        var expires: Date?
        var isSecure = false
        var isHTTPOnly = false

        if segments.count > 1 {
            for segmentIndex in 1..<segments.count {
                let rawAttribute = String(segments[segmentIndex]).trimmingCharacters(in: .whitespacesAndNewlines)
                if rawAttribute.isEmpty {
                    continue
                }

                let lowercasedAttribute = rawAttribute.lowercased()
                if lowercasedAttribute == "secure" {
                    isSecure = true
                    continue
                }
                if lowercasedAttribute == "httponly" {
                    isHTTPOnly = true
                    continue
                }

                guard let equalIndex = rawAttribute.firstIndex(of: "=") else {
                    continue
                }
                let key = String(rawAttribute[..<equalIndex]).trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
                let valueIndex = rawAttribute.index(after: equalIndex)
                let attributeValue = String(rawAttribute[valueIndex...]).trimmingCharacters(in: .whitespacesAndNewlines)
                if attributeValue.isEmpty {
                    continue
                }

                if key == "domain" {
                    // Preserve "Domain=" semantics as subdomain-capable for matching.
                    domain = attributeValue.hasPrefix(".") ? attributeValue : "." + attributeValue
                } else if key == "path" {
                    path = attributeValue
                } else if key == "max-age", let maxAgeSeconds = Int(attributeValue) {
                    expires = Date(timeIntervalSinceNow: TimeInterval(maxAgeSeconds))
                }
            }
        }

        return WebCookie(
            name: name,
            value: value,
            domain: domain,
            path: path,
            expires: expires,
            isSecure: isSecure,
            isHTTPOnly: isHTTPOnly
        )
    }

    fileprivate var normalizedDomain: String? {
        guard let domain else {
            return nil
        }
        let trimmed = domain.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
        if trimmed.isEmpty {
            return nil
        }
        if trimmed.hasPrefix(".") {
            let start = trimmed.index(after: trimmed.startIndex)
            let stripped = String(trimmed[start...])
            return stripped.isEmpty ? nil : stripped
        }
        return trimmed
    }

    fileprivate var isHostOnlyDomain: Bool {
        // A leading dot indicates explicit subdomain matching semantics.
        guard let domain else {
            return false
        }
        let trimmed = domain.trimmingCharacters(in: .whitespacesAndNewlines)
        guard !trimmed.isEmpty else {
            return false
        }
        return !trimmed.hasPrefix(".")
    }

    fileprivate var normalizedCookiePath: String {
        guard let rawPath = path?.trimmingCharacters(in: .whitespacesAndNewlines), !rawPath.isEmpty else {
            return "/"
        }
        if rawPath.hasPrefix("/") {
            return rawPath
        }
        return "/" + rawPath
    }

    fileprivate func normalizedRequestPath(_ requestPath: String) -> String {
        if requestPath.isEmpty {
            return "/"
        }
        if requestPath.hasPrefix("/") {
            return requestPath
        }
        return "/" + requestPath
    }

    fileprivate func requestPathMatchesCookiePath(_ requestPath: String, cookiePath: String) -> Bool {
        // Follow cookie path-match rules so sibling prefixes are not accepted.
        if requestPath == cookiePath {
            return true
        }
        if !requestPath.hasPrefix(cookiePath) {
            return false
        }
        if cookiePath.hasSuffix("/") {
            return true
        }
        let boundaryIndex = requestPath.index(requestPath.startIndex, offsetBy: cookiePath.count)
        return boundaryIndex < requestPath.endIndex && requestPath[boundaryIndex] == "/"
    }

    fileprivate func androidTargetURL(requestURL: URL?) -> URL? {
        if let requestURL {
            return requestURL
        }
        guard let domain = normalizedDomain, !domain.isEmpty else {
            return nil
        }
        let normalizedPath = normalizedCookiePath
        return URL(string: "https://\(domain)\(normalizedPath)")
    }

    fileprivate func asAndroidSetCookieString(requestURL: URL?) throws -> String {
        if name.isEmpty {
            throw WebCookieError.invalidCookieName
        }

        var cookieParts: [String] = ["\(name)=\(value)"]
        if let domain = normalizedDomain, !domain.isEmpty {
            cookieParts.append("Domain=\(domain)")
        } else if let fallbackDomain = requestURL?.host?.lowercased(), !fallbackDomain.isEmpty {
            cookieParts.append("Domain=\(fallbackDomain)")
        } else {
            throw WebCookieError.missingCookieDomain
        }

        cookieParts.append("Path=\(normalizedCookiePath)")

        if let expires {
            let maxAge = max(0, Int(expires.timeIntervalSinceNow.rounded()))
            cookieParts.append("Max-Age=\(maxAge)")
        }
        if isSecure {
            cookieParts.append("Secure")
        }
        if isHTTPOnly {
            cookieParts.append("HttpOnly")
        }
        return cookieParts.joined(separator: "; ")
    }
}

#if !SKIP
extension WebCookie {
    fileprivate init(nativeCookie: HTTPCookie) {
        self.init(
            name: nativeCookie.name,
            value: nativeCookie.value,
            domain: nativeCookie.domain,
            path: nativeCookie.path,
            expires: nativeCookie.expiresDate,
            isSecure: nativeCookie.isSecure,
            isHTTPOnly: nativeCookie.isHTTPOnly
        )
    }

    fileprivate func asNativeCookie(requestURL: URL?) throws -> HTTPCookie {
        if name.isEmpty {
            throw WebCookieError.invalidCookieName
        }
        // Preserve an explicit leading-dot domain so domain cookies keep subdomain scope.
        let explicitDomain = domain?
            .trimmingCharacters(in: .whitespacesAndNewlines)
            .lowercased()
        let fallbackDomain = requestURL?.host?.lowercased()
        guard let effectiveDomain = (explicitDomain?.isEmpty == false ? explicitDomain : nil) ?? fallbackDomain, !effectiveDomain.isEmpty else {
            throw WebCookieError.missingCookieDomain
        }

        var properties: [HTTPCookiePropertyKey: Any] = [
            .name: name,
            .value: value,
            .domain: effectiveDomain,
            .path: normalizedCookiePath
        ]
        if let expires {
            properties[.expires] = expires
        }
        if isSecure {
            properties[.secure] = "TRUE"
        }
        if isHTTPOnly {
            properties[HTTPCookiePropertyKey("HttpOnly")] = "TRUE"
        }

        guard let nativeCookie = HTTPCookie(properties: properties) else {
            throw WebCookieError.invalidCookie
        }
        return nativeCookie
    }
}
#endif

/// An web engine that holds a system web view:
/// [`WebKit.WKWebView`](https://developer.apple.com/documentation/webkit/wkwebview) on iOS and
/// [`android.webkit.WebView`](https://developer.android.com/reference/android/webkit/WebView) on Android
///
/// The `WebEngine` is used both as the render for a `WebView` and `BrowserView`,
/// and can also be used in a headless context to drive web pages
/// and evaluate JavaScript.
@MainActor public class WebEngine : WebObjectBase {
    public let configuration: WebEngineConfiguration
    public let webView: PlatformWebView
    #if !SKIP
    public override var description: String {
        "WebEngine: \(webView)"
    }
    private var observers: [NSKeyValueObservation] = []
    private var profileSetupError: WebProfileError?
    #else
    private var profileSetupError: WebProfileError?
    private var androidProfileCookieManager: android.webkit.CookieManager?
    private var androidProfileWebStorage: android.webkit.WebStorage?
    #endif

    /// Create a WebEngine with the specified configuration.
    /// - Parameters:
    ///   - configuration: the configuration to use
    ///   - webView: when set, the given platform-specific web view will
    public init(configuration: WebEngineConfiguration = WebEngineConfiguration(), webView: PlatformWebView? = nil) {
        self.configuration = configuration

        #if !SKIP
        self.webView = webView ?? WKWebView(frame: .zero, configuration: configuration.webViewConfiguration)
        if case .named = configuration.profile, configuration.profile.normalizedNamedIdentifier == nil {
            self.profileSetupError = .invalidProfileName
        }
        #else
        // fall back to using the global android context if the activity context is not set in the configuration
        self.webView = webView ?? PlatformWebView(configuration.context ?? ProcessInfo.processInfo.androidContext)
        switch Self.configureAndroidProfile(configuration.profile, for: self.webView) {
        case .success(let androidProfileResources):
            self.androidProfileCookieManager = androidProfileResources.cookieManager
            self.androidProfileWebStorage = androidProfileResources.webStorage
            self.profileSetupError = nil
        case .failure(let error):
            self.profileSetupError = error
        }
        #endif
    }

    public func reload() {
        if profileSetupError != nil {
            return
        }
        webView.reload()
    }

    public func stopLoading() {
        if profileSetupError != nil {
            return
        }
        webView.stopLoading()
    }

    public func go(to item: WebHistoryItem) {
        if profileSetupError != nil {
            return
        }
        #if !SKIP
        webView.go(to: item.item)
        #else
        // TODO: there's no "go" equivalent in WebView, so we'll probably need to use `goBackOrForward(int steps)` based on matching the item in the back/forward list
        #endif
    }

    public func goBack() {
        if profileSetupError != nil {
            return
        }
        webView.goBack()
    }

    public func goForward() {
        if profileSetupError != nil {
            return
        }
        webView.goForward()
    }

    /// Preferred URL accessor for parity with `WKWebView.url`.
    /// A typed `URL` keeps call sites aligned with Apple WebKit ergonomics.
    public var url: URL? {
        #if SKIP
        guard let raw = webView.getUrl() else {
            return nil
        }
        return URL(string: raw)
        #else
        webView.url
        #endif
    }

    /// Evaluates the given JavaScript string and returns the resulting JSON string, which may be a top-level fragment
    public func evaluate(js: String) async throws -> String? {
        try throwProfileSetupErrorIfNeeded()
        return try await evaluateJavaScriptAsync(js)
    }

    static func androidRemovalBuckets(for types: Set<WebSiteDataType>) -> Set<WebDataRemovalBucket> {
        var buckets = Set<WebDataRemovalBucket>()
        for type in types {
            buckets.insert(type.androidRemovalBucket)
        }
        return buckets
    }

    static func profileValidationError(for profile: WebProfile) -> WebProfileError? {
        switch profile {
        case .default:
            return nil
        case .named:
            return profile.normalizedNamedIdentifier == nil ? .invalidProfileName : nil
        }
    }

    private func throwProfileSetupErrorIfNeeded() throws {
        if let profileSetupError {
            throw profileSetupError
        }
    }

    #if SKIP
    struct AndroidProfileResources {
        let cookieManager: android.webkit.CookieManager?
        let webStorage: android.webkit.WebStorage?
    }

    public static func isAndroidMultiProfileSupported() -> Bool {
        WebViewFeature.isFeatureSupported(WebViewFeature.MULTI_PROFILE)
    }

    private static func configureAndroidProfile(_ profile: WebProfile, for webView: PlatformWebView) -> Result<AndroidProfileResources, WebProfileError> {
        if let supportError = androidProfileSupportError(for: profile, isMultiProfileFeatureSupported: isAndroidMultiProfileSupported()) {
            return .failure(supportError)
        }

        switch profile {
        case .default:
            return .success(AndroidProfileResources(cookieManager: nil, webStorage: nil))
        case .named:
            guard let identifier = profile.normalizedNamedIdentifier else {
                return .failure(.invalidProfileName)
            }
            guard applyAndroidProfile(identifier, to: webView) else {
                return .failure(.profileSetupFailed)
            }
            let profile = WebViewCompat.getProfile(webView)
            return .success(
                AndroidProfileResources(
                    cookieManager: profile.getCookieManager(),
                    webStorage: profile.getWebStorage()
                )
            )
        }
    }

    static func androidProfileSupportError(for profile: WebProfile, isMultiProfileFeatureSupported: Bool) -> WebProfileError? {
        if let validationError = profileValidationError(for: profile) {
            return validationError
        }
        switch profile {
        case .default:
            return nil
        case .named:
            return isMultiProfileFeatureSupported ? nil : .unsupportedOnAndroid
        }
    }

    @discardableResult
    func inheritAndroidProfile(from parentProfile: WebProfile) -> WebProfileError? {
        if configuration.profile == parentProfile, profileSetupError == nil {
            return nil
        }
        configuration.profile = parentProfile
        switch Self.configureAndroidProfile(parentProfile, for: webView) {
        case .success(let androidProfileResources):
            self.androidProfileCookieManager = androidProfileResources.cookieManager
            self.androidProfileWebStorage = androidProfileResources.webStorage
            self.profileSetupError = nil
            return nil
        case .failure(let error):
            self.profileSetupError = error
            return error
        }
    }

    private static func applyAndroidProfile(_ identifier: String, to webView: PlatformWebView) -> Bool {
        // SKIP INSERT: try { androidx.webkit.WebViewCompat.setProfile(webView, identifier); return true } catch (t: Throwable) { return false }
        WebViewCompat.setProfile(webView, identifier)
        return true
    }

    private func androidCookieManager() -> android.webkit.CookieManager {
        androidProfileCookieManager ?? android.webkit.CookieManager.getInstance()
    }

    private func androidWebStorage() -> android.webkit.WebStorage {
        androidProfileWebStorage ?? android.webkit.WebStorage.getInstance()
    }
    #endif

    static func androidRemovalBucketNames(for types: Set<WebSiteDataType>) -> Set<String> {
        var names = Set<String>()
        for bucket in androidRemovalBuckets(for: types) {
            switch bucket {
            case .cookies:
                names.insert("cookies")
            case .cache:
                names.insert("cache")
            case .storage:
                names.insert("storage")
            }
        }
        return names
    }

    #if !SKIP
    static func webKitDataTypes(for types: Set<WebSiteDataType>) -> Set<String> {
        var mapped = Set<String>()
        for type in types {
            mapped.insert(type.webKitDataType)
        }
        return mapped
    }
    #endif

    public func cookies(for url: URL) async -> [WebCookie] {
        if profileSetupError != nil {
            return []
        }
        #if !SKIP
        let store = webView.configuration.websiteDataStore.httpCookieStore
        let allCookies = await getAllCookies(from: store)
        var filtered: [WebCookie] = []
        for nativeCookie in allCookies {
            let webCookie = WebCookie(nativeCookie: nativeCookie)
            if webCookie.matches(url: url) {
                filtered.append(webCookie)
            }
        }
        return filtered
        #else
        let cookieHeader = androidCookieManager().getCookie(url.absoluteString) ?? ""
        if cookieHeader.isEmpty {
            return []
        }
        return WebCookie.parseRequestCookieHeader(cookieHeader)
        #endif
    }

    public func cookieHeader(for url: URL) async -> String? {
        if profileSetupError != nil {
            return nil
        }
        #if !SKIP
        let matchingCookies = await cookies(for: url)
        if matchingCookies.isEmpty {
            return nil
        }
        var cookiePairs: [String] = []
        for cookie in matchingCookies {
            cookiePairs.append("\(cookie.name)=\(cookie.value)")
        }
        return cookiePairs.joined(separator: "; ")
        #else
        let cookieHeader = androidCookieManager().getCookie(url.absoluteString) ?? ""
        return cookieHeader.isEmpty ? nil : cookieHeader
        #endif
    }

    public func setCookie(_ cookie: WebCookie, requestURL: URL? = nil) async throws {
        try throwProfileSetupErrorIfNeeded()
        #if !SKIP
        let nativeCookie = try cookie.asNativeCookie(requestURL: requestURL)
        let store = webView.configuration.websiteDataStore.httpCookieStore
        await setCookie(nativeCookie, in: store)
        #else
        let targetURL = cookie.androidTargetURL(requestURL: requestURL)
        guard let targetURL else {
            throw WebCookieError.missingCookieDomain
        }
        let cookieString = try cookie.asAndroidSetCookieString(requestURL: requestURL)
        let cookieManager = androidCookieManager()
        await setAndroidCookie(cookieManager, forURLString: targetURL.absoluteString, cookieString: cookieString)
        #endif
    }

    public func applySetCookieHeaders(_ headers: [String], for responseURL: URL) async throws {
        try throwProfileSetupErrorIfNeeded()
        #if !SKIP
        let parsedCookies = WebCookie.parseSetCookieHeaders(headers, responseURL: responseURL)
        for cookie in parsedCookies {
            try await setCookie(cookie, requestURL: responseURL)
        }
        #else
        let cookieManager = androidCookieManager()
        let targetURLString = responseURL.absoluteString
        for header in headers {
            let trimmed = header.trimmingCharacters(in: .whitespacesAndNewlines)
            if trimmed.isEmpty {
                continue
            }
            await setAndroidCookie(cookieManager, forURLString: targetURLString, cookieString: trimmed)
        }
        #endif
    }

    public func clearCookies() async {
        if profileSetupError != nil {
            return
        }
        #if !SKIP
        let store = webView.configuration.websiteDataStore.httpCookieStore
        let allCookies = await getAllCookies(from: store)
        for cookie in allCookies {
            await deleteCookie(cookie, from: store)
        }
        #else
        let cookieManager = androidCookieManager()
        await removeAllAndroidCookies(cookieManager)
        #endif
    }

    @MainActor
    public func removeData(ofTypes types: Set<WebSiteDataType>, modifiedSince: Date) async throws {
        try throwProfileSetupErrorIfNeeded()
        if types.isEmpty {
            return
        }

        #if !SKIP
        let webKitTypes = Self.webKitDataTypes(for: types)
        if webKitTypes.isEmpty {
            return
        }
        await removeData(
            from: webView.configuration.websiteDataStore,
            ofTypes: webKitTypes,
            modifiedSince: modifiedSince
        )
        #else
        if modifiedSince != .distantPast {
            throw WebDataRemovalError.unsupportedModifiedSinceOnAndroid
        }

        let buckets = Self.androidRemovalBuckets(for: types)
        if buckets.contains(.cookies) {
            await removeAllAndroidCookies(androidCookieManager())
        }
        if buckets.contains(.cache) {
            webView.clearCache(true)
        }
        if buckets.contains(.storage) {
            androidWebStorage().deleteAllData()
        }
        #endif
    }

    @MainActor public func takeSnapshot(configuration: SkipWebSnapshotConfiguration? = nil) async throws -> SkipWebSnapshot {
        try throwProfileSetupErrorIfNeeded()
        let config = configuration ?? SkipWebSnapshotConfiguration()

        #if !SKIP
        let platformConfig = WKSnapshotConfiguration()
        platformConfig.rect = config.rect.asCGRect
        if let snapshotWidth = config.snapshotWidth {
            platformConfig.snapshotWidth = NSNumber(value: snapshotWidth)
        }
        platformConfig.afterScreenUpdates = config.afterScreenUpdates

        let snapshotImage = try await webView.takeSnapshot(configuration: platformConfig)
        guard let pngData = snapshotImage.pngData() else {
            throw WebSnapshotError.pngEncodingFailed
        }

        let pixelWidth = Int(snapshotImage.size.width * snapshotImage.scale)
        let pixelHeight = Int(snapshotImage.size.height * snapshotImage.scale)
        return SkipWebSnapshot(
            pngData: pngData,
            pixelWidth: pixelWidth,
            pixelHeight: pixelHeight
        )
        #else
        let sourceWidth = Int(webView.getWidth())
        let sourceHeight = Int(webView.getHeight())
        guard sourceWidth > 0, sourceHeight > 0 else {
            throw WebSnapshotError.viewNotLaidOut
        }

        if config.afterScreenUpdates {
            let didScheduleUIUpdateWait: Bool = suspendCancellableCoroutine { continuation in
                let scheduled = webView.post {
                    continuation.resume(true)
                }
                guard scheduled else {
                    continuation.resume(false)
                    return
                }
                continuation.invokeOnCancellation { _ in
                    continuation.cancel()
                }
            }
            guard didScheduleUIUpdateWait else {
                throw WebSnapshotError.afterScreenUpdatesUnavailable
            }
        }

        let fullRect = CGRect(x: 0.0, y: 0.0, width: CGFloat(sourceWidth), height: CGFloat(sourceHeight))
        let requestedRect = config.rect.isNull ? fullRect : config.rect.asCGRect
        let clampedRect = requestedRect.intersection(fullRect)
        let minX = max(0, Int(floor(clampedRect.minX)))
        let minY = max(0, Int(floor(clampedRect.minY)))
        let maxX = min(sourceWidth, Int(ceil(clampedRect.maxX)))
        let maxY = min(sourceHeight, Int(ceil(clampedRect.maxY)))
        let captureWidth = maxX - minX
        let captureHeight = maxY - minY
        guard captureWidth > 0, captureHeight > 0 else {
            throw WebSnapshotError.invalidRect
        }

        let targetWidth: Int
        if let snapshotWidth = config.snapshotWidth {
            guard snapshotWidth > 0 else {
                throw WebSnapshotError.invalidRect
            }
            targetWidth = max(1, Int(snapshotWidth.rounded()))
        } else {
            targetWidth = captureWidth
        }
        let targetHeight = max(1, Int((Double(captureHeight) * (Double(targetWidth) / Double(captureWidth))).rounded()))

        let bitmap = Bitmap.createBitmap(targetWidth, targetHeight, Bitmap.Config.ARGB_8888)
        let canvas = Canvas(bitmap)
        let scaleX = Float(Double(targetWidth) / Double(captureWidth))
        let scaleY = Float(Double(targetHeight) / Double(captureHeight))
        let scrollX = Int(webView.getScrollX())
        let scrollY = Int(webView.getScrollY())
        canvas.scale(scaleX, scaleY)
        // Android WebView drawing is offset by the current scroll position,
        // so we must compensate or the snapshot is padded by blank space.
        canvas.translate(-Float(minX + scrollX), -Float(minY + scrollY))
        webView.draw(canvas)

        let outputStream = java.io.ByteArrayOutputStream()
        let encoded = bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
        bitmap.recycle()
        guard encoded else {
            throw WebSnapshotError.pngEncodingFailed
        }

        let base64 = android.util.Base64.encodeToString(outputStream.toByteArray(), android.util.Base64.NO_WRAP)
        guard let pngData: Data = Data(base64Encoded: base64, options: []) else {
            throw WebSnapshotError.pngEncodingFailed
        }
        return SkipWebSnapshot(
            pngData: pngData,
            pixelWidth: targetWidth,
            pixelHeight: targetHeight
        )
        #endif
    }

    public func loadHTML(_ html: String, baseURL: URL? = nil, mimeType: String = "text/html") {
        if profileSetupError != nil {
            return
        }
        logger.info("loadHTML webView: \(self.description)")
        let encoding: String = "UTF-8"

        #if SKIP
        // see https://developer.android.com/reference/android/webkit/WebView#loadDataWithBaseURL(java.lang.String,%20java.lang.String,%20java.lang.String,%20java.lang.String,%20java.lang.String)
        let baseUrl: String? = baseURL?.absoluteString // the URL to use as the page's base URL. If null defaults to 'about:blank'
        //var htmlContent = android.util.Base64.encodeToString(html.toByteArray(), android.util.Base64.NO_PADDING)
        var htmlContent = html
        let historyUrl: String? = nil // the URL to use as the history entry. If null defaults to 'about:blank'. If non-null, this must be a valid URL.
        webView.loadDataWithBaseURL(baseUrl, htmlContent, mimeType, encoding, historyUrl)
        #else
        refreshMessageHandlers()
        //try await awaitPageLoaded {
        webView.load(Data(html.utf8), mimeType: mimeType, characterEncodingName: encoding, baseURL: baseURL ?? URL(string: "about:blank")!)
        //}
        #endif
    }

    /// Asyncronously load the given URL, returning once the page has been loaded or an error has occurred
    public func load(url: URL) async throws {
        try throwProfileSetupErrorIfNeeded()
        let urlString = url.absoluteString
        logger.info("load URL=\(urlString) webView: \(self.description)")
        try await awaitPageLoaded {
            #if SKIP
            webView.loadUrl(urlString ?? "about:blank")
            #else
            if url.isFileURL {
                webView.loadFileURL(url, allowingReadAccessTo: url)
            } else {
                webView.load(URLRequest(url: url))
            }
            #endif
        }
    }

    fileprivate func evaluateJavaScriptAsync(_ script: String) async throws -> String? {
        #if !SKIP
        let evaluated: Any? = try await webView.evaluateJavaScript(script) // cast needed for older iOS, or else: "error: initializer for conditional binding must have Optional type, not 'Any'"
        guard let result = evaluated else {
            return nil
        }
        // in order to match the behavior of Android's evaluateJavascript, we need to return the result as a serialized JavaScript string that can contain fragments (e.g., top-level strings)
        let data = try JSONSerialization.data(withJSONObject: result, options: [.fragmentsAllowed, .withoutEscapingSlashes])
        return String(data: data, encoding: .utf8)
        #else
        logger.info("WebEngine: calling eval: \(android.os.Looper.myLooper())")
        suspendCancellableCoroutine { continuation in
            logger.info("WebEngine: calling eval suspendCoroutine: \(android.os.Looper.myLooper())")
            webView.evaluateJavascript(script) { result in
                logger.info("WebEngine: returned webView.evaluateJavascript: \(android.os.Looper.myLooper()): \(result)")
                continuation.resume(result)
            }

            continuation.invokeOnCancellation { _ in
                continuation.cancel()
            }
        }
        #endif
    }

    #if !SKIP
    private func getAllCookies(from cookieStore: WKHTTPCookieStore) async -> [HTTPCookie] {
        await withCheckedContinuation { continuation in
            cookieStore.getAllCookies { cookies in
                continuation.resume(returning: cookies)
            }
        }
    }

    private func setCookie(_ cookie: HTTPCookie, in cookieStore: WKHTTPCookieStore) async {
        await withCheckedContinuation { continuation in
            cookieStore.setCookie(cookie) {
                continuation.resume(returning: ())
            }
        }
    }

    private func deleteCookie(_ cookie: HTTPCookie, from cookieStore: WKHTTPCookieStore) async {
        await withCheckedContinuation { continuation in
            cookieStore.delete(cookie) {
                continuation.resume(returning: ())
            }
        }
    }

    private func removeData(from dataStore: WKWebsiteDataStore, ofTypes types: Set<String>, modifiedSince: Date) async {
        await withCheckedContinuation { continuation in
            dataStore.removeData(ofTypes: types, modifiedSince: modifiedSince) {
                continuation.resume(returning: ())
            }
        }
    }
    #else
    nonisolated private func setAndroidCookie(
        _ cookieManager: android.webkit.CookieManager,
        forURLString urlString: String,
        cookieString: String
    ) async {
        cookieManager.setCookie(urlString, cookieString, nil)
        cookieManager.flush()
        // Android cookie writes are asynchronous; a short delay avoids racing immediate reads.
        try? await Task.sleep(nanoseconds: 50_000_000)
    }

    nonisolated private func removeAllAndroidCookies(_ cookieManager: android.webkit.CookieManager) async {
        cookieManager.removeAllCookies(nil)
        cookieManager.flush()
        // Mirror setCookie behavior: allow async cookie-store mutation to settle before reads.
        try? await Task.sleep(nanoseconds: 50_000_000)
    }
    #endif

    /// Perform the given block and only return once the page has completed loading
    // SKIP @nobridge
    public func awaitPageLoaded(_ block: () -> ()) async throws {
        try throwProfileSetupErrorIfNeeded()
        let pdelegate = self.engineDelegate
        defer { self.engineDelegate = pdelegate }

        // need to retain the navigation delegate or else it will drop the continuation
        var loadDelegate: PageLoadDelegate? = nil

        let _: Void? = try await withCheckedThrowingContinuation { continuation in
            loadDelegate = PageLoadDelegate(config: configuration) { result in
                continuation.resume(with: result)
            }

            self.engineDelegate = loadDelegate
            logger.log("WebEngine: awaitPageLoaded block()")
            block()
        }
    }
    
    #if !SKIP
    var registeredMessageHandlerNames = Set<String>()
    
    fileprivate static var systemMessageHandlers: [String] {
        [
            "skipConsoleLog"
        ]
    }

    @MainActor
    public func refreshMessageHandlers() {
        let userContentController = webView.configuration.userContentController
        for messageHandlerName in Self.systemMessageHandlers + configuration.messageHandlers.keys {
            if registeredMessageHandlerNames.contains(messageHandlerName) { continue }

            // Sometimes we reuse an underlying WKWebView for a new SwiftUI component.
            userContentController.removeScriptMessageHandler(forName: messageHandlerName, contentWorld: .page)
            userContentController.add(self, contentWorld: .page, name: messageHandlerName)
            registeredMessageHandlerNames.insert(messageHandlerName)
        }
        for missing in registeredMessageHandlerNames.subtracting(Self.systemMessageHandlers + configuration.messageHandlers.keys) {
            userContentController.removeScriptMessageHandler(forName: missing)
            registeredMessageHandlerNames.remove(missing)
        }
    }
    
    @MainActor
    public func updateUserScripts() {
        let userContentController = webView.configuration.userContentController
        let allScripts = WebViewUserScript.systemScripts + configuration.userScripts
        if userContentController.userScripts.sorted(by: { $0.source > $1.source }) != allScripts.map({ $0.webKitUserScript }).sorted(by: { $0.source > $1.source }) {
            userContentController.removeAllUserScripts()
            for script in allScripts {
                userContentController.addUserScript(script.webKitUserScript)
            }
        }
    }
    
    
    #endif
}


#if !SKIP
extension WebEngine: ScriptMessageHandler {
    public func userContentController(_ userContentController: UserContentController, didReceive message: ScriptMessage) {
        if message.name == "skipConsoleLog" {
            guard let body = message.body as? [String: String] else {
                logger.error("JS Console (invalid skipConsoleLog message): \(String(describing: message.body))")
                return
            }
            let level = body["level"] ?? "log"
            let content = body["content"] ?? ""
            switch level {
            case "debug":
                logger.debug("JS Console \(level): \(content)")
            case "info":
                logger.info("JS Console \(level): \(content)")
            case "log":
                logger.info("JS Console \(level): \(content)")
            case "warn":
                logger.warning("JS Console \(level): \(content)")
            case "error":
                logger.error("JS Console \(level): \(content)")
            default:
                logger.error("JS Console (unknown level \(level)): \(content)")
            }
            return
        }
        guard let messageHandler = configuration.messageHandlers[message.name] else { return }
        let msg = WebViewMessage(frameInfo: message.frameInfo, uuid: UUID(), name: message.name, body: message.body)
        Task {
            await messageHandler(msg)
        }
    }
}
#endif

extension WebEngine {
    /// The engine delegate that handles client navigation events like the page being loaded or an error occuring
    // SKIP @nobridge
    public var engineDelegate: WebEngineDelegate? {
        get {
            #if SKIP
            webView.webViewClient as? WebEngineDelegate
            #else
            webView.navigationDelegate as? WebEngineDelegate
            #endif
        }

        set {
            #if SKIP
            webView.webViewClient = newValue ?? webView.webViewClient
            #else
            webView.navigationDelegate = newValue
            #endif

        }
    }
}


#if SKIP
// SKIP @nobridge
public class WebEngineDelegate : android.webkit.WebViewClient {
    let config: WebEngineConfiguration
    let webViewClient: android.webkit.WebViewClient
    
    override init(config: WebEngineConfiguration, webViewClient: android.webkit.WebViewClient = android.webkit.WebViewClient()) {
        super.init()
        self.config = config
        self.webViewClient = webViewClient
    }

    /// Notify the host application to update its visited links database.
    override func doUpdateVisitedHistory(view: PlatformWebView, url: String, isReload: Bool) {
        logger.log("application")
        webViewClient.doUpdateVisitedHistory(view, url, isReload)
    }

    /// As the host application if the browser should resend data as the requested page was a result of a POST.
    override func onFormResubmission(view: PlatformWebView, dontResend: android.os.Message, resend: android.os.Message) {
        logger.log("onFormResubmission")
        webViewClient.onFormResubmission(view, dontResend, resend)
    }

    /// Notify the host application that the WebView will load the resource specified by the given url.
    override func onLoadResource(view: PlatformWebView, url: String) {
        logger.log("onLoadResource: \(url)")
        webViewClient.onLoadResource(view, url)
    }

    /// Notify the host application that WebView content left over from previous page navigations will no longer be drawn.
    override func onPageCommitVisible(view: PlatformWebView, url: String) {
        logger.log("onPageCommitVisible: \(url)")
        webViewClient.onPageCommitVisible(view, url)
    }

    /// Notify the host application that a page has finished loading.
    override func onPageFinished(view: PlatformWebView, url: String) {
        logger.log("onPageFinished: \(url)")
        for userScript in config.userScripts {
            if userScript.webKitUserScript.injectionTime == .atDocumentEnd {
                let source = userScript.webKitUserScript.source
                view.evaluateJavascript(source) { _ in
                    logger.debug("Executed user script \(source)")
                }
            }
        }
        webViewClient.onPageFinished(view, url)
    }

    /// Notify the host application that a page has started loading.
    override func onPageStarted(view: PlatformWebView, url: String, favicon: android.graphics.Bitmap?) {
        logger.log("onPageStarted: \(url)")
        if (!config.messageHandlers.isEmpty) {
            // add support for webkit.messageHandlers.messageHandlerName.postMessage(body)
            // JS Proxies are pretty weird. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy
            // We're using an empty target; when JS accesses any property,
            // we'll return a JS object with a `postMessage` member function, which will call
            // skipWebAndroidMessageHandler.postMessage, passing the messageHandlerName and body as strings.
            view.evaluateJavascript("""
            if (!window.webkit) window.webkit = {};
            webkit.messageHandlers = new Proxy({}, {
                get: (target, messageHandlerName, receiver) => ({
                    postMessage: (body) => skipWebAndroidMessageHandler.postMessage(String(messageHandlerName), JSON.stringify(body))
                })
            });
        """) { _ in logger.debug("Added webkit.messageHandlers") }
        }
        for userScript in config.userScripts {
            if userScript.webKitUserScript.injectionTime == .atDocumentStart {
                let source = userScript.webKitUserScript.source
                view.evaluateJavascript(source) { _ in
                    logger.debug("Executed user script \(source)")
                }
            }
        }
        webViewClient.onPageStarted(view, url, favicon)
    }

    /// Notify the host application to handle a SSL client certificate request.
    override func onReceivedClientCertRequest(view: PlatformWebView, request: android.webkit.ClientCertRequest) {
        logger.log("onReceivedClientCertRequest: \(request)")
        webViewClient.onReceivedClientCertRequest(view, request)
    }

    /// Report web resource loading error to the host application.
    override func onReceivedError(view: PlatformWebView, request: android.webkit.WebResourceRequest, error: android.webkit.WebResourceError) {
        logger.log("onReceivedError: \(error)")
        webViewClient.onReceivedError(view, request, error)
    }

    /// Notifies the host application that the WebView received an HTTP authentication request.
    override func onReceivedHttpAuthRequest(view: PlatformWebView, handler: android.webkit.HttpAuthHandler, host: String, realm: String) {
        logger.log("onReceivedHttpAuthRequest: \(handler) \(host) \(realm)")
        webViewClient.onReceivedHttpAuthRequest(view, handler, host, realm)
    }

    /// Notify the host application that an HTTP error has been received from the server while loading a resource.
    override func onReceivedHttpError(view: PlatformWebView, request: android.webkit.WebResourceRequest, errorResponse: android.webkit.WebResourceResponse) {
        logger.log("onReceivedHttpError: \(request) \(errorResponse)")
        webViewClient.onReceivedHttpError(view, request, errorResponse)
    }

    /// Notify the host application that a request to automatically log in the user has been processed.
//    override func onReceivedLoginRequest(view: PlatformWebView, realm: String, account: String, args: String) {
//        webViewClient.onReceivedLoginRequest(view, realm, account, args)
//    }

    /// Notifies the host application that an SSL error occurred while loading a resource.
    override func onReceivedSslError(view: PlatformWebView, handler: android.webkit.SslErrorHandler, error: android.net.http.SslError) {
        logger.log("onReceivedSslError: \(error)")
        webViewClient.onReceivedSslError(view, handler, error)
    }

    /// Notify host application that the given WebView's render process has exited.
    override func onRenderProcessGone(view: PlatformWebView, detail: android.webkit.RenderProcessGoneDetail) -> Bool {
        logger.log("onRenderProcessGone: \(detail)")
        return webViewClient.onRenderProcessGone(view, detail)
    }

    /// Notify the host application that a loading URL has been flagged by Safe Browsing.
    override func onSafeBrowsingHit(view: PlatformWebView, request: android.webkit.WebResourceRequest, threatType: Int, callback: android.webkit.SafeBrowsingResponse) {
        logger.log("onSafeBrowsingHit: \(request)")
        webViewClient.onSafeBrowsingHit(view, request, threatType, callback)
    }

    /// Notify the host application that the scale applied to the WebView has changed.
    override func onScaleChanged(view: PlatformWebView, oldScale: Float, newScale: Float) {
        logger.log("onScaleChanged: \(oldScale) \(newScale)")
        webViewClient.onScaleChanged(view, oldScale, newScale)
    }

    /// Notify the host application that a key was not handled by the WebView.
    override func onUnhandledKeyEvent(view: PlatformWebView, event: android.view.KeyEvent) {
        logger.log("onUnhandledKeyEvent: \(event)")
        webViewClient.onUnhandledKeyEvent(view, event)
    }

    /// Notify the host application of a resource request and allow the application to return the data.
    public override func shouldInterceptRequest(view: PlatformWebView, request: android.webkit.WebResourceRequest) -> android.webkit.WebResourceResponse? {
        logger.log("shouldInterceptRequest: \(request.url)")
        let scheme: String = request.url?.scheme ?? ""
        if let handler = config.schemeHandlers[scheme] {
            return handler.interceptRequest(view: view, request: request)
        }
        return webViewClient.shouldInterceptRequest(view, request)
    }

    /// Give the host application a chance to handle the key event synchronously.
    override func shouldOverrideKeyEvent(view: PlatformWebView, event: android.view.KeyEvent) -> Bool {
        logger.log("shouldOverrideKeyEvent: \(event)")
        return webViewClient.shouldOverrideKeyEvent(view, event)
    }

    /// Give the host application a chance to take control when a URL is about to be loaded in the current WebView.
    override func shouldOverrideUrlLoading(view: PlatformWebView, request: android.webkit.WebResourceRequest) -> Bool {
        logger.log("shouldOverrideUrlLoading: \(request.url)")
        return webViewClient.shouldOverrideUrlLoading(view, request)
    }
}
#else
public class WebEngineDelegate : WebObjectBase, WKNavigationDelegate {

}
#endif

/// A temporary NavigationDelegate that uses a callback to integrate with checked continuations
fileprivate class PageLoadDelegate : WebEngineDelegate {
    let callback: (Result<Void, Error>) -> ()
    var callbackInvoked = false

    init(config: WebEngineConfiguration, callback: @escaping (Result<Void, Error>) -> Void) {
        #if SKIP
        super.init(config: config)
        #endif
        self.callback = callback
    }

    #if SKIP
    override func onPageFinished(view: PlatformWebView, url: String) {
        logger.info("webView: \(view) onPageFinished: \(url!)")
        if self.callbackInvoked { return }
        callbackInvoked = true
        self.callback(Result<Void, Error>.success(()))
    }
    #else
    @objc func webView(_ webView: PlatformWebView, didFinish navigation: WebNavigation!) {
        logger.info("webView: \(webView) didFinish: \(navigation!)")
        if self.callbackInvoked { return }
        callbackInvoked = true
        self.callback(.success(()))
    }
    #endif

    #if SKIP
    override func onReceivedError(view: PlatformWebView, request: android.webkit.WebResourceRequest, error: android.webkit.WebResourceError) {
        logger.info("webView: \(view) onReceivedError: \(request!) error: \(error)")
        if self.callbackInvoked { return }
        callbackInvoked = true
        self.callback(Result<Void, Error>.failure(WebLoadError(msg: String(error.description), code: error.errorCode)))
    }
    #else
    @objc func webView(_ webView: PlatformWebView, didFail navigation: WebNavigation!, withError error: any Error) {
        logger.info("webView: \(webView) didFail: \(navigation!) error: \(error)")
        if self.callbackInvoked { return }
        callbackInvoked = true
        self.callback(.failure(error))
    }
    #endif
}

#if SKIP
// android.webkit.WebResourceError is not an Exception, so we need to wrap it
public struct WebLoadError : Error, CustomStringConvertible {
    public let msg: String
    public let code: Int32

    public init(msg: String, code: Int32) {
        self.msg = msg
        self.code = code
    }

    public var description: String {
        "SQLite error code \(code): \(msg)"
    }

    public var localizedDescription: String {
        "SQLite error code \(code): \(msg)"
    }
}
#endif

/// Request metadata for creating a child window/web view.
public struct WebWindowRequest {
    /// The URL currently loaded by the parent web view, when available.
    public let sourceURL: URL?
    /// The target URL requested for the child view, when available.
    ///
    /// On Android this can be `nil` at `onCreateWindow` time.
    public let targetURL: URL?
    /// Whether this request was initiated from a user gesture.
    public let isUserGesture: Bool?
    /// Whether the child should be treated as a dialog window.
    public let isDialog: Bool?
    /// Whether the request targets the main frame.
    public let isMainFrame: Bool?

    public init(sourceURL: URL?, targetURL: URL?, isUserGesture: Bool?, isDialog: Bool?, isMainFrame: Bool?) {
        self.sourceURL = sourceURL
        self.targetURL = targetURL
        self.isUserGesture = isUserGesture
        self.isDialog = isDialog
        self.isMainFrame = isMainFrame
    }
}

#if !SKIP
/// iOS-specific details passed through create-child callback.
public struct WebKitCreateWindowParams {
    public let configuration: WKWebViewConfiguration
    public let navigationAction: WKNavigationAction
    public let windowFeatures: WKWindowFeatures
    let parentConfigurationSnapshot: WebEngineConfiguration
    let parentIsInspectable: Bool

    public init(
        configuration: WKWebViewConfiguration,
        navigationAction: WKNavigationAction,
        windowFeatures: WKWindowFeatures,
        parentConfigurationSnapshot: WebEngineConfiguration = WebEngineConfiguration(),
        parentIsInspectable: Bool = true
    ) {
        self.configuration = configuration
        self.navigationAction = navigationAction
        self.windowFeatures = windowFeatures
        self.parentConfigurationSnapshot = parentConfigurationSnapshot
        self.parentIsInspectable = parentIsInspectable
    }
}

public extension WebKitCreateWindowParams {
    /// Creates a popup child engine using the exact WKWebViewConfiguration
    /// supplied by WebKit for this createWebViewWith callback.
    ///
    /// Using this helper preserves WebKit's popup contract and avoids
    /// NSInternalInconsistencyException ("Returned WKWebView was not created with
    /// the given configuration.") caused by configuration mismatches.
    @MainActor func makeChildWebEngine(
        configuration webEngineConfiguration: WebEngineConfiguration? = nil,
        frame: CGRect = .zero,
        isInspectable: Bool? = nil
    ) -> WebEngine {
        let effectiveConfiguration = (webEngineConfiguration ?? parentConfigurationSnapshot).popupChildMirroredConfiguration()
        let childWebView = WKWebView(frame: frame, configuration: configuration)
        registerPopupChild(childWebView)

        let preferences = childWebView.configuration.defaultWebpagePreferences!
        preferences.allowsContentJavaScript = effectiveConfiguration.javaScriptEnabled
        childWebView.configuration.preferences.javaScriptCanOpenWindowsAutomatically = effectiveConfiguration.javaScriptCanOpenWindowsAutomatically
        childWebView.allowsBackForwardNavigationGestures = effectiveConfiguration.allowsBackForwardNavigationGestures
        childWebView.scrollView.isScrollEnabled = effectiveConfiguration.isScrollEnabled
        childWebView.pageZoom = effectiveConfiguration.pageZoom
        childWebView.isOpaque = effectiveConfiguration.isOpaque
        childWebView.isInspectable = isInspectable ?? parentIsInspectable
        if effectiveConfiguration.customUserAgent != "" {
            childWebView.customUserAgent = effectiveConfiguration.customUserAgent
        }

        let childEngine = WebEngine(configuration: effectiveConfiguration, webView: childWebView)
        childEngine.refreshMessageHandlers()
        childEngine.updateUserScripts()
        return childEngine
    }

    @MainActor func registerPopupChild(_ childWebView: WKWebView) {
        registerPopupChild(childWebView, initializedWith: configuration)
    }

    @MainActor func registerPopupChild(_ childWebView: WKWebView, initializedWith initConfiguration: WKWebViewConfiguration) {
        PopupConfigRegistry.register(
            childWebViewID: ObjectIdentifier(childWebView),
            initConfigID: ObjectIdentifier(initConfiguration)
        )
    }
}

/// Tracks popup child construction-time configuration for WKUIDelegate validation.
///
/// Why this exists:
/// - WebKit requires that the WKWebView returned from
///   `WKUIDelegate.webView(_:createWebViewWith:for:windowFeatures:)`
///   be initialized with the exact configuration passed into that callback.
/// - Violating this contract can raise
///   `NSInternalInconsistencyException` with:
///   "Returned WKWebView was not created with the given configuration."
/// - `child.webView.configuration` cannot be used for identity validation after init,
///   because WebKit may expose a distinct configuration instance there.
///
/// To verify the contract reliably, SkipWeb records the configuration identity used
/// at child construction time (via `makeChildWebEngine`) and compares that recorded
/// identity in createWebViewWith.
@MainActor enum PopupConfigRegistry {
    enum VerificationResult {
        case matched
        case mismatch
        case missingRegistration
    }

    private static var childInitConfigByWebViewID: [ObjectIdentifier: ObjectIdentifier] = [:]
    private static var didLogMissingRegistrationWarning = false

    static func register(childWebViewID: ObjectIdentifier, initConfigID: ObjectIdentifier) {
        childInitConfigByWebViewID[childWebViewID] = initConfigID
    }

    static func verifyAndConsume(childWebViewID: ObjectIdentifier, expectedConfigID: ObjectIdentifier) -> VerificationResult {
        guard let initConfigID = childInitConfigByWebViewID.removeValue(forKey: childWebViewID) else {
            return .missingRegistration
        }
        return initConfigID == expectedConfigID ? .matched : .mismatch
    }

    static func shouldLogMissingRegistrationWarning() -> Bool {
        if didLogMissingRegistrationWarning {
            return false
        }
        didLogMissingRegistrationWarning = true
        return true
    }
}
#else
/// iOS-specific details passed through create-child callback.
public struct WebKitCreateWindowParams {
    public init() {
    }
}
#endif

#if SKIP
/// Android-specific details passed through create-child callback.
public struct AndroidCreateWindowParams {
    public let isDialog: Bool
    public let isUserGesture: Bool
    public let resultMessage: android.os.Message

    public init(isDialog: Bool, isUserGesture: Bool, resultMessage: android.os.Message) {
        self.isDialog = isDialog
        self.isUserGesture = isUserGesture
        self.resultMessage = resultMessage
    }
}
#else
/// Android-specific details passed through create-child callback.
public struct AndroidCreateWindowParams {
    public init() {
    }
}
#endif

#if !SKIP
public typealias PlatformCreateWindowContext = WebKitCreateWindowParams
#else
public typealias PlatformCreateWindowContext = AndroidCreateWindowParams
#endif

/// Delegate for web view UI behaviors like popup child-window creation.
public protocol SkipWebUIDelegate: AnyObject {
    /// Return a child engine to allow popup creation, or `nil` to deny.
    ///
    /// Platform behavior:
    /// - iOS: called from `WKUIDelegate.webView(_:createWebViewWith:for:windowFeatures:)`.
    /// - Android: called from `WebChromeClient.onCreateWindow`.
    ///   `request.targetURL` may be `nil` on Android at creation time.
    func webView(_ webView: WebView, createWebViewWith request: WebWindowRequest, platformContext: PlatformCreateWindowContext) -> WebEngine?

    /// Called when a previously created child web view is closed.
    ///
    /// Platform behavior:
    /// - iOS: invoked from `WKUIDelegate.webViewDidClose(_:)`.
    /// - Android: invoked from `WebChromeClient.onCloseWindow`.
    func webViewDidClose(_ webView: WebView, child: WebEngine)
}

public extension SkipWebUIDelegate {
    func webView(_ webView: WebView, createWebViewWith request: WebWindowRequest, platformContext: PlatformCreateWindowContext) -> WebEngine? {
        nil
    }

    func webViewDidClose(_ webView: WebView, child: WebEngine) {
    }
}

/// The configuration for a WebEngine
@Observable public class WebEngineConfiguration {
    public var javaScriptEnabled: Bool
    public var javaScriptCanOpenWindowsAutomatically: Bool
    public var allowsBackForwardNavigationGestures: Bool
    public var allowsPullToRefresh: Bool
    public var allowsInlineMediaPlayback: Bool
    public var dataDetectorsEnabled: Bool
    public var isScrollEnabled: Bool
    public var pageZoom: CGFloat
    public var isOpaque: Bool
    public var customUserAgent: String?
    public var profile: WebProfile
    public var userScripts: [WebViewUserScript]
    public var messageHandlers: [String: ((WebViewMessage) async -> Void)]
    public var schemeHandlers: [String: URLSchemeHandler]
    public var uiDelegate: (any SkipWebUIDelegate)?

    #if SKIP
    /// The Android context to use for creating a web context
    public var context: android.content.Context? = nil
    #endif

    public init(javaScriptEnabled: Bool = true,
                javaScriptCanOpenWindowsAutomatically: Bool = false,
                allowsBackForwardNavigationGestures: Bool = true,
                allowsPullToRefresh: Bool = true,
                allowsInlineMediaPlayback: Bool = true,
                dataDetectorsEnabled: Bool = true,
                isScrollEnabled: Bool = true,
                pageZoom: CGFloat = 1.0,
                isOpaque: Bool = true,
                customUserAgent: String? = nil,
                profile: WebProfile = .default,
                userScripts: [WebViewUserScript] = [],
                messageHandlers: [String: ((WebViewMessage) async -> Void)] = [:],
                schemeHandlers: [String: URLSchemeHandler] = [:],
                uiDelegate: (any SkipWebUIDelegate)? = nil) {
        self.javaScriptEnabled = javaScriptEnabled
        self.javaScriptCanOpenWindowsAutomatically = javaScriptCanOpenWindowsAutomatically
        self.allowsBackForwardNavigationGestures = allowsBackForwardNavigationGestures
        self.allowsPullToRefresh = allowsPullToRefresh
        self.allowsInlineMediaPlayback = allowsInlineMediaPlayback
        self.dataDetectorsEnabled = dataDetectorsEnabled
        self.isScrollEnabled = isScrollEnabled
        self.pageZoom = pageZoom
        self.isOpaque = isOpaque
        self.customUserAgent = customUserAgent
        self.profile = profile
        self.userScripts = userScripts
        self.messageHandlers = messageHandlers
        self.schemeHandlers = schemeHandlers
        self.uiDelegate = uiDelegate
    }

    public func popupChildMirroredConfiguration() -> WebEngineConfiguration {
        let copy = WebEngineConfiguration(
            javaScriptEnabled: javaScriptEnabled,
            javaScriptCanOpenWindowsAutomatically: javaScriptCanOpenWindowsAutomatically,
            allowsBackForwardNavigationGestures: allowsBackForwardNavigationGestures,
            allowsPullToRefresh: allowsPullToRefresh,
            allowsInlineMediaPlayback: allowsInlineMediaPlayback,
            dataDetectorsEnabled: dataDetectorsEnabled,
            isScrollEnabled: isScrollEnabled,
            pageZoom: pageZoom,
            isOpaque: isOpaque,
            customUserAgent: customUserAgent,
            profile: profile,
            userScripts: userScripts,
            messageHandlers: messageHandlers,
            schemeHandlers: schemeHandlers,
            uiDelegate: uiDelegate
        )
        #if SKIP
        copy.context = context
        #endif
        return copy
    }

    #if !SKIP
    /// Create a `WebViewConfiguration` from the properties of this configuration.
    @MainActor public var webViewConfiguration: WebViewConfiguration {
        let configuration = WebViewConfiguration()
        configuration.websiteDataStore = webKitWebsiteDataStore

        //let preferences = WebpagePreferences()
        //preferences.allowsContentJavaScript //

        #if !os(macOS) // API unavailable on macOS
        configuration.allowsInlineMediaPlayback = self.allowsInlineMediaPlayback
        configuration.dataDetectorTypes = [.all]
        //configuration.defaultWebpagePreferences = preferences
        configuration.dataDetectorTypes = [.calendarEvent, .flightNumber, .link, .lookupSuggestion, .trackingNumber]

        for (schemeName, schemeHandlerObject) in schemeHandlers {
            configuration.setURLSchemeHandler(schemeHandlerObject, forURLScheme: schemeName)
        }
        #endif

        return configuration
    }

    @MainActor private var webKitWebsiteDataStore: WKWebsiteDataStore {
        switch profile {
        case .default:
            return WKWebsiteDataStore.default()
        case .named(let identifier):
            guard let dataStoreIdentifier = webKitDataStoreIdentifier(for: identifier) else {
                return WKWebsiteDataStore.default()
            }
            return WKWebsiteDataStore(forIdentifier: dataStoreIdentifier)
        }
    }

    @MainActor private func webKitDataStoreIdentifier(for identifier: String) -> UUID? {
        guard let normalizedIdentifier = WebProfile.named(identifier).normalizedNamedIdentifier else {
            return nil
        }
        if let uuid = UUID(uuidString: normalizedIdentifier) {
            return uuid
        }

        let digest = Insecure.SHA1.hash(data: Data(normalizedIdentifier.utf8))
        let bytes = Array(digest.prefix(16))
        guard bytes.count == 16 else {
            return nil
        }

        let versionedBytes: [UInt8] = bytes.enumerated().map { index, byte in
            switch index {
            case 6:
                return (byte & 0x0F) | 0x50
            case 8:
                return (byte & 0x3F) | 0x80
            default:
                return byte
            }
        }

        return UUID(uuid: (
            versionedBytes[0], versionedBytes[1], versionedBytes[2], versionedBytes[3],
            versionedBytes[4], versionedBytes[5], versionedBytes[6], versionedBytes[7],
            versionedBytes[8], versionedBytes[9], versionedBytes[10], versionedBytes[11],
            versionedBytes[12], versionedBytes[13], versionedBytes[14], versionedBytes[15]
        ))
    }
    #endif
}

public class WebHistoryItem {
    #if !SKIP
    public typealias BackForwardListItem = WKBackForwardListItem
    #else
    public typealias BackForwardListItem = android.webkit.WebHistoryItem
    #endif

    public let item: BackForwardListItem

    init(item: BackForwardListItem) {
        self.item = item
    }

    /// The URL of the webpage represented by this item.
    public var url: String {
        #if !SKIP
        return item.url.absoluteString
        #else
        return item.getUrl()
        #endif
    }

    /// The URL of the initial request that created this item.
    public var initialURL: String {
        #if !SKIP
        return item.initialURL.absoluteString
        #else
        return item.getOriginalUrl()
        #endif
    }

    /// The title of the webpage represented by this item.
    public var title: String? {
        #if !SKIP
        return item.title
        #else
        return item.getTitle()
        #endif
    }
}

public struct WebViewMessage: Equatable {
    // SKIP @nobridge
    public let frameInfo: FrameInfo
    internal let uuid: UUID
    public let name: String
    public let body: Any

    public static func == (lhs: WebViewMessage, rhs: WebViewMessage) -> Bool {
        lhs.uuid == rhs.uuid
        && lhs.name == rhs.name && lhs.frameInfo == rhs.frameInfo
    }
}


#if !SKIP
public typealias FrameInfo = WKFrameInfo
#else
// SKIP @nobridge
public class FrameInfo {
    open var isMainFrame: Bool
    open var request: URLRequest
    open var securityOrigin: SecurityOrigin
    weak open var webView: PlatformWebView?

    init(isMainFrame: Bool, request: URLRequest, securityOrigin: SecurityOrigin, webView: PlatformWebView? = nil) {
        self.isMainFrame = isMainFrame
        self.request = request
        self.securityOrigin = securityOrigin
        self.webView = webView
    }
}
#endif

#if !SKIP
public typealias WebContentRuleListStore = WKContentRuleListStore
#else
public class WebContentRuleListStore { }
#endif

#if !SKIP
public typealias WebNavigation = WKNavigation
#else
public class WebNavigation { }
#endif

#if !SKIP
public typealias WebNavigationAction = WKNavigationAction
#else
public class WebNavigationAction { }
#endif

#if !SKIP
public typealias WebNavigationDelegate = WKNavigationDelegate
#else
public protocol WebNavigationDelegate { }
#endif

#if !SKIP
public typealias WebUIDelegate = WKUIDelegate
#else
public protocol WebUIDelegate { }
#endif

#if !SKIP
public typealias WebViewConfiguration = WKWebViewConfiguration
#else
public class WebViewConfiguration { }
#endif


#if !SKIP
public typealias SecurityOrigin = WKSecurityOrigin
#else
public class SecurityOrigin { }
#endif


#if !SKIP
public typealias UserScriptInjectionTime = WKUserScriptInjectionTime
#else
public enum UserScriptInjectionTime : Int {
    case atDocumentStart = 0
    case atDocumentEnd = 1
}
#endif

#if !SKIP
public typealias UserScript = WKUserScript
#else
open class UserScript : WebObjectBase {
    open var source: String
    open var injectionTime: UserScriptInjectionTime
    open var isForMainFrameOnly: Bool
    open var contentWorld: ContentWorld

    public init(source: String, injectionTime: UserScriptInjectionTime, forMainFrameOnly: Bool, in contentWorld: ContentWorld) {
        self.source = source
        self.injectionTime = injectionTime
        self.isForMainFrameOnly = forMainFrameOnly
        self.contentWorld = contentWorld
    }
}
#endif

public struct WebViewUserScript: Equatable, Hashable {
    public let source: String
    public let webKitUserScript: UserScript
    public let allowedDomains: Set<String>

    public static func == (lhs: WebViewUserScript, rhs: WebViewUserScript) -> Bool {
        lhs.source == rhs.source
        && lhs.allowedDomains == rhs.allowedDomains
    }

    public init(source: String, injectionTime: UserScriptInjectionTime, forMainFrameOnly: Bool, world: ContentWorld = .page, allowedDomains: Set<String> = Set()) {
        self.source = source
        self.webKitUserScript = UserScript(source: source, injectionTime: injectionTime, forMainFrameOnly: forMainFrameOnly, in: world)
        self.allowedDomains = allowedDomains
    }

    public func hash(into hasher: inout Hasher) {
        hasher.combine(source)
        hasher.combine(allowedDomains)
    }
    
    #if SKIP
    fileprivate static let systemScripts: [WebViewUserScript] = []
    #else
    fileprivate static let systemScripts = [
        ConsoleLogUserScript().userScript
    ]
    #endif
}

#if !SKIP
fileprivate struct ConsoleLogUserScript {
    let userScript: WebViewUserScript
    
    init() {
        let contents = """
        (function() {
        function log(level, args) {
            var content = args.map(v => typeof v === "object" ? JSON.stringify(v) : String(v)).join(" ");
            webkit.messageHandlers.skipConsoleLog.postMessage({level, content});
        }
        for (const method of ['log', 'warn', 'error', 'debug', 'info']) {
            const original = console[method];
            console[method] = function() {
                log(method, [...arguments]);
                original.apply(console, arguments);
            }
        }
        })();
        """
        userScript = WebViewUserScript(source: contents, injectionTime: .atDocumentStart, forMainFrameOnly: true, world: .page)
    }
}
#endif

#if !SKIP
public typealias ContentWorld = WKContentWorld
#else
public class ContentWorld {
    public static var page: ContentWorld = ContentWorld()
    public static var defaultClient: ContentWorld = ContentWorld()

    public static func world(name: String) -> ContentWorld {
        ContentWorld(name: name)
    }

    public var name: String?

    private init(name: String? = nil) {
        self.name = name
    }
}
#endif

#if !SKIP
public typealias UserContentController = WKUserContentController
#else
public class UserContentController { }
#endif

#if !SKIP
public typealias NavigationActionPolicy = WKNavigationActionPolicy
#else
public class NavigationActionPolicy { }
#endif


#if !SKIP
public typealias NavigationResponse = WKNavigationResponse
#else
public class NavigationResponse { }
#endif


#if !SKIP
public typealias NavigationResponsePolicy = WKNavigationResponsePolicy
#else
public class NavigationResponsePolicy { }
#endif


#if !SKIP
public typealias WebpagePreferences = WKWebpagePreferences
#else
public class WebpagePreferences {
}
#endif

#if !SKIP
public typealias URLSchemeHandler = WKURLSchemeHandler
#else
public protocol URLSchemeHandler {
    // SKIP @nobridge
    func interceptRequest(view: PlatformWebView, request: android.webkit.WebResourceRequest) -> android.webkit.WebResourceResponse
}
#endif

#if !SKIP
public typealias ScriptMessage = WKScriptMessage
#else
public class ScriptMessage {

}
#endif

#if !SKIP
public typealias ScriptMessageHandler = WKScriptMessageHandler
#else
public protocol ScriptMessageHandler {

}
#endif

#if !SKIP
public typealias ContentRuleList = WKContentRuleList
#else
public class ContentRuleList {
    public var identifier: String

    init(identifier: String) {
        self.identifier = identifier
    }
}
#endif


#if !SKIP
public typealias ContentRuleListStore = WKContentRuleListStore
#else
public class ContentRuleListStore {
}

#endif

// SKIP @nobridge
open class AbstractURLSchemeHandler : WebObjectBase, URLSchemeHandler {
    open func loadData(from fileName: String) -> Data? {
        fatalError("Implementations must override loadData")
    }
    
    #if SKIP

    public override func interceptRequest(view: PlatformWebView, request: android.webkit.WebResourceRequest) -> android.webkit.WebResourceResponse {
        let responseHeaders: kotlin.collections.Map<String, String> = kotlin.collections.HashMap()
        guard let url = URL(string: request.url.toString()) else {
            return android.webkit.WebResourceResponse(
                "text/plain",
                "utf-8",
                500,
                "Internal Server Error",
                responseHeaders,
                "Invalid URL \(request.url)".byteInputStream()
            )
        }
        
        var resourcePath = url.path
        if resourcePath.starts(with: "/") {
            resourcePath = String(resourcePath.dropFirst())
        }
        guard let data = loadData(from: resourcePath) else {
            logger.debug("404 error for URL: \(url)")
            return android.webkit.WebResourceResponse(
                "text/plain",
                "utf-8",
                404,
                "Not Found",
                responseHeaders,
                "Not Found URL \(request.url)".byteInputStream()
            )
        }
        
        let fileExtension = android.webkit.MimeTypeMap.getFileExtensionFromUrl(url.absoluteString)
        let mimeType = android.webkit.MimeTypeMap.getSingleton().getMimeTypeFromExtension(fileExtension) ?? "application/octet-stream"
        
        let response = android.webkit.WebResourceResponse(
            mimeType,
            "utf-8",
            java.io.ByteArrayInputStream(data.platformData)
        )
        
        logger.debug("Handled URL \(url)")
        return response
    }
    #else
    public func webView(_ webView: WKWebView, start urlSchemeTask: any WKURLSchemeTask) {
        logger.debug("Requested URL: \(urlSchemeTask.request.url?.absoluteString ?? "<unknown>")");
        guard let url = urlSchemeTask.request.url else {
            urlSchemeTask.didFailWithError(URLError(.badURL))
            return
        }
        var resourcePath = url.path
        if resourcePath.starts(with: "/") {
            resourcePath = String(resourcePath.dropFirst())
        }
        guard let data = loadData(from: resourcePath) else {
            let error = NSError(
                domain: "SchemeHandlerError",
                code: 404,
                userInfo: [NSLocalizedDescriptionKey: "Resource not found: \(resourcePath)"]
            )
            logger.debug("404 error for URL: \(url)")
            urlSchemeTask.didFailWithError(error)
            return
        }
        
        let fileExtension = resourcePath.split(separator: ".").last ?? ""
        let mimeType = UTType(filenameExtension: String(fileExtension))?.preferredMIMEType ?? "application/octet-stream"
        let response = HTTPURLResponse(
            url: url,
            statusCode: 200,
            httpVersion: "HTTP/1.1",
            headerFields: [
                "Content-Type": mimeType,
                "Content-Length": "\(data.count)"
            ]
        )
        
        if let response = response {
            urlSchemeTask.didReceive(response)
            urlSchemeTask.didReceive(data)
            urlSchemeTask.didFinish()
            logger.debug("Handled URL \(url)");
        } else {
            let error = NSError(
                domain: "BundleResourceSchemeHandlerError",
                code: 500,
                userInfo: [NSLocalizedDescriptionKey: "Could not create HTTPURLResponse"]
            )
            logger.debug("500 error for URL: \(url)")
            urlSchemeTask.didFailWithError(error)
        }
        
    }
    
    public func webView(_ webView: WKWebView, stop urlSchemeTask: any WKURLSchemeTask) {
        // no stopping
    }
    #endif
}

// SKIP @nobridge
public class BundleURLSchemeHandler: AbstractURLSchemeHandler {
    let bundle: Bundle
    let subdirectory: String?
    
    public init(bundle: Bundle = Bundle.main, subdirectory: String? = nil) {
        self.bundle = bundle
        self.subdirectory = subdirectory
    }
    
    public override func loadData(from fileName: String) -> Data? {
        guard let fileURL = bundle.url(forResource: fileName, withExtension: nil, subdirectory: self.subdirectory) else {
            return nil
        }
        return try? Data(contentsOf: fileURL)
    }
}

// SKIP @nobridge
public class DirectoryURLSchemeHandler: AbstractURLSchemeHandler {
    let directory: URL
    
    public init(directory: URL) {
        self.directory = directory
    }
    
    public override func loadData(from fileName: String) -> Data? {
        let file = directory.appendingPathComponent(fileName)
        logger.info("Reading \(fileName) from \(file)")
        return try? Data(contentsOf: file)
    }
}
#endif
#endif