@capgo/capacitor-inappbrowser 8.6.32 → 8.6.34

package/CapgoCapacitorInappbrowser.podspec

@@ -11,6 +11,7 @@ Pod::Spec.new do |s|
   s.author = package['author']
   s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
   s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.resources = ['ios/Sources/InAppBrowserPlugin/Resources/proxy-bridge.js']
   s.ios.deployment_target = '15.0'
   s.dependency 'Capacitor'
   s.swift_version = '5.1'

package/Package.swift

@@ -19,7 +19,8 @@ let package = Package(
                 .product(name: "Capacitor", package: "capacitor-swift-pm"),
                 .product(name: "Cordova", package: "capacitor-swift-pm")
             ],
-            path: "ios/Sources/InAppBrowserPlugin"),
+            path: "ios/Sources/InAppBrowserPlugin",
+            resources: [.process("Resources")]),
         .testTarget(
             name: "InappbrowserPluginTests",
             dependencies: ["InappbrowserPlugin"],

package/android/src/main/java/ee/forgr/capacitor_inappbrowser/WebViewDialog.java

@@ -6053,6 +6053,7 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
 
         // If both width and height are specified, use custom dimensions
         if (width != null && height != null) {
+            params.gravity = Gravity.TOP | Gravity.LEFT;
             params.width = (int) getPixels(width);
             params.height = (int) getPixels(height);
             params.x = (x != null) ? (int) getPixels(x) : 0;
@@ -6060,6 +6061,7 @@ public class WebViewDialog extends Dialog implements ProxyResponseRouting.ProxyR
             params.gravity = Gravity.TOP | Gravity.START;
         } else if (height != null && width == null) {
             // If only height is specified, use custom height with fullscreen width
+            params.gravity = Gravity.TOP | Gravity.LEFT;
             params.width = WindowManager.LayoutParams.MATCH_PARENT;
             params.height = (int) getPixels(height);
             params.x = 0;

package/ios/Sources/InAppBrowserPlugin/InAppBrowserPlugin.swift

@@ -98,7 +98,7 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
         case aware = "AWARE"
         case fakeVisible = "FAKE_VISIBLE"
     }
-    private let pluginVersion: String = "8.6.32"
+    private let pluginVersion: String = "8.6.34"
     public let identifier = "CapgoInAppBrowserPlugin"
     public let jsName = "CapgoInAppBrowser"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -135,6 +135,7 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
     var webViewController: WKWebViewController?
     private var webViewControllers: [String: WKWebViewController] = [:]
     private var proxySchemeHandlers: [String: ProxySchemeHandler] = [:]
+    private var proxyBridges: [String: ProxyBridge] = [:]
     private var webViewStack: [String] = []
     private var activeWebViewId: String?
     private weak var presentationContainerView: UIView?
@@ -186,6 +187,7 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
         }
         proxySchemeHandlers[id]?.cancelAllPendingTasks()
         proxySchemeHandlers[id] = nil
+        proxyBridges[id] = nil
         webViewControllers[id] = nil
         navigationControllers[id] = nil
         webViewStack.removeAll { $0 == id }
@@ -893,16 +895,23 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
             }
 
             var proxyHandler: ProxySchemeHandler?
+            var proxyBridge: ProxyBridge?
+            var proxyBridgeAccessToken: String?
             if legacyProxyRequests.isEnabled || !outboundProxyRules.isEmpty || !inboundProxyRules.isEmpty {
+                let bridgeAccessToken = UUID().uuidString
+                proxyBridgeAccessToken = bridgeAccessToken
+                proxyBridge = ProxyBridge(accessToken: bridgeAccessToken)
                 proxyHandler = ProxySchemeHandler(
                     plugin: self,
                     webviewId: webViewId,
                     legacyProxyRequests: legacyProxyRequests.isEnabled,
                     legacyProxyRequestURLRegex: legacyProxyRequests.urlRegex,
                     outboundRules: outboundProxyRules,
-                    inboundRules: inboundProxyRules
+                    inboundRules: inboundProxyRules,
+                    proxyBridge: proxyBridge
                 )
                 self.proxySchemeHandlers[webViewId] = proxyHandler
+                self.proxyBridges[webViewId] = proxyBridge
             }
 
             self.webViewController = WKWebViewController.init(
@@ -921,6 +930,9 @@ public class CapgoInAppBrowserPlugin: CAPPlugin, CAPBridgedPlugin {
                 captureConsoleLogs: captureConsoleLogs,
                 proxyRequests: legacyProxyRequests.isEnabled,
                 proxySchemeHandler: proxyHandler,
+                proxyBridge: proxyBridge,
+                proxyBridgeAccessToken: proxyBridgeAccessToken,
+                legacyProxyRequestURLRegexPattern: legacyProxyRequests.urlRegex?.pattern,
                 documentStartUserScripts: self.documentStartUserScripts(
                     authorizedAppLinks: authorizedAppLinks,
                     openBlankTargetInWebView: openBlankTargetInWebView

package/ios/Sources/InAppBrowserPlugin/ProxyBridge.swift

@@ -0,0 +1,210 @@
+import Foundation
+
+struct ProxyBridgeStoredRequest {
+    let method: String
+    let headersJson: String
+    let base64Body: String
+    let credentialsMode: String
+    let storedAt: Date
+}
+
+public final class ProxyBridge {
+    static let storedRequestTTL: TimeInterval = 120
+
+    private let accessToken: String
+    private var storedRequests: [String: ProxyBridgeStoredRequest] = [:]
+    private var storedRequestOrder: [String] = []
+    private let lock = NSLock()
+    private let clock: () -> Date
+
+    init(accessToken: String, clock: @escaping () -> Date = Date.init) {
+        self.accessToken = accessToken
+        self.clock = clock
+    }
+
+    func storeRequest(
+        token: String,
+        requestId: String,
+        method: String,
+        headersJson: String,
+        base64Body: String,
+        credentialsMode: String
+    ) {
+        guard token == accessToken, !requestId.isEmpty else {
+            return
+        }
+
+        let now = clock()
+        lock.lock()
+        cleanupExpiredRequests(now: now)
+        storedRequests[requestId] = ProxyBridgeStoredRequest(
+            method: method,
+            headersJson: headersJson,
+            base64Body: base64Body,
+            credentialsMode: credentialsMode,
+            storedAt: now
+        )
+        storedRequestOrder.append(requestId)
+        lock.unlock()
+    }
+
+    func getAndRemove(requestId: String) -> ProxyBridgeStoredRequest? {
+        lock.lock()
+        defer { lock.unlock() }
+        guard let storedRequest = storedRequests.removeValue(forKey: requestId) else {
+            return nil
+        }
+        storedRequestOrder.removeAll { $0 == requestId }
+        return storedRequest
+    }
+
+    private func cleanupExpiredRequests(now: Date) {
+        while let oldestRequestId = storedRequestOrder.first {
+            guard let oldestRequest = storedRequests[oldestRequestId] else {
+                storedRequestOrder.removeFirst()
+                continue
+            }
+
+            if now.timeIntervalSince(oldestRequest.storedAt) < Self.storedRequestTTL {
+                return
+            }
+
+            storedRequests.removeValue(forKey: oldestRequestId)
+            storedRequestOrder.removeFirst()
+        }
+    }
+}
+
+enum ProxyBridgeSupport {
+    struct BridgeMarkerRequest {
+        let originalURL: String
+        let requestId: String
+    }
+
+    static func isBridgeMarkerRequestURL(_ requestURL: String) -> Bool {
+        guard let components = URLComponents(string: requestURL),
+              components.path == "/_capgo_proxy_",
+              let query = components.query,
+              !query.isEmpty else {
+            return false
+        }
+        return true
+    }
+
+    static func parseBridgeMarkerRequest(_ requestURL: String) -> BridgeMarkerRequest? {
+        guard isBridgeMarkerRequestURL(requestURL),
+              let components = URLComponents(string: requestURL) else {
+            return nil
+        }
+
+        let queryItems = components.queryItems ?? []
+        guard let originalURL = queryItems.first(where: { $0.name == "u" })?.value,
+              let requestId = queryItems.first(where: { $0.name == "rid" })?.value,
+              !originalURL.isEmpty,
+              !requestId.isEmpty else {
+            return nil
+        }
+
+        return BridgeMarkerRequest(originalURL: originalURL, requestId: requestId)
+    }
+
+    static func decodeStoredHeaders(_ headersJson: String) -> [String: String] {
+        guard let data = headersJson.data(using: .utf8),
+              let headers = try? JSONSerialization.jsonObject(with: data) as? [String: String] else {
+            return [:]
+        }
+        return headers
+    }
+
+    static func shouldInjectBridge(hasProxySchemeHandler: Bool) -> Bool {
+        hasProxySchemeHandler
+    }
+
+    static func usesLegacyJsProxyMode(
+        legacyProxyRequests: Bool,
+        legacyProxyRequestURLRegex: NSRegularExpression?,
+        hasOutboundRules: Bool,
+        hasInboundRules: Bool
+    ) -> Bool {
+        (legacyProxyRequests || legacyProxyRequestURLRegex != nil) &&
+            hasOutboundRules == false &&
+            hasInboundRules == false
+    }
+
+    static func shouldDelegateLegacyJsProxyRequest(
+        legacyProxyRequests: Bool,
+        legacyProxyRequestURLRegex: NSRegularExpression?,
+        hasOutboundRules: Bool,
+        hasInboundRules: Bool,
+        requestURL: String
+    ) -> Bool {
+        guard usesLegacyJsProxyMode(
+            legacyProxyRequests: legacyProxyRequests,
+            legacyProxyRequestURLRegex: legacyProxyRequestURLRegex,
+            hasOutboundRules: hasOutboundRules,
+            hasInboundRules: hasInboundRules
+        ) else {
+            return false
+        }
+
+        guard let legacyProxyRequestURLRegex else {
+            return legacyProxyRequests
+        }
+
+        let range = NSRange(location: 0, length: requestURL.utf16.count)
+        return legacyProxyRequestURLRegex.firstMatch(in: requestURL, options: [], range: range) != nil
+    }
+
+    static func escapeJavaScriptLiteral(_ value: String) -> String {
+        value
+            .replacingOccurrences(of: "\\", with: "\\\\")
+            .replacingOccurrences(of: "'", with: "\\'")
+            .replacingOccurrences(of: "\r", with: "\\r")
+            .replacingOccurrences(of: "\n", with: "\\n")
+            .replacingOccurrences(of: "\u{2028}", with: "\\u2028")
+            .replacingOccurrences(of: "\u{2029}", with: "\\u2029")
+    }
+
+    static func bootstrapScriptSource() -> String {
+        """
+        (function() {
+          if (window.__capgoProxy && window.__capgoProxy.__capgoNativeBridgeInstalled) {
+            return;
+          }
+          window.__capgoProxy = {
+            __capgoNativeBridgeInstalled: true,
+            storeRequest: function(token, requestId, method, headersJson, base64Body, credentialsMode) {
+              if (!window.webkit || !window.webkit.messageHandlers || !window.webkit.messageHandlers.capgoProxyBridge) {
+                return;
+              }
+              window.webkit.messageHandlers.capgoProxyBridge.postMessage({
+                token: token,
+                requestId: requestId,
+                method: method,
+                headersJson: headersJson,
+                base64Body: base64Body,
+                credentialsMode: credentialsMode
+              });
+            }
+          };
+        })();
+        """
+    }
+
+    static func loadBundledBridgeScript(accessToken: String, proxyRegexSource: String) -> String? {
+        #if SWIFT_PACKAGE
+        let bundle = Bundle.module
+        #else
+        let bundle = Bundle(for: ProxyBridge.self)
+        #endif
+
+        guard let scriptURL = bundle.url(forResource: "proxy-bridge", withExtension: "js"),
+              let rawScript = try? String(contentsOf: scriptURL) else {
+            return nil
+        }
+
+        return rawScript
+            .replacingOccurrences(of: "___CAPGO_PROXY_TOKEN___", with: escapeJavaScriptLiteral(accessToken))
+            .replacingOccurrences(of: "___CAPGO_PROXY_REGEX___", with: escapeJavaScriptLiteral(proxyRegexSource))
+    }
+}

package/ios/Sources/InAppBrowserPlugin/ProxySchemeHandler.swift

@@ -460,16 +460,17 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
     private let legacyProxyRequestURLRegex: NSRegularExpression?
     private let outboundRules: [NativeProxyRule]
     private let inboundRules: [NativeProxyRule]
+    private weak var proxyBridge: ProxyBridge?
 
     private lazy var session = URLSession(configuration: .default, delegate: self, delegateQueue: nil)
-
     init(
         plugin: CapgoInAppBrowserPlugin,
         webviewId: String,
         legacyProxyRequests: Bool,
         legacyProxyRequestURLRegex: NSRegularExpression?,
         outboundRules: [NativeProxyRule],
-        inboundRules: [NativeProxyRule]
+        inboundRules: [NativeProxyRule],
+        proxyBridge: ProxyBridge? = nil
     ) {
         self.plugin = plugin
         self.webviewId = webviewId
@@ -477,6 +478,7 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
         self.legacyProxyRequestURLRegex = legacyProxyRequestURLRegex
         self.outboundRules = outboundRules
         self.inboundRules = inboundRules
+        self.proxyBridge = proxyBridge
         super.init()
     }
 
@@ -488,7 +490,8 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
             legacyProxyRequests: legacyProxyRequests,
             legacyProxyRequestURLRegex: legacyProxyRequestURLRegex,
             outboundRules: outboundRules,
-            inboundRules: inboundRules
+            inboundRules: inboundRules,
+            proxyBridge: proxyBridge
         )
     }
 
@@ -505,13 +508,10 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
         }
 
         let requestId = UUID().uuidString
-        let requestContext = NativeRequestContext(
-            url: url.absoluteString,
-            method: ProxySchemeRequestSupport.normalizedRequestMethod(urlSchemeTask.request.httpMethod),
-            headers: urlSchemeTask.request.allHTTPHeaderFields ?? [:],
-            base64Body: extractBody(from: urlSchemeTask.request),
-            isMainFrame: ProxySchemeRequestSupport.isMainFrameRequest(urlSchemeTask.request)
-        )
+        guard let requestContext = makeInitialRequestContext(from: urlSchemeTask, requestURL: url) else {
+            finishCanceledSchemeTask(urlSchemeTask)
+            return
+        }
         let pendingTask = PendingProxyTask(requestId: requestId, schemeTask: urlSchemeTask, requestContext: requestContext, phase: "outbound")
 
         taskLock.lock()
@@ -1169,6 +1169,80 @@ public class ProxySchemeHandler: NSObject, WKURLSchemeHandler, URLSessionTaskDel
         }
     }
 
+
+    private func makeInitialRequestContext(from urlSchemeTask: WKURLSchemeTask, requestURL: URL) -> NativeRequestContext? {
+        let requestURLString = requestURL.absoluteString
+
+        if let bridgeRequest = ProxyBridgeSupport.parseBridgeMarkerRequest(requestURLString) {
+            if ProxyBridgeSupport.usesLegacyJsProxyMode(
+                legacyProxyRequests: legacyProxyRequests,
+                legacyProxyRequestURLRegex: legacyProxyRequestURLRegex,
+                hasOutboundRules: !outboundRules.isEmpty,
+                hasInboundRules: !inboundRules.isEmpty
+            ),
+            !ProxyBridgeSupport.shouldDelegateLegacyJsProxyRequest(
+                legacyProxyRequests: legacyProxyRequests,
+                legacyProxyRequestURLRegex: legacyProxyRequestURLRegex,
+                hasOutboundRules: !outboundRules.isEmpty,
+                hasInboundRules: !inboundRules.isEmpty,
+                requestURL: bridgeRequest.originalURL
+            ) {
+                _ = proxyBridge?.getAndRemove(requestId: bridgeRequest.requestId)
+                return nil
+            }
+
+            guard let stored = proxyBridge?.getAndRemove(requestId: bridgeRequest.requestId) else {
+                return nil
+            }
+
+            var headers = ProxyBridgeSupport.decodeStoredHeaders(stored.headersJson)
+            let markerHeaders = urlSchemeTask.request.allHTTPHeaderFields ?? [:]
+            for (key, value) in markerHeaders where headers[key] == nil {
+                headers[key] = value
+            }
+
+            let base64Body = stored.base64Body.isEmpty ? nil : stored.base64Body
+            return NativeRequestContext(
+                url: bridgeRequest.originalURL,
+                method: ProxySchemeRequestSupport.normalizedRequestMethod(stored.method),
+                headers: headers,
+                base64Body: base64Body,
+                isMainFrame: ProxySchemeRequestSupport.isMainFrameRequest(urlSchemeTask.request)
+            )
+        }
+
+        return NativeRequestContext(
+            url: requestURLString,
+            method: ProxySchemeRequestSupport.normalizedRequestMethod(urlSchemeTask.request.httpMethod),
+            headers: urlSchemeTask.request.allHTTPHeaderFields ?? [:],
+            base64Body: extractBody(from: urlSchemeTask.request),
+            isMainFrame: ProxySchemeRequestSupport.isMainFrameRequest(urlSchemeTask.request)
+        )
+    }
+
+    private func finishCanceledSchemeTask(_ schemeTask: WKURLSchemeTask) {
+        guard let url = schemeTask.request.url,
+              let httpResponse = HTTPURLResponse(
+                url: url,
+                statusCode: 204,
+                httpVersion: "HTTP/1.1",
+                headerFields: [:]
+              )
+        else {
+            schemeTask.didFailWithError(
+                NSError(
+                    domain: "ProxySchemeHandler",
+                    code: -4,
+                    userInfo: [NSLocalizedDescriptionKey: "Failed to create canceled response"]
+                )
+            )
+            return
+        }
+
+        schemeTask.didReceive(httpResponse)
+        schemeTask.didReceive(Data())
+        schemeTask.didFinish()
+    }
     private func extractBody(from request: URLRequest) -> String? {
         if let body = request.httpBody {
             return body.base64EncodedString()

package/ios/Sources/InAppBrowserPlugin/Resources/proxy-bridge.js

@@ -0,0 +1,586 @@
+"use strict";
+(() => {
+  var __async = (__this, __arguments, generator) => {
+    return new Promise((resolve, reject) => {
+      var fulfilled = (value) => {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var rejected = (value) => {
+        try {
+          step(generator.throw(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+      step((generator = generator.apply(__this, __arguments)).next());
+    });
+  };
+
+  // src/proxy-bridge-support.ts
+  function findCapturedHeaderKey(headers, headerName) {
+    const normalizedHeaderName = headerName.toLowerCase();
+    for (const key of Object.keys(headers)) {
+      if (key.toLowerCase() === normalizedHeaderName) {
+        return key;
+      }
+    }
+    return null;
+  }
+  function isNativeProxyErrorResponse(response) {
+    return response.status === 599 && response.headers.get("x-capgo-proxy-error") !== null;
+  }
+  function nativeProxyErrorMessage(response) {
+    const nativeErrorHeader = response.headers.get("x-capgo-proxy-error");
+    if (!nativeErrorHeader) {
+      return "Network request failed";
+    }
+    const nativeMessage = nativeErrorHeader.trim();
+    return nativeMessage || "Network request failed";
+  }
+  function replaceCapturedHeader(headers, name, value) {
+    const existingKey = findCapturedHeaderKey(headers, name);
+    if (existingKey && existingKey !== name) {
+      delete headers[existingKey];
+    }
+    headers[name] = value;
+  }
+  function appendCapturedHeader(headers, name, value) {
+    const existingKey = findCapturedHeaderKey(headers, name);
+    if (!existingKey) {
+      headers[name] = value;
+      return;
+    }
+    headers[existingKey] = headers[existingKey] ? `${headers[existingKey]}, ${value}` : value;
+  }
+  function inferContentTypeFromBody(body) {
+    if (typeof body === "string") {
+      return "text/plain;charset=UTF-8";
+    }
+    if (body instanceof URLSearchParams) {
+      return "application/x-www-form-urlencoded;charset=UTF-8";
+    }
+    if (typeof Blob !== "undefined" && body instanceof Blob) {
+      return body.type || null;
+    }
+    return null;
+  }
+  function ensureInferredContentType(headers, body) {
+    if (findCapturedHeaderKey(headers, "content-type")) {
+      return;
+    }
+    const inferredContentType = inferContentTypeFromBody(body);
+    if (inferredContentType) {
+      headers["content-type"] = inferredContentType;
+    }
+  }
+  function resolveProxyBridgeUrl(rawUrl, baseUrl) {
+    try {
+      return new URL(rawUrl, baseUrl).href;
+    } catch (_error) {
+      return null;
+    }
+  }
+  function shouldProxyBridgeUrl(rawUrl, baseUrl, urlRegex) {
+    const resolvedUrl = resolveProxyBridgeUrl(rawUrl, baseUrl);
+    if (!resolvedUrl) {
+      return false;
+    }
+    const protocol = new URL(resolvedUrl).protocol.toLowerCase();
+    if (protocol !== "http:" && protocol !== "https:") {
+      return false;
+    }
+    return !urlRegex || urlRegex.test(resolvedUrl);
+  }
+  function getSubmitEventSubmitter(event, submitEventCtor) {
+    var _a, _b;
+    const resolvedSubmitEventCtor = submitEventCtor != null ? submitEventCtor : typeof SubmitEvent !== "undefined" ? SubmitEvent : void 0;
+    if (resolvedSubmitEventCtor && event instanceof resolvedSubmitEventCtor) {
+      return (_a = event.submitter) != null ? _a : null;
+    }
+    if ("submitter" in event) {
+      return (_b = event.submitter) != null ? _b : null;
+    }
+    return null;
+  }
+  function shouldProxySubmitEvent(defaultPrevented, canProxyTarget) {
+    return !defaultPrevented && canProxyTarget;
+  }
+  function shouldProxySubmitRequest(defaultPrevented, canProxyTarget, rawUrl, baseUrl, urlRegex) {
+    return shouldProxySubmitEvent(defaultPrevented, canProxyTarget) && shouldProxyBridgeUrl(rawUrl, baseUrl, urlRegex);
+  }
+  function consumeProxySubmitReplayBypass(form) {
+    if (!form.__capgoSkipNextProxySubmit) {
+      return false;
+    }
+    delete form.__capgoSkipNextProxySubmit;
+    return true;
+  }
+  function replaySubmitAfterProxyFailure(form, originalSubmit, submitter) {
+    if (typeof form.requestSubmit === "function") {
+      form.__capgoSkipNextProxySubmit = true;
+      try {
+        if (submitter !== null && submitter !== void 0) {
+          form.requestSubmit(submitter);
+        } else {
+          form.requestSubmit();
+        }
+        return;
+      } catch (_error) {
+        delete form.__capgoSkipNextProxySubmit;
+      }
+    }
+    originalSubmit.call(form);
+  }
+  function captureXhrReplayState(xhr) {
+    var _a, _b, _c, _d;
+    return {
+      responseType: (_a = xhr.responseType) != null ? _a : "",
+      timeout: (_b = xhr.timeout) != null ? _b : 0,
+      withCredentials: (_c = xhr.withCredentials) != null ? _c : false,
+      overrideMimeType: (_d = xhr.__proxyOverrideMimeType) != null ? _d : null
+    };
+  }
+  function restoreXhrReplayState(xhr, state) {
+    xhr.responseType = state.responseType;
+    xhr.timeout = state.timeout;
+    xhr.withCredentials = state.withCredentials;
+    xhr.__proxyOverrideMimeType = state.overrideMimeType;
+    if (state.overrideMimeType && typeof xhr.overrideMimeType === "function") {
+      xhr.overrideMimeType(state.overrideMimeType);
+    }
+  }
+
+  // src/proxy-bridge.ts
+  (function() {
+    const proxyBridge = window.__capgoProxy;
+    if (!proxyBridge) {
+      return;
+    }
+    const accessToken = "___CAPGO_PROXY_TOKEN___";
+    const proxyRegexSource = "___CAPGO_PROXY_REGEX___";
+    let requestCounter = 0;
+    let proxyRequestPattern = null;
+    if (proxyRegexSource) {
+      try {
+        proxyRequestPattern = new RegExp(proxyRegexSource);
+      } catch (_error) {
+        proxyRequestPattern = null;
+      }
+    }
+    function generateRequestId() {
+      return "pr_" + Date.now() + "_" + requestCounter++;
+    }
+    function arrayBufferToBase64(buffer) {
+      const bytes = new Uint8Array(buffer);
+      let binary = "";
+      for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+      }
+      return btoa(binary);
+    }
+    function stringToBase64(value) {
+      return btoa(unescape(encodeURIComponent(value)));
+    }
+    function hasHeader(headers, headerName) {
+      const normalizedHeaderName = headerName.toLowerCase();
+      return Object.keys(headers).some((key) => key.toLowerCase() === normalizedHeaderName);
+    }
+    function normalizeMethod(method) {
+      return (method || "GET").toUpperCase();
+    }
+    function normalizeCredentialsMode(mode) {
+      if (mode === "omit" || mode === "include") {
+        return mode;
+      }
+      return "same-origin";
+    }
+    function getDocumentBaseUrl() {
+      if (typeof document !== "undefined" && typeof document.baseURI === "string" && document.baseURI) {
+        return document.baseURI;
+      }
+      return window.location.href;
+    }
+    function resolveUrl(url) {
+      if (url && !url.match(/^[a-zA-Z][a-zA-Z0-9+\-.]*:\/\//)) {
+        try {
+          return new URL(url, getDocumentBaseUrl()).href;
+        } catch (_error) {
+          return url;
+        }
+      }
+      return url;
+    }
+    function methodSupportsRequestBody(method) {
+      const normalizedMethod = normalizeMethod(method);
+      return normalizedMethod !== "GET" && normalizedMethod !== "HEAD";
+    }
+    function bodyToBase64(body) {
+      return __async(this, null, function* () {
+        if (body === null || body === void 0) {
+          return null;
+        }
+        if (typeof body === "string") {
+          return stringToBase64(body);
+        }
+        if (body instanceof ArrayBuffer) {
+          return arrayBufferToBase64(body);
+        }
+        if (ArrayBuffer.isView(body)) {
+          return arrayBufferToBase64(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
+        }
+        if (body instanceof Blob) {
+          const buffer = yield body.arrayBuffer();
+          return arrayBufferToBase64(buffer);
+        }
+        if (body instanceof FormData) {
+          const buffer = yield new Response(body).arrayBuffer();
+          return arrayBufferToBase64(buffer);
+        }
+        if (body instanceof URLSearchParams) {
+          return stringToBase64(body.toString());
+        }
+        return null;
+      });
+    }
+    function storeInterceptedRequest(url, method, headers, body, credentialsMode) {
+      return __async(this, null, function* () {
+        const requestId = generateRequestId();
+        const normalizedMethod = normalizeMethod(method);
+        let normalizedBody = body;
+        if (normalizedBody instanceof FormData) {
+          const encoded = new Response(normalizedBody);
+          const contentType = encoded.headers.get("content-type");
+          if (contentType) {
+            replaceCapturedHeader(headers, "content-type", contentType);
+          }
+          normalizedBody = yield encoded.arrayBuffer();
+        }
+        if (!methodSupportsRequestBody(normalizedMethod)) {
+          normalizedBody = null;
+        }
+        ensureInferredContentType(headers, normalizedBody);
+        const base64Body = yield bodyToBase64(normalizedBody);
+        if (normalizedBody !== null && normalizedBody !== void 0 && base64Body === null && methodSupportsRequestBody(normalizedMethod)) {
+          throw new Error(`[proxy-bridge] Unsupported request body for ${normalizedMethod} proxy replay`);
+        }
+        proxyBridge.storeRequest(
+          accessToken,
+          requestId,
+          normalizedMethod,
+          JSON.stringify(headers),
+          base64Body || "",
+          normalizeCredentialsMode(credentialsMode)
+        );
+        return "/_capgo_proxy_?u=" + encodeURIComponent(url) + "&rid=" + requestId;
+      });
+    }
+    function getSubmitterAttribute(submitter, attributeName) {
+      if (!(submitter instanceof HTMLElement)) {
+        return null;
+      }
+      return submitter.getAttribute(attributeName);
+    }
+    function createFormData(form, submitter) {
+      if (submitter instanceof HTMLElement) {
+        try {
+          return new FormData(form, submitter);
+        } catch (_error) {
+        }
+      }
+      return new FormData(form);
+    }
+    function appendFormDataToUrl(url, formData) {
+      const resolvedUrl = new URL(url, getDocumentBaseUrl());
+      const searchParams = new URLSearchParams(resolvedUrl.search);
+      formData.forEach((value, key) => {
+        searchParams.append(key, typeof value === "string" ? value : value.name);
+      });
+      resolvedUrl.search = searchParams.toString();
+      return resolvedUrl.toString();
+    }
+    function formDataToUrlSearchParams(formData) {
+      const searchParams = new URLSearchParams();
+      formData.forEach((value, key) => {
+        searchParams.append(key, typeof value === "string" ? value : value.name);
+      });
+      return searchParams;
+    }
+    function formDataToPlainText(formData) {
+      const lines = [];
+      formData.forEach((value, key) => {
+        lines.push(key + "=" + (typeof value === "string" ? value : value.name));
+      });
+      return lines.join("\r\n");
+    }
+    function resolveFormMethod(form, submitter) {
+      return normalizeMethod(getSubmitterAttribute(submitter, "formmethod") || form.getAttribute("method"));
+    }
+    function resolveFormAction(form, submitter) {
+      return resolveUrl(
+        getSubmitterAttribute(submitter, "formaction") || form.getAttribute("action") || getDocumentBaseUrl()
+      );
+    }
+    function resolveFormTarget(form, submitter) {
+      return (getSubmitterAttribute(submitter, "formtarget") || form.getAttribute("target") || "").trim();
+    }
+    function resolveFormEnctype(form, submitter) {
+      return (getSubmitterAttribute(submitter, "formenctype") || form.getAttribute("enctype") || "application/x-www-form-urlencoded").toLowerCase();
+    }
+    function canProxyFormTarget(target) {
+      const normalizedTarget = target.toLowerCase();
+      return normalizedTarget === "" || normalizedTarget === "_self" || normalizedTarget === "_top" || normalizedTarget === "_parent";
+    }
+    function navigateFormProxy(proxyUrl, target) {
+      const normalizedTarget = target.toLowerCase();
+      if (!normalizedTarget || normalizedTarget === "_self") {
+        window.location.assign(proxyUrl);
+        return;
+      }
+      if (normalizedTarget === "_top" && window.top) {
+        window.top.location.assign(proxyUrl);
+        return;
+      }
+      if (normalizedTarget === "_parent" && window.parent) {
+        window.parent.location.assign(proxyUrl);
+        return;
+      }
+      window.location.assign(proxyUrl);
+    }
+    function proxyFormSubmission(form, submitter) {
+      return __async(this, null, function* () {
+        const target = resolveFormTarget(form, submitter);
+        if (!canProxyFormTarget(target)) {
+          return false;
+        }
+        const method = resolveFormMethod(form, submitter);
+        const actionUrl = resolveFormAction(form, submitter);
+        const formData = createFormData(form, submitter);
+        const headers = {};
+        let requestUrl = actionUrl;
+        let body = null;
+        if (method === "GET" || method === "HEAD") {
+          requestUrl = appendFormDataToUrl(actionUrl, formData);
+        } else {
+          const enctype = resolveFormEnctype(form, submitter);
+          if (enctype === "text/plain") {
+            headers["content-type"] = "text/plain;charset=UTF-8";
+            body = formDataToPlainText(formData);
+          } else if (enctype === "multipart/form-data") {
+            body = formData;
+          } else {
+            headers["content-type"] = "application/x-www-form-urlencoded;charset=UTF-8";
+            body = formDataToUrlSearchParams(formData);
+          }
+        }
+        if (!shouldProxyBridgeUrl(requestUrl, getDocumentBaseUrl(), proxyRequestPattern)) {
+          return false;
+        }
+        const proxyUrl = yield storeInterceptedRequest(requestUrl, method, headers, body, "include");
+        navigateFormProxy(proxyUrl, target);
+        return true;
+      });
+    }
+    const originalFetch = window.fetch;
+    window.fetch = function(input, init) {
+      return __async(this, null, function* () {
+        var _a;
+        let url;
+        let method = "GET";
+        const headers = {};
+        let inheritedHeaders = false;
+        let body = null;
+        let credentialsMode = "same-origin";
+        let requestCloneError = null;
+        if (input instanceof Request) {
+          url = input.url;
+          method = input.method;
+          credentialsMode = normalizeCredentialsMode(input.credentials);
+          inheritedHeaders = true;
+          input.headers.forEach((value, key) => {
+            headers[key] = value;
+          });
+          try {
+            const cloned = input.clone();
+            const buffer = yield cloned.arrayBuffer();
+            if (buffer.byteLength > 0) {
+              body = buffer;
+            }
+          } catch (error) {
+            requestCloneError = error;
+          }
+        } else {
+          url = input instanceof URL ? input.toString() : input;
+        }
+        url = resolveUrl(url);
+        if (init) {
+          if (init.method) {
+            method = init.method;
+          }
+          if (init.headers) {
+            if (inheritedHeaders) {
+              Object.keys(headers).forEach((key) => {
+                delete headers[key];
+              });
+              inheritedHeaders = false;
+            }
+            const normalized = new Headers(init.headers);
+            normalized.forEach((value, key) => {
+              headers[key] = value;
+            });
+          }
+          if (init.body !== void 0) {
+            body = init.body;
+          }
+          if (init.credentials) {
+            credentialsMode = normalizeCredentialsMode(init.credentials);
+          }
+        }
+        if (requestCloneError != null) {
+          return originalFetch.call(window, input, init);
+        }
+        if (!shouldProxyBridgeUrl(url, getDocumentBaseUrl(), proxyRequestPattern)) {
+          return originalFetch.call(window, input, init);
+        }
+        const signal = (_a = init == null ? void 0 : init.signal) != null ? _a : input instanceof Request ? input.signal : void 0;
+        let proxyUrl;
+        try {
+          proxyUrl = yield storeInterceptedRequest(url, method, headers, body, credentialsMode);
+        } catch (_error) {
+          return originalFetch.call(window, input, init);
+        }
+        const proxyResponse = yield originalFetch.call(globalThis, proxyUrl, {
+          method: "GET",
+          signal
+        });
+        if (isNativeProxyErrorResponse(proxyResponse)) {
+          throw new TypeError(nativeProxyErrorMessage(proxyResponse));
+        }
+        return proxyResponse;
+      });
+    };
+    const originalXhrOpen = XMLHttpRequest.prototype.open;
+    const originalXhrSend = XMLHttpRequest.prototype.send;
+    const originalXhrAbort = XMLHttpRequest.prototype.abort;
+    const originalXhrSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+    const originalXhrOverrideMimeType = XMLHttpRequest.prototype.overrideMimeType;
+    XMLHttpRequest.prototype.open = function(method, url, ...rest) {
+      this.__proxyMethod = method;
+      this.__proxyUrl = resolveUrl(url instanceof URL ? url.toString() : url);
+      this.__proxyHeaders = {};
+      this.__proxyAsync = rest[0] !== false;
+      this.__proxyCredentials = this.withCredentials ? "include" : "same-origin";
+      this.__proxyUsername = typeof rest[1] === "string" ? rest[1] : null;
+      this.__proxyPassword = typeof rest[2] === "string" ? rest[2] : "";
+      this.__proxyAborted = false;
+      this.__proxyOverrideMimeType = null;
+      return originalXhrOpen.apply(this, [method, url, ...rest]);
+    };
+    XMLHttpRequest.prototype.setRequestHeader = function(name, value) {
+      if (this.__proxyHeaders) {
+        appendCapturedHeader(this.__proxyHeaders, name, value);
+      }
+      return originalXhrSetRequestHeader.call(this, name, value);
+    };
+    XMLHttpRequest.prototype.abort = function() {
+      this.__proxyAborted = true;
+      return originalXhrAbort.call(this);
+    };
+    if (typeof originalXhrOverrideMimeType === "function") {
+      XMLHttpRequest.prototype.overrideMimeType = function(mimeType) {
+        this.__proxyOverrideMimeType = mimeType;
+        return originalXhrOverrideMimeType.call(this, mimeType);
+      };
+    }
+    XMLHttpRequest.prototype.send = function(body) {
+      const xhr = this;
+      const method = xhr.__proxyMethod || "GET";
+      const url = xhr.__proxyUrl || "";
+      const headers = xhr.__proxyHeaders || {};
+      const isAsync = xhr.__proxyAsync !== false;
+      const credentialsMode = xhr.withCredentials ? "include" : "same-origin";
+      const username = xhr.__proxyUsername;
+      const password = xhr.__proxyPassword;
+      if (typeof username === "string" && username.length > 0 && !hasHeader(headers, "Authorization")) {
+        headers["Authorization"] = "Basic " + stringToBase64(username + ":" + (typeof password === "string" ? password : ""));
+      }
+      function completeSend(proxyUrl) {
+        if (xhr.__proxyAborted) {
+          return;
+        }
+        const replayState = captureXhrReplayState(xhr);
+        originalXhrOpen.call(xhr, "GET", proxyUrl, true);
+        restoreXhrReplayState(xhr, replayState);
+        originalXhrSend.call(xhr, null);
+      }
+      if (!shouldProxyBridgeUrl(url, getDocumentBaseUrl(), proxyRequestPattern)) {
+        originalXhrSend.call(xhr, body != null ? body : null);
+        return;
+      }
+      if (!isAsync) {
+        console.warn("[proxy-bridge] Synchronous XMLHttpRequest cannot be proxied; falling back to the original request");
+        originalXhrSend.call(xhr, body != null ? body : null);
+        return;
+      }
+      storeInterceptedRequest(url, method, headers, body, credentialsMode).then((proxyUrl) => {
+        completeSend(proxyUrl);
+      }).catch((_error) => {
+        if (xhr.__proxyAborted) {
+          return;
+        }
+        console.error("[proxy-bridge] Failed to encode XMLHttpRequest body");
+        originalXhrSend.call(xhr, body != null ? body : null);
+      });
+    };
+    const originalFormSubmit = HTMLFormElement.prototype.submit;
+    document.addEventListener("submit", (event) => {
+      const form = event.target instanceof HTMLFormElement ? event.target : null;
+      if (!form) {
+        return;
+      }
+      if (consumeProxySubmitReplayBypass(form)) {
+        return;
+      }
+      const submitter = getSubmitEventSubmitter(event);
+      const target = resolveFormTarget(form, submitter);
+      const method = resolveFormMethod(form, submitter);
+      let requestUrl = resolveFormAction(form, submitter);
+      if (method === "GET" || method === "HEAD") {
+        requestUrl = appendFormDataToUrl(requestUrl, createFormData(form, submitter));
+      }
+      if (!shouldProxySubmitRequest(
+        event.defaultPrevented,
+        canProxyFormTarget(target),
+        requestUrl,
+        getDocumentBaseUrl(),
+        proxyRequestPattern
+      )) {
+        return;
+      }
+      event.preventDefault();
+      proxyFormSubmission(form, submitter).then((handled) => {
+        if (!handled) {
+          replaySubmitAfterProxyFailure(form, originalFormSubmit, submitter);
+        }
+      }).catch((error) => {
+        console.error("[proxy-bridge] Failed to proxy form submission", error);
+        replaySubmitAfterProxyFailure(form, originalFormSubmit, submitter);
+      });
+    });
+    HTMLFormElement.prototype.submit = function() {
+      const form = this;
+      proxyFormSubmission(form).then((handled) => {
+        if (!handled) {
+          originalFormSubmit.call(form);
+        }
+      }).catch((_error) => {
+        console.error("[proxy-bridge] Failed to proxy programmatic form submission");
+        originalFormSubmit.call(form);
+      });
+    };
+  })();
+})();

package/ios/Sources/InAppBrowserPlugin/WKWebViewController.swift

@@ -354,7 +354,7 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
         self.initWebview(isInspectable: isInspectable)
     }
 
-    public init(url: URL, headers: [String: String], isInspectable: Bool, credentials: WKWebViewCredentials? = nil, preventDeeplink: Bool, blankNavigationTab: Bool, enabledSafeBottomMargin: Bool, enabledSafeTopMargin: Bool = true, blockedHosts: [String], authorizedAppLinks: [String], allowWebViewJsVisibilityControl: Bool = false, allowScreenshotsFromWebPage: Bool = false, captureConsoleLogs: Bool = false, proxyRequests: Bool = false, proxySchemeHandler: ProxySchemeHandler? = nil, documentStartUserScripts: [String] = [], openBlankTargetInWebView: Bool = false) {
+    public init(url: URL, headers: [String: String], isInspectable: Bool, credentials: WKWebViewCredentials? = nil, preventDeeplink: Bool, blankNavigationTab: Bool, enabledSafeBottomMargin: Bool, enabledSafeTopMargin: Bool = true, blockedHosts: [String], authorizedAppLinks: [String], allowWebViewJsVisibilityControl: Bool = false, allowScreenshotsFromWebPage: Bool = false, captureConsoleLogs: Bool = false, proxyRequests: Bool = false, proxySchemeHandler: ProxySchemeHandler? = nil, proxyBridge: ProxyBridge? = nil, proxyBridgeAccessToken: String? = nil, legacyProxyRequestURLRegexPattern: String? = nil, documentStartUserScripts: [String] = [], openBlankTargetInWebView: Bool = false) {
         super.init(nibName: nil, bundle: nil)
         self.blankNavigationTab = blankNavigationTab
         self.enabledSafeBottomMargin = enabledSafeBottomMargin
@@ -366,6 +366,9 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
         self.captureConsoleLogs = captureConsoleLogs
         self.proxyRequests = proxyRequests
         self.proxySchemeHandler = proxySchemeHandler
+        self.proxyBridge = proxyBridge
+        self.proxyBridgeAccessToken = proxyBridgeAccessToken
+        self.legacyProxyRequestURLRegexPattern = legacyProxyRequestURLRegexPattern
         self.openBlankTargetInWebView = openBlankTargetInWebView
         self.setHeaders(headers: headers)
         self.setPreventDeeplink(preventDeeplink: preventDeeplink)
@@ -422,6 +425,9 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
     var disableOverscroll: Bool = false
     var proxyRequests: Bool = false
     var proxySchemeHandler: ProxySchemeHandler?
+    var proxyBridge: ProxyBridge?
+    var proxyBridgeAccessToken: String?
+    var legacyProxyRequestURLRegexPattern: String?
     var initialWebConfiguration: WKWebViewConfiguration?
     var waitsForPopupNavigation = false
     var hiddenPopupWindow = false
@@ -1298,6 +1304,25 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
             }
             print("[InAppBrowser - preShowScriptError]: Error!!!!")
             semaphore.signal()
+        } else if message.name == "capgoProxyBridge" {
+            guard let messageBody = message.body as? [String: Any],
+                  let token = messageBody["token"] as? String,
+                  let requestId = messageBody["requestId"] as? String,
+                  let method = messageBody["method"] as? String,
+                  let headersJson = messageBody["headersJson"] as? String else {
+                return
+            }
+
+            let base64Body = messageBody["base64Body"] as? String ?? ""
+            let credentialsMode = messageBody["credentialsMode"] as? String ?? "same-origin"
+            proxyBridge?.storeRequest(
+                token: token,
+                requestId: requestId,
+                method: method,
+                headersJson: headersJson,
+                base64Body: base64Body,
+                credentialsMode: credentialsMode
+            )
         } else if message.name == "close" {
             closeView()
         } else if message.name == "hide" {
@@ -1432,6 +1457,35 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
         userContentController.addUserScript(script)
     }
 
+    private func addProxyBridgeUserScripts(to userContentController: WKUserContentController) {
+        guard let accessToken = proxyBridgeAccessToken else {
+            return
+        }
+
+        let bootstrapScript = WKUserScript(
+            source: ProxyBridgeSupport.bootstrapScriptSource(),
+            injectionTime: .atDocumentStart,
+            forMainFrameOnly: false
+        )
+        userContentController.addUserScript(bootstrapScript)
+
+        let proxyRegexSource = legacyProxyRequestURLRegexPattern ?? ""
+        guard let bridgeScriptSource = ProxyBridgeSupport.loadBundledBridgeScript(
+            accessToken: accessToken,
+            proxyRegexSource: proxyRegexSource
+        ) else {
+            print("[InAppBrowser][Proxy] WARNING: Failed to load proxy-bridge.js for iOS injection")
+            return
+        }
+
+        let bridgeScript = WKUserScript(
+            source: bridgeScriptSource,
+            injectionTime: .atDocumentStart,
+            forMainFrameOnly: false
+        )
+        userContentController.addUserScript(bridgeScript)
+    }
+
     func injectJavaScriptInterface() {
         let script = mobileAppScriptSource()
         DispatchQueue.main.async {
@@ -1470,6 +1524,7 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
         userContentController.removeScriptMessageHandler(forName: "takeScreenshot")
         userContentController.removeScriptMessageHandler(forName: "consoleMessageHandler")
         userContentController.removeScriptMessageHandler(forName: "magicPrint")
+        userContentController.removeScriptMessageHandler(forName: "capgoProxyBridge")
 
         if proxyRequests || proxySchemeHandler != nil, let handler = proxySchemeHandler {
             WKWebView.enableCustomSchemeHandling(for: ["https", "http"])
@@ -1481,6 +1536,10 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
             }
         }
 
+        if ProxyBridgeSupport.shouldInjectBridge(hasProxySchemeHandler: proxySchemeHandler != nil) {
+            addProxyBridgeUserScripts(to: userContentController)
+        }
+
         let weakHandler = WeakScriptMessageHandler(self)
         userContentController.add(weakHandler, name: "messageHandler")
         userContentController.add(weakHandler, name: "preShowScriptError")
@@ -1516,6 +1575,9 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
                 )
             )
         }
+        if ProxyBridgeSupport.shouldInjectBridge(hasProxySchemeHandler: proxySchemeHandler != nil) {
+            userContentController.add(weakHandler, name: "capgoProxyBridge")
+        }
         userContentController.add(weakHandler, name: "magicPrint")
 
         // Inject JavaScript to override window.print
@@ -1704,7 +1766,9 @@ open class WKWebViewController: UIViewController, WKScriptMessageHandler {
         self.disableOverscroll = parent.disableOverscroll
         self.proxyRequests = parent.proxyRequests
         self.proxySchemeHandler = proxySchemeHandler
-        self.initialWebConfiguration = configuration
+        self.proxyBridge = parent.proxyBridge
+        self.proxyBridgeAccessToken = parent.proxyBridgeAccessToken
+        self.legacyProxyRequestURLRegexPattern = parent.legacyProxyRequestURLRegexPattern
         self.waitsForPopupNavigation = true
         self.hiddenPopupWindow = parent.hiddenPopupWindow
         self.opensHidden = parent.hiddenPopupWindow
@@ -1984,6 +2048,7 @@ public extension WKWebViewController {
         webView.configuration.userContentController.removeScriptMessageHandler(forName: "preShowScriptSuccess")
         webView.configuration.userContentController.removeScriptMessageHandler(forName: "preShowScriptError")
         webView.configuration.userContentController.removeScriptMessageHandler(forName: "magicPrint")
+        webView.configuration.userContentController.removeScriptMessageHandler(forName: "capgoProxyBridge")
 
         webView.removeFromSuperview()
         // Also clean progress bar view if present

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-inappbrowser",
-  "version": "8.6.32",
+  "version": "8.6.34",
   "description": "Capacitor plugin in app browser",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",
@@ -32,7 +32,7 @@
   ],
   "scripts": {
     "verify": "bun run verify:ios && bun run verify:android && bun run verify:web",
-    "verify:ios": "xcodebuild -scheme CapgoCapacitorInappbrowser -destination generic/platform=iOS",
+    "verify:ios": "bun run build:proxy-bridge && xcodebuild -scheme CapgoCapacitorInappbrowser -destination generic/platform=iOS",
     "verify:android": "cd android && ./gradlew clean build test && cd ..",
     "verify:web": "bun run build && bun run test:web",
     "test:web": "bun test src/proxy-bridge-support.test.ts",
@@ -43,7 +43,7 @@
     "prettier": "prettier-pretty-check \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
     "swiftlint": "node-swiftlint",
     "docgen": "docgen --api InAppBrowserPlugin --output-readme README.md --output-json dist/docs.json",
-    "build:proxy-bridge": "esbuild src/proxy-bridge.ts --bundle --outfile=android/src/main/assets/proxy-bridge.js --format=iife --target=es2015",
+    "build:proxy-bridge": "esbuild src/proxy-bridge.ts --bundle --outfile=android/src/main/assets/proxy-bridge.js --format=iife --target=es2015 && mkdir -p ios/Sources/InAppBrowserPlugin/Resources && cp android/src/main/assets/proxy-bridge.js ios/Sources/InAppBrowserPlugin/Resources/proxy-bridge.js",
     "build": "bun run clean && bun run docgen && tsc && rollup -c rollup.config.mjs && bun run build:proxy-bridge",
     "clean": "rimraf ./dist",
     "watch": "tsc --watch",