react-native-queue-player 1.0.0

package/ios/Cast/Core/LocalNetworkPermissionProbe.swift

@@ -0,0 +1,265 @@
+import Foundation
+import Network
+import NitroModules
+
+/// iOS Local Network permission preflight per Apple's TN3179
+/// ("Understanding Local Network Privacy"). Pairs an `NWListener`
+/// advertising a custom Bonjour service with an `NWBrowser` looking
+/// for the same service. If the browser sees the listener's advert,
+/// the system has granted Local Network permission; if the browser
+/// fails with an LNA-specific error code, permission has been denied;
+/// otherwise the state stays `.undetermined`.
+///
+/// First call to `requestPermission()` triggers the iOS system prompt
+/// if the app hasn't been asked yet. Subsequent calls within the TTL
+/// return the cached result.
+///
+/// Caller (`CastManager`) wires the probe's state-change callback to
+/// the existing `onLocalNetworkPermissionChange` listener registry so
+/// JS consumers see grant / deny transitions.
+final class LocalNetworkPermissionProbe {
+
+  /// Bonjour service type for the paired probe. Custom + app-scoped
+  /// so it never collides with another app's discovery / responses.
+  static let serviceType = "_rnqp-lnp._tcp"
+
+  /// Cached permission state TTL. Permission is system-mutable (the
+  /// user can revoke in Settings while the app runs), so the probe
+  /// re-runs after this window if the state is read past the TTL.
+  static let cacheTTLSeconds: TimeInterval = 60.0
+
+  /// Default per-probe timeout — the system prompt is async on first
+  /// run; this caps the wait for browser activity.
+  static let probeTimeoutSeconds: TimeInterval = 8.0
+
+  /// Multi-listener registry mirrored from `CastManager`'s typed
+  /// callback pattern. `CastManager.onLocalNetworkPermissionChange`
+  /// adds one listener; future native consumers can add more.
+  private var listeners: [Int64: (CastLocalNetworkPermission) -> Void] = [:]
+  private var nextListenerId: Int64 = 0
+  private let listenerLock = NSLock()
+
+  private let queue = DispatchQueue(label: "queueplayer.lna-probe")
+
+  /// Lock-protected mutable state. The probe runs entirely on `queue`
+  /// so all mutations happen serially; reads from other threads take
+  /// the lock.
+  private let stateLock = NSLock()
+  private var _cachedState: CastLocalNetworkPermission = .undetermined
+  private var _cachedAt: Date?
+  private var _activeProbe: ProbeRun?
+
+  init() {}
+
+  /// Snapshot of the most recently resolved permission state. Returns
+  /// `.undetermined` if no probe has resolved yet, or if the cached
+  /// result has expired past the TTL.
+  var cachedState: CastLocalNetworkPermission {
+    stateLock.lock(); defer { stateLock.unlock() }
+    if let at = _cachedAt, Date().timeIntervalSince(at) < Self.cacheTTLSeconds {
+      return _cachedState
+    }
+    return .undetermined
+  }
+
+  /// Trigger the probe. Returns immediately with a `Promise` that
+  /// resolves to the final permission state. First call on a fresh
+  /// app install raises the iOS system prompt for Local Network
+  /// access; subsequent calls within the TTL skip the probe and
+  /// resolve with the cached value.
+  func requestPermission() -> Promise<CastLocalNetworkPermission> {
+    let promise = Promise<CastLocalNetworkPermission>()
+
+    stateLock.lock()
+    if let at = _cachedAt, Date().timeIntervalSince(at) < Self.cacheTTLSeconds {
+      let cached = _cachedState
+      stateLock.unlock()
+      promise.resolve(withResult: cached)
+      return promise
+    }
+    if let active = _activeProbe {
+      active.subscribe(promise)
+      stateLock.unlock()
+      return promise
+    }
+    let probe = ProbeRun(parent: self, queue: queue)
+    _activeProbe = probe
+    probe.subscribe(promise)
+    stateLock.unlock()
+
+    queue.async { probe.start() }
+    return promise
+  }
+
+  // MARK: - Listener registry
+
+  func addListener(
+    _ callback: @escaping (CastLocalNetworkPermission) -> Void
+  ) -> () -> Void {
+    listenerLock.lock()
+    nextListenerId += 1
+    let id = nextListenerId
+    listeners[id] = callback
+    listenerLock.unlock()
+    return { [weak self] in
+      guard let self else { return }
+      self.listenerLock.lock()
+      self.listeners.removeValue(forKey: id)
+      self.listenerLock.unlock()
+    }
+  }
+
+  // MARK: - Probe completion (called by ProbeRun on `queue`)
+
+  fileprivate func completeProbe(with state: CastLocalNetworkPermission) {
+    var snapshotListeners: [(CastLocalNetworkPermission) -> Void] = []
+    let previousState: CastLocalNetworkPermission
+    stateLock.lock()
+    previousState = _cachedState
+    _cachedState = state
+    _cachedAt = Date()
+    _activeProbe = nil
+    stateLock.unlock()
+    if previousState != state {
+      listenerLock.lock()
+      snapshotListeners = Array(listeners.values)
+      listenerLock.unlock()
+      for l in snapshotListeners { l(state) }
+    }
+  }
+}
+
+/// One in-flight probe. Owns the paired NWBrowser + NWListener and
+/// fans the outcome into all subscribed promises.
+fileprivate final class ProbeRun {
+  private weak var parent: LocalNetworkPermissionProbe?
+  private let queue: DispatchQueue
+  private var listener: NWListener?
+  private var browser: NWBrowser?
+  private var timeoutItem: DispatchWorkItem?
+  /// Guards `promises` + `resolved` so a late `subscribe` cannot land
+  /// a promise into a probe that already resolved + cleared its
+  /// promise list. Either the late promise resolves immediately with
+  /// the terminal state, or it joins the still-pending list.
+  private let lock = NSLock()
+  private var promises: [Promise<CastLocalNetworkPermission>] = []
+  private var resolved = false
+  private var resolvedState: CastLocalNetworkPermission = .undetermined
+
+  init(parent: LocalNetworkPermissionProbe, queue: DispatchQueue) {
+    self.parent = parent
+    self.queue = queue
+  }
+
+  func subscribe(_ promise: Promise<CastLocalNetworkPermission>) {
+    lock.lock()
+    if resolved {
+      let state = resolvedState
+      lock.unlock()
+      promise.resolve(withResult: state)
+      return
+    }
+    promises.append(promise)
+    lock.unlock()
+  }
+
+  func start() {
+    do {
+      let listener = try NWListener(
+        using: NWParameters.tcp,
+        on: .any
+      )
+      listener.service = NWListener.Service(
+        name: nil,
+        type: LocalNetworkPermissionProbe.serviceType
+      )
+      // Listener is advertisement-only — `.granted` resolution comes
+      // exclusively from `browseResultsChangedHandler` seeing the
+      // advert. Accepting raw TCP traffic on the listener's port
+      // would false-positive on a port-scanning LAN peer.
+      listener.newConnectionHandler = { connection in connection.cancel() }
+      listener.start(queue: queue)
+      self.listener = listener
+
+      let browser = NWBrowser(
+        for: .bonjour(type: LocalNetworkPermissionProbe.serviceType, domain: nil),
+        using: NWParameters.tcp
+      )
+      browser.stateUpdateHandler = { [weak self] state in
+        self?.handleBrowserState(state)
+      }
+      browser.browseResultsChangedHandler = { [weak self] results, _ in
+        if !results.isEmpty {
+          self?.resolve(.granted)
+        }
+      }
+      browser.start(queue: queue)
+      self.browser = browser
+
+      let timeout = DispatchWorkItem { [weak self] in
+        // No browser activity within the cap — treat as undetermined.
+        // Apple's prompt may still be visible; the next probe call
+        // re-asks and may resolve.
+        self?.resolve(.undetermined)
+      }
+      timeoutItem = timeout
+      queue.asyncAfter(
+        deadline: .now() + LocalNetworkPermissionProbe.probeTimeoutSeconds,
+        execute: timeout
+      )
+    } catch {
+      NSLog("[LocalNetworkPermissionProbe] NWListener failed to start: \(error)")
+      resolve(.undetermined)
+    }
+  }
+
+  private func handleBrowserState(_ state: NWBrowser.State) {
+    switch state {
+    case .failed(let error):
+      if Self.isLocalNetworkDeniedError(error) {
+        resolve(.denied)
+      } else {
+        resolve(.undetermined)
+      }
+    case .cancelled:
+      // Browser cancelled before resolving — stay undetermined and
+      // let the next requestPermission() call try again.
+      resolve(.undetermined)
+    default:
+      break
+    }
+  }
+
+  private func resolve(_ state: CastLocalNetworkPermission) {
+    lock.lock()
+    if resolved {
+      lock.unlock()
+      return
+    }
+    resolved = true
+    resolvedState = state
+    let resolvedPromises = promises
+    promises.removeAll()
+    lock.unlock()
+
+    timeoutItem?.cancel()
+    timeoutItem = nil
+    browser?.cancel()
+    listener?.cancel()
+    browser = nil
+    listener = nil
+    parent?.completeProbe(with: state)
+    for p in resolvedPromises { p.resolve(withResult: state) }
+  }
+
+  /// Detect the LNA-denied error code. Network.framework surfaces it
+  /// as a POSIX `EACCES` wrapped in `NWError.posix(.EACCES)`. Other
+  /// failure modes (no Wi-Fi, system error) fall through to
+  /// `.undetermined`.
+  static func isLocalNetworkDeniedError(_ error: NWError) -> Bool {
+    if case .posix(let code) = error, code == .EACCES {
+      return true
+    }
+    return false
+  }
+}

package/ios/Cast/Core/MediaHTTPConnection.swift

@@ -0,0 +1,349 @@
+import Foundation
+import Network
+
+/// Resolution of an HTTP `Range` header against a known file size.
+enum MediaByteRange: Equatable {
+  /// No Range header, or one the server ignores (malformed / invalid
+  /// bounds) — serve the whole file with `200`.
+  case full
+  /// A satisfiable single range with inclusive bounds — serve `206`.
+  case partial(start: Int64, end: Int64)
+  /// A syntactically-valid range that starts past EOF — serve `416`.
+  case unsatisfiable
+}
+
+/// Parsed view of an incoming request: the method, the request target,
+/// and the one header the file server acts on (`Range`). Built from the
+/// raw header block (everything before the `\r\n\r\n` terminator).
+struct MediaHTTPRequest: Equatable {
+  let method: String
+  let path: String
+  let rangeHeader: String?
+
+  /// The `<token>` from a `/media/<32-hex>` path, or `nil` when the path
+  /// is anything else. The token is both the routing key (which file) and
+  /// the access secret (high-entropy, unenumerable) for the LAN-reachable
+  /// server.
+  var mediaToken: String? {
+    let prefix = "/media/"
+    guard path.hasPrefix(prefix) else { return nil }
+    let token = String(path.dropFirst(prefix.count))
+    guard token.count == 32,
+          token.allSatisfy({ ($0 >= "0" && $0 <= "9") || ($0 >= "a" && $0 <= "f") })
+    else { return nil }
+    return token
+  }
+
+  init?(headerData: Data) {
+    guard let text = String(data: headerData, encoding: .utf8) else { return nil }
+    var lines = text.components(separatedBy: "\r\n")
+    guard !lines.isEmpty else { return nil }
+    let requestLine = lines.removeFirst().split(separator: " ")
+    guard requestLine.count >= 2 else { return nil }
+    self.method = String(requestLine[0]).uppercased()
+    // Strip any query string — the file path never carries one, and the
+    // token match below expects the bare path.
+    let target = String(requestLine[1])
+    self.path = target.split(separator: "?", maxSplits: 1).first.map(String.init) ?? target
+
+    var range: String?
+    for line in lines where !line.isEmpty {
+      guard let colon = line.firstIndex(of: ":") else { continue }
+      let name = line[line.startIndex..<colon].trimmingCharacters(in: .whitespaces).lowercased()
+      if name == "range" {
+        range = String(line[line.index(after: colon)...]).trimmingCharacters(in: .whitespaces)
+      }
+    }
+    self.rangeHeader = range
+  }
+}
+
+/// Serves one local file over a single `NWConnection` as HTTP/1.1:
+/// `GET`/`HEAD` on `/media/<token>` with `Range` support (the Cast
+/// receiver byte-range probes + seeks). One responder per accepted
+/// connection; it owns the connection, runs all I/O on a dedicated serial
+/// queue, streams the body in bounded chunks (no whole-file buffering),
+/// and reports completion via `onFinished` so the owner can drop it.
+final class MediaHTTPConnection {
+
+  private let connection: NWConnection
+  private let registry: MediaTokenRegistry
+  private let onFinished: () -> Void
+  private let queue: DispatchQueue
+  /// In-flight body-streaming task, cancelled when the client hangs up so
+  /// we stop reading a range the receiver has abandoned.
+  private var streamTask: Task<Void, Never>?
+  private let stateLock = NSLock()
+  private var finished = false
+
+  /// Bound on the accumulated request header so a stalled/malicious client
+  /// can't grow the buffer without limit.
+  private static let maxHeaderBytes = 64 * 1024
+  /// Body streaming chunk — keeps memory flat for large offline files.
+  private static let chunkBytes = 256 * 1024
+  private static let headerTerminator = Data("\r\n\r\n".utf8)
+
+  init(
+    connection: NWConnection,
+    registry: MediaTokenRegistry,
+    onFinished: @escaping () -> Void
+  ) {
+    self.connection = connection
+    self.registry = registry
+    self.onFinished = onFinished
+    self.queue = DispatchQueue(label: "queueplayer.cast.mediaserver.conn")
+  }
+
+  func start() {
+    connection.stateUpdateHandler = { [weak self] state in
+      guard let self = self else { return }
+      switch state {
+      case .ready:
+        self.readRequest(buffer: Data())
+      case .failed(let error):
+        // A receiver cancelling a range connection it no longer needs
+        // arrives here as a reset — expected churn, not an error.
+        if !Self.isBenignDisconnect(error) {
+          NSLog("[LocalMediaServer] connection failed: \(error)")
+        }
+        self.cancel()
+      case .cancelled:
+        self.finish()
+      default:
+        break
+      }
+    }
+    connection.start(queue: queue)
+  }
+
+  /// Cancel the connection + any in-flight streaming. Idempotent.
+  func cancel() {
+    stateLock.lock()
+    let task = streamTask
+    streamTask = nil
+    stateLock.unlock()
+    task?.cancel()
+    connection.cancel()
+  }
+
+  // MARK: - Request
+
+  private func readRequest(buffer: Data) {
+    connection.receive(minimumIncompleteLength: 1, maximumLength: 16 * 1024) {
+      [weak self] data, _, isComplete, error in
+      guard let self = self else { return }
+      if error != nil {
+        self.cancel()
+        return
+      }
+      var buf = buffer
+      if let data = data { buf.append(data) }
+      // Bound the header accumulation right after the append so a client
+      // that never sends `\r\n\r\n` can't grow the buffer past the cap.
+      if buf.count > Self.maxHeaderBytes {
+        self.respondError(status: 431, reason: "Request Header Fields Too Large")
+        return
+      }
+      guard let terminator = Self.firstRange(of: Self.headerTerminator, in: buf) else {
+        if isComplete {
+          self.cancel()
+        } else {
+          self.readRequest(buffer: buf)
+        }
+        return
+      }
+      let headerData = buf.subdata(in: buf.startIndex..<terminator.lowerBound)
+      guard let request = MediaHTTPRequest(headerData: headerData) else {
+        self.respondError(status: 400, reason: "Bad Request")
+        return
+      }
+      self.serve(request)
+    }
+  }
+
+  private func serve(_ request: MediaHTTPRequest) {
+    guard request.method == "GET" || request.method == "HEAD" else {
+      respondError(status: 405, reason: "Method Not Allowed")
+      return
+    }
+    guard let token = request.mediaToken, let media = registry.resolve(token) else {
+      respondError(status: 404, reason: "Not Found")
+      return
+    }
+    let fm = FileManager.default
+    var isDir: ObjCBool = false
+    guard fm.fileExists(atPath: media.fileURL.path, isDirectory: &isDir), !isDir.boolValue,
+          let attrs = try? fm.attributesOfItem(atPath: media.fileURL.path),
+          let size = (attrs[.size] as? NSNumber)?.int64Value
+    else {
+      respondError(status: 404, reason: "Not Found")
+      return
+    }
+
+    let isHead = request.method == "HEAD"
+    switch Self.resolveRange(request.rangeHeader, fileSize: size) {
+    case .full:
+      let head = Self.headFull(contentType: media.contentType, fileSize: size)
+      sendBodyAfterHead(head, fileURL: media.fileURL, start: 0, end: max(0, size - 1), include: size > 0 && !isHead)
+    case .partial(let start, let end):
+      let head = Self.headPartial(contentType: media.contentType, start: start, end: end, fileSize: size)
+      sendBodyAfterHead(head, fileURL: media.fileURL, start: start, end: end, include: !isHead)
+    case .unsatisfiable:
+      sendHeadOnly(Self.headUnsatisfiable(fileSize: size))
+    }
+  }
+
+  // MARK: - Response
+
+  private func sendHeadOnly(_ head: String) {
+    connection.send(content: Data(head.utf8), completion: .contentProcessed { [weak self] _ in
+      self?.cancel()
+    })
+  }
+
+  /// Send the header block, then (when `include`) stream the inclusive
+  /// `[start, end]` byte range from `fileURL` in bounded chunks. A `HEAD`
+  /// or an empty body sends the head and closes.
+  private func sendBodyAfterHead(_ head: String, fileURL: URL, start: Int64, end: Int64, include: Bool) {
+    let task = Task { [weak self] in
+      guard let self = self else { return }
+      do {
+        try await self.send(Data(head.utf8))
+        if include {
+          try await self.streamFile(fileURL, start: start, end: end)
+        }
+        self.cancel()
+      } catch {
+        // A client disconnect mid-stream surfaces as a send/read failure —
+        // normal churn for cancelled range requests, just clean up.
+        self.cancel()
+      }
+    }
+    stateLock.lock()
+    streamTask = task
+    stateLock.unlock()
+  }
+
+  private func streamFile(_ fileURL: URL, start: Int64, end: Int64) async throws {
+    let handle = try FileHandle(forReadingFrom: fileURL)
+    defer { try? handle.close() }
+    try handle.seek(toOffset: UInt64(start))
+    var remaining = end - start + 1
+    while remaining > 0 {
+      if Task.isCancelled { return }
+      let want = Int(min(Int64(Self.chunkBytes), remaining))
+      guard let chunk = try handle.read(upToCount: want), !chunk.isEmpty else { return }
+      try await send(chunk)
+      remaining -= Int64(chunk.count)
+    }
+  }
+
+  private func send(_ data: Data) async throws {
+    try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
+      connection.send(content: data, completion: .contentProcessed { error in
+        if let error = error { cont.resume(throwing: error) } else { cont.resume(returning: ()) }
+      })
+    }
+  }
+
+  private func respondError(status: Int, reason: String) {
+    sendHeadOnly(Self.headError(status: status, reason: reason))
+  }
+
+  private func finish() {
+    stateLock.lock()
+    if finished { stateLock.unlock(); return }
+    finished = true
+    let task = streamTask
+    streamTask = nil
+    stateLock.unlock()
+    task?.cancel()
+    onFinished()
+  }
+
+  // MARK: - Range resolution (pure)
+
+  /// Resolve an HTTP `Range` header against `fileSize`. Single-range only
+  /// (the Cast receiver never sends multi-range); a multi-range header
+  /// resolves to its first range. Per RFC 7233 a malformed / inverted
+  /// range is ignored (`.full`, i.e. `200`); a syntactically-valid range
+  /// starting at or past EOF is `.unsatisfiable` (`416`).
+  static func resolveRange(_ header: String?, fileSize: Int64) -> MediaByteRange {
+    guard fileSize > 0 else { return .full }
+    guard let raw = header?.lowercased(), raw.hasPrefix("bytes=") else { return .full }
+    let spec = raw.dropFirst("bytes=".count)
+    let firstSpec = spec.split(separator: ",").first.map(String.init) ?? ""
+    guard let dash = firstSpec.firstIndex(of: "-") else { return .full }
+    let startStr = firstSpec[firstSpec.startIndex..<dash].trimmingCharacters(in: .whitespaces)
+    let endStr = firstSpec[firstSpec.index(after: dash)...].trimmingCharacters(in: .whitespaces)
+
+    if startStr.isEmpty {
+      // Suffix form `-N`: the last N bytes.
+      guard let suffix = Int64(endStr), suffix > 0 else { return .unsatisfiable }
+      let start = max(0, fileSize - suffix)
+      return .partial(start: start, end: fileSize - 1)
+    }
+    guard let start = Int64(startStr), start >= 0 else { return .full }
+    if start >= fileSize { return .unsatisfiable }
+    if endStr.isEmpty {
+      return .partial(start: start, end: fileSize - 1)
+    }
+    guard let end = Int64(endStr) else { return .full }
+    if end < start { return .full }
+    return .partial(start: start, end: min(end, fileSize - 1))
+  }
+
+  // MARK: - Header builders (pure)
+
+  static func headFull(contentType: String, fileSize: Int64) -> String {
+    "HTTP/1.1 200 OK\r\n"
+      + "Content-Type: \(contentType)\r\n"
+      + "Content-Length: \(fileSize)\r\n"
+      + "Accept-Ranges: bytes\r\n"
+      + "Connection: close\r\n\r\n"
+  }
+
+  static func headPartial(contentType: String, start: Int64, end: Int64, fileSize: Int64) -> String {
+    "HTTP/1.1 206 Partial Content\r\n"
+      + "Content-Type: \(contentType)\r\n"
+      + "Content-Range: bytes \(start)-\(end)/\(fileSize)\r\n"
+      + "Content-Length: \(end - start + 1)\r\n"
+      + "Accept-Ranges: bytes\r\n"
+      + "Connection: close\r\n\r\n"
+  }
+
+  static func headUnsatisfiable(fileSize: Int64) -> String {
+    "HTTP/1.1 416 Range Not Satisfiable\r\n"
+      + "Content-Range: bytes */\(fileSize)\r\n"
+      + "Content-Length: 0\r\n"
+      + "Connection: close\r\n\r\n"
+  }
+
+  static func headError(status: Int, reason: String) -> String {
+    "HTTP/1.1 \(status) \(reason)\r\n"
+      + "Content-Length: 0\r\n"
+      + "Connection: close\r\n\r\n"
+  }
+
+  // MARK: - Helpers
+
+  static func firstRange(of needle: Data, in haystack: Data) -> Range<Int>? {
+    guard needle.count <= haystack.count, !needle.isEmpty else { return nil }
+    let upper = haystack.count - needle.count
+    var i = haystack.startIndex
+    while i <= upper {
+      if haystack[i..<(i + needle.count)].elementsEqual(needle) {
+        return i..<(i + needle.count)
+      }
+      i += 1
+    }
+    return nil
+  }
+
+  private static func isBenignDisconnect(_ error: NWError) -> Bool {
+    if case .posix(let code) = error {
+      return code == .ECONNRESET || code == .ENOTCONN || code == .EPIPE || code == .ECANCELED
+    }
+    return false
+  }
+}

package/ios/Cast/Core/MediaServerHandle.swift

@@ -0,0 +1,49 @@
+import Foundation
+
+/// Per-cast-session handle onto `LocalMediaServer`. Returned from
+/// `LocalMediaServer.acquire`. The backend registers each consumer-
+/// supplied `file://` URL it wants exposed to a receiver, gets back
+/// a full `http://<lan>:<port>/media/<token>` URL, and on session end
+/// calls `close()` to revoke every token registered through this
+/// handle plus decrement the server's refcount.
+final class MediaServerHandle {
+  private weak var server: LocalMediaServer?
+  private let sessionId: String
+  private var closed = false
+  private let lock = NSLock()
+
+  init(server: LocalMediaServer, sessionId: String) {
+    self.server = server
+    self.sessionId = sessionId
+  }
+
+  /// Registers `fileURL` under a fresh token and returns the receiver-
+  /// reachable `http://` URL. Optional `contentType` overrides MIME
+  /// inferred from the file extension.
+  func register(fileURL: URL, lanAddress: String, contentType: String? = nil) -> URL? {
+    guard let server = server, let port = server.serverPortOrNil else { return nil }
+    let token = server.register(sessionId: sessionId, fileURL: fileURL, contentType: contentType)
+    return URL(string: "http://\(lanAddress):\(port)/media/\(token)")
+  }
+
+  func revoke(_ token: String) {
+    server?.revoke(token)
+  }
+
+  func close() {
+    lock.lock()
+    if closed {
+      lock.unlock()
+      return
+    }
+    closed = true
+    lock.unlock()
+    server?.release(sessionId: sessionId)
+  }
+
+  deinit {
+    if !closed {
+      close()
+    }
+  }
+}