@dawidzawada/bonjour-zeroconf 1.0.0

package/ios/AddressResolverError.swift

@@ -0,0 +1,20 @@
+//
+//  BonjourError.swift
+//  Pods
+//
+//  Created by Dawid Zawada on 06/11/2025.
+//
+
+enum AddressResolverError: Error {
+    case timeout
+    case extractionFailed
+    
+    var localizedDescription: String {
+      switch self {
+      case .timeout:
+        return "Connection timed out"
+      case .extractionFailed:
+        return "Failed to extract IP and port information"
+      }
+    }
+}

package/ios/BonjourZeroconf+AddressResolver.swift

@@ -0,0 +1,133 @@
+//
+//  BonjourZeroconf+AddressResolver.swift
+//  Pods
+//
+//  Created by Dawid Zawada on 05/11/2025.
+//
+import Network
+
+extension BonjourZeroconf {
+  /// Resolve a service to get its IP address and port using async/await
+  internal func resolveService(result: NWBrowser.Result, name: String, timeout: TimeInterval) async -> ScanResult? {
+      do {
+          return try await withCheckedThrowingContinuation { continuation in
+              let connection = NWConnection(to: result.endpoint, using: .tcp)
+              
+              final class ResumeBox {
+                  var hasResumed = false
+              }
+              let box = ResumeBox()
+              
+              let timeoutTask = DispatchWorkItem {
+                  guard !box.hasResumed else { return }
+                  box.hasResumed = true
+                  Loggy.log(.debug, message: "Timeout resolving \(name)")
+                  continuation.resume(throwing: AddressResolverError.timeout)
+                  connection.cancel()
+              }
+              networkQueue.asyncAfter(deadline: .now() + timeout, execute: timeoutTask)
+              
+              connection.stateUpdateHandler = { [weak self] state in
+                  switch state {
+                  case .ready:
+                      timeoutTask.cancel()
+                      guard !box.hasResumed else { return }
+                      box.hasResumed = true
+                      
+                      if let remoteEndpoint = connection.currentPath?.remoteEndpoint,
+                         let scanResult = self?.extractIPAndPort(from: remoteEndpoint, serviceName: name) {
+                          continuation.resume(returning: scanResult)
+                      } else {
+                          continuation.resume(throwing: AddressResolverError.extractionFailed)
+                      }
+                      connection.cancel()
+                      
+                  case .failed(let error):
+                      timeoutTask.cancel()
+                      guard !box.hasResumed else { return }
+                      box.hasResumed = true
+                      Loggy.log(.error, message: "Failed to resolve service \(name): \(error.localizedDescription)")
+                      continuation.resume(throwing: error)
+                      connection.cancel()
+                      
+                  case .waiting(let error):
+                      Loggy.log(.debug, message: "Connection waiting for \(name): \(error.localizedDescription)")
+                      
+                  case .cancelled:
+                      break
+                      
+                  default:
+                      break
+                  }
+              }
+              
+            connection.start(queue: networkQueue)
+          }
+      } catch let error as AddressResolverError {
+        switch error {
+        case .timeout:
+            notifyScanFailListeners(with: BonjourFail.resolveFailed)
+          break;
+        case .extractionFailed:
+            notifyScanFailListeners(with: BonjourFail.extractionFailed)
+          break;
+        }
+        return nil
+    } catch {
+        return nil
+    }
+  }
+  
+  /// Extract IP address and port from an endpoint
+  internal func extractIPAndPort(from endpoint: NWEndpoint, serviceName: String) -> ScanResult? {
+      switch endpoint {
+      case .hostPort(let host, let port):
+          var ipv4: String?
+          var ipv6: String?
+          var hostname: String?
+          let portNumber = Int(port.rawValue)
+          
+          switch host {
+          case .ipv4(let address):
+              ipv4 = address.rawValue.map(String.init).joined(separator: ".")
+              Loggy.log(.debug, message: "Resolved \(serviceName) -> IPv4: \(ipv4!), Port: \(portNumber)")
+              
+          case .ipv6(let address):
+              let formatted = stride(from: 0, to: address.rawValue.count, by: 2).map { i in
+                  String(format: "%02x%02x", address.rawValue[i], address.rawValue[i + 1])
+              }.joined(separator: ":")
+              
+              if formatted.hasPrefix("fe80:") {
+                if let interface = endpoint.interface?.name {
+                      ipv6 = "\(formatted)%\(interface)"
+                  } else {
+                      ipv6 = "\(formatted)%en0"  // fallback
+                  }
+              } else {
+                  ipv6 = formatted
+              }
+              Loggy.log(.debug, message: "Resolved \(serviceName) -> IPv6: \(ipv6!), Port: \(portNumber)")
+              
+          case .name(let name, _):
+              hostname = name
+              Loggy.log(.debug, message: "Resolved \(serviceName) -> Hostname: \(hostname ?? "nil"), Port: \(portNumber)")
+              
+          @unknown default:
+              Loggy.log(.debug, message: "Unknown host type for \(serviceName)")
+              return nil
+          }
+          
+          return ScanResult(
+              name: serviceName,
+              ipv4: ipv4,
+              ipv6: ipv6,
+              hostname: hostname,
+              port: Double(portNumber)
+          )
+          
+      default:
+          Loggy.log(.warning, message: "Unexpected endpoint format for \(serviceName)")
+          return nil
+      }
+  }
+}

package/ios/BonjourZeroconf+Listeners.swift

@@ -0,0 +1,26 @@
+//
+//  BonjourZeroconf+Listeners.swift
+//  Pods
+//
+//  Created by Dawid Zawada on 05/11/2025.
+//
+
+extension BonjourZeroconf {
+  internal func notifyScanResultsListeners(with results: [ScanResult]) {
+    for listener in scanResultsListeners.values {
+      listener(results)
+    }
+  }
+  
+  internal func notifyScanStateListeners(with isScanningState: Bool) {
+    for listener in scanStateListeners.values {
+      listener(isScanningState)
+    }
+  }
+  
+  internal func notifyScanFailListeners(with fail: BonjourFail) {
+    for listener in scanFailListeners.values {
+      listener(fail)
+    }
+  }
+}

package/ios/BonjourZeroconf.swift

@@ -0,0 +1,201 @@
+import NitroModules
+import Foundation
+import Network
+
+class BonjourZeroconf: HybridBonjourZeroconfSpec {
+  private var _browser: NWBrowser?
+  private let serviceCache = ServiceCache()
+  
+  private let DEFAULT_RESOLVE_TIMEOUT = 10.0
+  
+  internal var scanResultsListeners: [UUID: ([ScanResult]) -> Void] = [:]
+  internal var scanStateListeners: [UUID: (Bool) -> Void] = [:]
+  internal var scanFailListeners: [UUID: (BonjourFail) -> Void] = [:]
+  internal let networkQueue = DispatchQueue(label: "com.bonjour-zeroconf.network", qos: .userInitiated)
+  
+  var isScanning: Bool {
+    return _isScanning
+  }
+  
+  internal var _isScanning = false {
+    didSet {
+      notifyScanStateListeners(with: _isScanning)
+    }
+  }
+
+
+  func scan(type: String, domain: String, options: ScanOptions?) {
+      if _isScanning {
+        Loggy.log(.warning, message: "Cannot start scanning, already scanning")
+        return
+      }
+    
+      let resolveTimeout = options?.addressResolveTimeout ?? DEFAULT_RESOLVE_TIMEOUT
+    
+      let browser = NWBrowser(for: .bonjour(type: type, domain: domain), using: .tcp)
+      self._browser = browser
+      self._isScanning = true
+      
+      browser.stateUpdateHandler = { [weak self] state in
+          guard let self = self else { return }
+          
+          switch state {
+          case .failed(let error):
+              notifyScanFailListeners(with: BonjourFail.discoveryFailed)
+              Loggy.log(.error, message: "Browser failed, reason: \(error.localizedDescription)")
+              browser.cancel()
+              self._isScanning = false
+              
+          case .ready:
+              Loggy.log(.info, message: "Browser ready")
+              
+          case .cancelled:
+              Loggy.log(.info, message: "Browser cancelled")
+              self._isScanning = false
+              
+          default:
+              break
+          }
+      }
+      
+      browser.browseResultsChangedHandler = { [weak self] results, changes in
+          guard let self = self else { return }
+          
+          Loggy.log(.info, message: "Found \(results.count) service(s)")
+          
+          Task {
+            await self.processChanges(changes, until: resolveTimeout)
+          }
+      }
+    
+      Loggy.log(.info, message: "Starting browser for service type: \(type)")
+      browser.start(queue: networkQueue)
+  }
+  
+  func listenForScanResults(onResult: @escaping ([ScanResult]) -> Void) -> BonjourListener {
+    let listenerId = UUID()
+    self.scanResultsListeners[listenerId] = onResult
+    
+    Task {
+        let cachedResults = await serviceCache.getAll()
+        onResult(cachedResults)
+    }
+    
+    return BonjourListener { [weak self] in
+      self?.scanResultsListeners.removeValue(forKey: listenerId)
+    }
+  }
+  
+  func listenForScanState(onChange: @escaping (Bool) -> Void) -> BonjourListener {
+    let listenerId = UUID()
+    self.scanStateListeners[listenerId] = onChange
+    
+    onChange(_isScanning)
+    
+    return BonjourListener { [weak self] in
+      self?.scanStateListeners.removeValue(forKey: listenerId)
+    }
+  }
+  
+  func listenForScanFail(onFail: @escaping (BonjourFail) -> Void) -> BonjourListener {
+    let listenerId = UUID()
+    self.scanFailListeners[listenerId] = onFail
+    
+    return BonjourListener { [weak self] in
+      self?.scanFailListeners.removeValue(forKey: listenerId)
+    }
+  }
+  
+
+  func stop() {
+      if let browser = self._browser {
+          browser.cancel()
+      }
+      
+      self._isScanning = false
+      Task {
+          await serviceCache.clear()
+      }
+      Loggy.log(.info, message: "Stopped scanning")
+  }
+  
+  /// Process all discovered services and resolve their IP addresses
+  private func processChanges(_ changes: Set<NWBrowser.Result.Change>, until resolveTimeout: Double) async {
+      var hasChanges = false
+      
+      var servicesToResolve: [(key: String, result: NWBrowser.Result, name: String)] = []
+      
+      for change in changes {
+          switch change {
+          case .added(let result):
+              guard let key = serviceKey(for: result) else { continue }
+              
+              if await serviceCache.get(key) == nil {
+                  guard case .service(let name, _, _, _) = result.endpoint else { continue }
+                  Loggy.log(.info, message: "New service detected: \(name)")
+                  servicesToResolve.append((key: key, result: result, name: name))
+                  hasChanges = true
+              } else {
+                  Loggy.log(.debug, message: "Service already cached: \(key)")
+              }
+              
+          case .removed(let result):
+            guard let key = serviceKey(for: result) else { continue }
+            
+            if await serviceCache.remove(key) != nil {
+                Loggy.log(.debug, message: "Service removed")
+                hasChanges = true
+            }
+              
+          case .changed(let _old, let new, let _flags):
+            guard let key = serviceKey(for: new) else { continue }
+            guard case .service(let name, _, _, _) = new.endpoint else { continue }
+            
+            Loggy.log(.debug, message: "Service changed: \(name)")
+            servicesToResolve.append((key: key, result: new, name: name))
+            hasChanges = true
+            
+          case .identical:
+              break
+              
+          @unknown default:
+              break
+          }
+      }
+      
+      // Resolve concurrently
+      if !servicesToResolve.isEmpty {
+          await withTaskGroup(of: (String, ScanResult?).self) { group in
+              for service in servicesToResolve {
+                  group.addTask {
+                      let scanResult = await self.resolveService(
+                          result: service.result,
+                          name: service.name,
+                          timeout: resolveTimeout
+                      )
+                      return (service.key, scanResult)
+                  }
+              }
+              
+              for await (key, scanResult) in group {
+                  if let scanResult = scanResult {
+                      await serviceCache.set(key, value: scanResult)
+                      Loggy.log(.debug, message: "Resolved and cached service: \(scanResult.name)")
+                  }
+              }
+          }
+      }
+      
+      if hasChanges {
+          let allResolvedServices = await serviceCache.getAll()
+          notifyScanResultsListeners(with: allResolvedServices)
+      }
+  }
+  
+  private func serviceKey(for result: NWBrowser.Result) -> String? {
+    guard case .service(let name, let type, let domain, _) = result.endpoint else {
+      return nil
+    }
+    return "\(name).\(type).\(domain)"
+  }
+}

package/ios/LocalNetworkAuthorization.swift

@@ -0,0 +1,66 @@
+//
+//  LocalNetworkAuthorization.swift
+//  Pods
+//
+//  Created by Dawid Zawada on 16/11/2025.
+//
+import Foundation
+import Network
+
+// This code is based on https://stackoverflow.com/a/67758105/2618437
+// And: https://github.com/neurio/react-native-local-network-permission
+public class LocalNetworkAuthorization: NSObject {
+    private var browser: NWBrowser?
+    private var netService: NetService?
+    private var completion: ((Bool) -> Void)?
+    
+    public func requestAuthorization(completion: @escaping (Bool) -> Void) {
+        self.completion = completion
+        
+        // Create parameters, and allow browsing over peer-to-peer link.
+        let parameters = NWParameters()
+        parameters.includePeerToPeer = true
+        
+        // Browse for a custom service type.
+        let browser = NWBrowser(for: .bonjour(type: "_bonjour._tcp", domain: nil), using: parameters)
+        self.browser = browser
+        browser.stateUpdateHandler = { newState in
+            switch newState {
+            case .failed(let error):
+                print(error.localizedDescription)
+            case .ready, .cancelled:
+                break
+            case let .waiting(error):
+                Loggy.log(.warning, message: "Local network permission has been denied: \(error)")
+                self.reset()
+                self.completion?(false)
+            default:
+                break
+            }
+        }
+        
+        self.netService = NetService(domain: "local.", type:"_lnp._tcp.", name: "LocalNetworkPrivacy", port: 1100)
+        self.netService?.delegate = self
+        
+        self.browser?.start(queue: .main)
+        self.netService?.publish()
+        // the netService needs to be scheduled on a run loop, in this case the main runloop
+        self.netService?.schedule(in: .main, forMode: .common)
+    }
+    
+    private func reset() {
+        print("resetting")
+        self.browser?.cancel()
+        self.browser = nil
+        self.netService?.stop()
+        self.netService = nil
+    }
+}
+
+extension LocalNetworkAuthorization : NetServiceDelegate {
+    public func netServiceDidPublish(_ sender: NetService) {
+        self.reset()
+        Loggy.log(.info, message: "Local Network permission granted")
+        completion?(true)
+    }
+}

package/ios/LocalNetworkPermission+Listeners.swift

@@ -0,0 +1,14 @@
+//
+//  LocalNetworkPermission+Listeners.swift
+//  Pods
+//
+//  Created by Dawid Zawada on 16/11/2025.
+//
+
+extension LocalNetworkPermission {
+  internal func notifyPermissionListeners(with granted: Bool) {
+    for listener in permissionListeners.values {
+      listener(granted)
+    }
+  }
+}

package/ios/LocalNetworkPermission.swift

@@ -0,0 +1,41 @@
+//
+//  LocalNetworkPermission.swift
+//  Pods
+//
+//  Created by Dawid Zawada on 16/11/2025.
+//
+import NitroModules
+import Network
+
+class LocalNetworkPermission: HybridLocalNetworkPermissionSpec {
+  internal var permissionListeners: [UUID: (Bool) -> Void] = [:]
+  
+  func requestPermission() throws -> Promise<Bool> {
+    return Promise.async {
+      if #available(iOS 14.0, *) {
+        return try await self.requestAuthorizationAsync()
+      } else {
+        return true
+      }
+    }
+  }
+  
+  func listenForPermission(onChange: @escaping (Bool) -> Void) -> BonjourListener {
+    let listenerId = UUID()
+    self.permissionListeners[listenerId] = onChange
+    
+    return BonjourListener { [weak self] in
+      self?.permissionListeners.removeValue(forKey: listenerId)
+    }
+  }
+  
+  private func requestAuthorizationAsync() async throws -> Bool {
+    return await withCheckedContinuation { continuation in
+      let authorizationInstance = LocalNetworkAuthorization()
+      authorizationInstance.requestAuthorization { granted in
+        self.notifyPermissionListeners(with: granted)
+        continuation.resume(returning: granted)
+      }
+    }
+  }
+}

package/ios/ServiceCache.swift

@@ -0,0 +1,30 @@
+//
+//  ServiceCache.swift
+//  Pods
+//
+//  Created by Dawid Zawada on 05/11/2025.
+//
+
+actor ServiceCache {
+    private var cache: [String: ScanResult] = [:]
+    
+    func get(_ key: String) -> ScanResult? {
+        return cache[key]
+    }
+    
+    func set(_ key: String, value: ScanResult) {
+        cache[key] = value
+    }
+    
+    func remove(_ key: String) -> ScanResult? {
+        return cache.removeValue(forKey: key)
+    }
+    
+    func getAll() -> [ScanResult] {
+        return Array(cache.values)
+    }
+    
+    func clear() {
+        cache.removeAll()
+    }
+}

package/ios/Utils/Loggy.swift

@@ -0,0 +1,37 @@
+//
+//  Logger.swift
+//  Pods
+//
+//  Created by Dawid Zawada on 17/11/2025.
+//
+enum LogLevel: String {
+  case debug
+  case info
+  case warning
+  case error
+}
+
+enum Loggy {
+  static var staticFormatter: DateFormatter?
+  static var formatter: DateFormatter {
+    guard let staticFormatter else {
+      let formatter = DateFormatter()
+      formatter.dateFormat = "HH:mm:ss.SSS"
+      self.staticFormatter = formatter
+      return formatter
+    }
+    return staticFormatter
+  }
+
+  /**
+   * Log a message to the console`
+   */
+  @inlinable
+  static func log(_ level: LogLevel,
+                  message: String,
+                  _ function: String = #function) {
+    let now = Date()
+    let time = formatter.string(from: now)
+    print("\(time): [\(level.rawValue)] 🌐 BonjourZeroconf.\(function): \(message)")
+  }
+}

package/lib/module/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+import { useIsScanning } from "./useIsScanning.js";
+import { BonjourFail } from "./specs/BonjourFail.js";
+import { requestLocalNetworkPermission, useLocalNetworkPermission } from './permissions';
+export const Scanner = NitroModules.createHybridObject('BonjourZeroconf');
+export { useIsScanning, requestLocalNetworkPermission, useLocalNetworkPermission, BonjourFail };
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","useIsScanning","BonjourFail","requestLocalNetworkPermission","useLocalNetworkPermission","Scanner","createHybridObject"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAEzD,SAASC,aAAa,QAAQ,oBAAiB;AAG/C,SAASC,WAAW,QAAQ,wBAAqB;AACjD,SACEC,6BAA6B,EAC7BC,yBAAyB,QACpB,eAAe;AAEtB,OAAO,MAAMC,OAAO,GAClBL,YAAY,CAACM,kBAAkB,CAAkB,iBAAiB,CAAC;AAErE,SACEL,aAAa,EACbE,6BAA6B,EAC7BC,yBAAyB,EACzBF,WAAW","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/permissions.ios.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+import { useEffect, useState } from 'react';
+const LocalNetworkPermission = NitroModules.createHybridObject('LocalNetworkPermission');
+export const requestLocalNetworkPermission = async () => {
+  return await LocalNetworkPermission.requestPermission();
+};
+export const useLocalNetworkPermission = () => {
+  const [permissionGranted, setPermissionGranted] = useState(false);
+  useEffect(() => {
+    const {
+      remove
+    } = LocalNetworkPermission.listenForPermission(granted => {
+      setPermissionGranted(granted);
+    });
+    return () => {
+      remove();
+    };
+  }, []);
+  return [permissionGranted, requestLocalNetworkPermission];
+};
+//# sourceMappingURL=permissions.ios.js.map

package/lib/module/permissions.ios.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","useEffect","useState","LocalNetworkPermission","createHybridObject","requestLocalNetworkPermission","requestPermission","useLocalNetworkPermission","permissionGranted","setPermissionGranted","remove","listenForPermission","granted"],"sourceRoot":"../../src","sources":["permissions.ios.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAEzD,SAASC,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AAE3C,MAAMC,sBAAsB,GAC1BH,YAAY,CAACI,kBAAkB,CAC7B,wBACF,CAAC;AAEH,OAAO,MAAMC,6BAA6B,GAAG,MAAAA,CAAA,KAAY;EACvD,OAAO,MAAMF,sBAAsB,CAACG,iBAAiB,CAAC,CAAC;AACzD,CAAC;AAED,OAAO,MAAMC,yBAAyB,GAAGA,CAAA,KAAM;EAC7C,MAAM,CAACC,iBAAiB,EAAEC,oBAAoB,CAAC,GAAGP,QAAQ,CAAC,KAAK,CAAC;EAEjED,SAAS,CAAC,MAAM;IACd,MAAM;MAAES;IAAO,CAAC,GAAGP,sBAAsB,CAACQ,mBAAmB,CAAEC,OAAO,IAAK;MACzEH,oBAAoB,CAACG,OAAO,CAAC;IAC/B,CAAC,CAAC;IACF,OAAO,MAAM;MACXF,MAAM,CAAC,CAAC;IACV,CAAC;EACH,CAAC,EAAE,EAAE,CAAC;EAEN,OAAO,CAACF,iBAAiB,EAAEH,6BAA6B,CAAC;AAC3D,CAAC","ignoreList":[]}

package/lib/module/permissions.js

@@ -0,0 +1,9 @@
+"use strict";
+
+export const requestLocalNetworkPermission = async () => {
+  return true;
+};
+export const useLocalNetworkPermission = () => {
+  return [true, requestLocalNetworkPermission];
+};
+//# sourceMappingURL=permissions.js.map

package/lib/module/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["requestLocalNetworkPermission","useLocalNetworkPermission"],"sourceRoot":"../../src","sources":["permissions.ts"],"mappings":";;AAAA,OAAO,MAAMA,6BAA6B,GAAG,MAAAA,CAAA,KAAY;EACvD,OAAO,IAAI;AACb,CAAC;AAED,OAAO,MAAMC,yBAAyB,GAAGA,CAAA,KAAM;EAC7C,OAAO,CAAC,IAAI,EAAED,6BAA6B,CAAC;AAC9C,CAAC","ignoreList":[]}

package/lib/module/specs/BonjourFail.js

@@ -0,0 +1,9 @@
+"use strict";
+
+export let BonjourFail = /*#__PURE__*/function (BonjourFail) {
+  BonjourFail[BonjourFail["RESOLVE_FAILED"] = 0] = "RESOLVE_FAILED";
+  BonjourFail[BonjourFail["EXTRACTION_FAILED"] = 1] = "EXTRACTION_FAILED";
+  BonjourFail[BonjourFail["DISCOVERY_FAILED"] = 2] = "DISCOVERY_FAILED";
+  return BonjourFail;
+}({});
+//# sourceMappingURL=BonjourFail.js.map

package/lib/module/specs/BonjourFail.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BonjourFail"],"sourceRoot":"../../../src","sources":["specs/BonjourFail.ts"],"mappings":";;AAAA,WAAYA,WAAW,0BAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAXA,WAAW,CAAXA,WAAW;EAAA,OAAXA,WAAW;AAAA","ignoreList":[]}

package/lib/module/specs/BonjourListener.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=BonjourListener.js.map

package/lib/module/specs/BonjourListener.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/BonjourListener.ts"],"mappings":"","ignoreList":[]}

package/lib/module/specs/BonjourZeroconf.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=BonjourZeroconf.nitro.js.map

package/lib/module/specs/BonjourZeroconf.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/BonjourZeroconf.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/specs/LocalNetworkPermission.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=LocalNetworkPermission.nitro.js.map

package/lib/module/specs/LocalNetworkPermission.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/LocalNetworkPermission.nitro.ts"],"mappings":"","ignoreList":[]}