@onekeyfe/react-native-range-downloader 6.7.0-1 → 6.7.0-alpha.311

package/android/src/main/java/com/margelo/nitro/reactnativerangedownloader/ConcurrentRangeDownloader.kt

@@ -5,6 +5,11 @@ import okhttp3.Request
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
+import java.net.ConnectException
+import java.net.ProtocolException
+import java.net.SocketException
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
 import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicLong
@@ -74,19 +79,18 @@ class ConcurrentRangeDownloader(
      * any other non-retryable 4xx per OCDS §4's catch-all). Unlike a generic
      * transient [java.io.IOException], this MUST bypass the per-segment retry
      * loop ([downloadSegment]) — retrying a dead URL only wastes the attempt
-     * budget. The `HTTP <code>` message shape is preserved so the JS error
-     * taxonomy ([updateErrorTaxonomy.ts]) maps it to `HTTP_<code>`.
+     * budget. Native updater callers can read [code] without parsing prose.
      */
-    private class PermanentHttpException(val code: Int) :
+    class PermanentHttpException(val code: Int) :
         Exception("HTTP $code")
 
     /**
      * Typed transient carrying an optional `Retry-After` delay (milliseconds)
      * the server asked us to wait before retrying (`429`/`503`). The retry loop
-     * in [downloadSegment] prefers this over its computed backoff. Keeps the
-     * `HTTP <code>` message shape for the JS taxonomy.
+     * in [downloadSegment] prefers this over its computed backoff. Native
+     * updater callers can read [code] without parsing prose.
      */
-    private class TransientHttpException(val code: Int, val retryAfterMillis: Long?) :
+    class TransientHttpException(val code: Int, val retryAfterMillis: Long?) :
         java.io.IOException("HTTP $code")
 
     /**
@@ -144,12 +148,15 @@ class ConcurrentRangeDownloader(
      * Fills [partialFilePath] completely with the resource at [url] using
      * concurrent ranges. See [Outcome]. Throws on a transient/IO error after
      * per-segment retries, leaving the segment files in place so a later attempt
-     * resumes.
+     * resumes. [maxTotalBytes] rejects a known oversized probe before workers
+     * or artifact writes; callers with unknown single-stream sizes enforce their
+     * own streaming limit.
      */
     fun download(
         url: String,
         partialFilePath: String,
         cancelHandle: CancelHandle? = null,
+        maxTotalBytes: Long = Long.MAX_VALUE,
         onProgress: (transferred: Long, total: Long) -> Unit,
     ): Outcome {
         val partialFile = File(partialFilePath)
@@ -164,6 +171,9 @@ class ConcurrentRangeDownloader(
         }
 
         val probe = probe(url) ?: return Outcome.FALLBACK
+        if (probe.totalSize > maxTotalBytes) {
+            throw SecurityException("Range download exceeds caller size limit")
+        }
         if (!probe.supportsRange || probe.totalSize < minConcurrentBytes) {
             log("concurrent: not eligible (supportsRange=${probe.supportsRange}, size=${probe.totalSize})")
             return Outcome.FALLBACK
@@ -308,12 +318,12 @@ class ConcurrentRangeDownloader(
                         val len = response.body?.contentLength() ?: -1L
                         Probe(if (len > 0) len else 0, false)
                     }
-                    else -> null
+                    else -> throw classifyHttpFailure(response)
                 }
             }
         } catch (e: Exception) {
             log("concurrent: probe failed: ${e.javaClass.simpleName}")
-            null
+            throw e
         }
     }
 
@@ -404,10 +414,13 @@ class ConcurrentRangeDownloader(
                 throw e
             } catch (e: PermanentHttpException) {
                 // Dead URL (auth/gone/non-retryable) — retrying only burns the
-                // attempt budget. Surface immediately; the caller maps the
-                // `HTTP <code>` message to a permanent JS taxonomy bucket.
+                // attempt budget. Surface the typed HTTP status immediately.
                 throw e
             } catch (e: Exception) {
+                val retryable = e is TransientHttpException ||
+                    e is SocketTimeoutException || e is UnknownHostException ||
+                    e is ConnectException || e is SocketException || e is ProtocolException
+                if (!retryable) throw e
                 if (aborted.get() || retry >= maxPartRetry) throw e
                 retry += 1
                 // Prefer the server's Retry-After; otherwise exponential backoff
@@ -469,8 +482,8 @@ class ConcurrentRangeDownloader(
             if (response.code != 206) {
                 // OCDS §4 classification. Anything that is not a usable 206 is
                 // either a permanently-dead URL (bypass retries) or a transient
-                // condition (retry with backoff). The `HTTP <code>` message shape
-                // is preserved on both so the JS taxonomy maps it to HTTP_<code>.
+                // condition (retry with backoff). Both exceptions retain a
+                // typed status for native updater callers.
                 throw classifyHttpFailure(response)
             }
             // Reject a multipart/byteranges body: it carries range delimiters and

package/android/src/test/java/com/margelo/nitro/reactnativerangedownloader/ConcurrentRangeDownloaderOcdsTest.kt

@@ -2,6 +2,9 @@ package com.margelo.nitro.reactnativerangedownloader
 
 import okhttp3.OkHttpClient
 import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.RecordedRequest
 import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
@@ -82,6 +85,52 @@ class ConcurrentRangeDownloaderOcdsTest {
     }
   }
 
+  @Test
+  fun oversizedProbedTotalRejectsBeforeRangeWorkers() {
+    val cap = content.size.toLong()
+    server = MockWebServer()
+    server.dispatcher = object : Dispatcher() {
+      override fun dispatch(request: RecordedRequest) = MockResponse()
+        .setResponseCode(206)
+        .addHeader("Content-Range", "bytes 0-0/${cap + 1}")
+        .setBody("x")
+    }
+    server.start()
+
+    val partial = partialPath()
+    val failure = runCatching {
+      newDownloader().download(
+        url = url(),
+        partialFilePath = partial,
+        maxTotalBytes = cap,
+        onProgress = { _, _ -> },
+      )
+    }.exceptionOrNull()
+
+    assertTrue("oversized total must reject", failure is SecurityException)
+    assertEquals("only the probe may reach the server", 1, server.requestCount)
+    assertEquals("bytes=0-0", server.takeRequest().getHeader("Range"))
+    assertNoArtifactsLeft(partial)
+  }
+
+  @Test
+  fun probedTotalAtLimitCanComplete() {
+    val fs = RangeFaultServer(content)
+    startServer(fs)
+
+    val partial = partialPath()
+    val outcome = newDownloader().download(
+      url = url(),
+      partialFilePath = partial,
+      maxTotalBytes = content.size.toLong(),
+      onProgress = { _, _ -> },
+    )
+
+    assertEquals(ConcurrentRangeDownloader.Outcome.COMPLETED, outcome)
+    assertEquals(content.size.toLong(), File(partial).length())
+    assertEquals(sha256(content), sha256(File(partial)))
+  }
+
   // ------------------------------------------------------------------------
   // OCDS-T1: drop one segment's connection mid-body a couple of times.
   //   Only that segment is re-fetched (retries stay in its own window); the

package/ios/ReactNativeRangeDownloader.swift

@@ -29,7 +29,7 @@ class ReactNativeRangeDownloader: HybridReactNativeRangeDownloaderSpec {
 
   func download(params: RangeDownloadParams) throws -> Promise<RangeDownloadResult> {
     return Promise.async {
-      let (klass, filePath, fallbackReason, fallbackClass) = await RangeDownloader.shared.download(
+      let (klass, filePath, fallbackReason, fallbackClass, _) = await RangeDownloader.shared.download(
         channel: params.channel,
         taskId: params.taskId,
         urlString: params.url,
@@ -350,6 +350,10 @@ extension RangeFallbackClass {
 
 public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
 
+  public struct HTTPStatusError: Error {
+    public let statusCode: Int
+  }
+
   public static let shared = RangeDownloader()
 
   /// Posted by the AppDelegate from
@@ -370,6 +374,15 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
   private static let defaultSegmentCount = 8
   private static let defaultMinConcurrentBytes: Int64 = 2 * 1024 * 1024
 
+  private static func isRetryableNetworkError(_ error: Error) -> Bool {
+    let nsError = error as NSError
+    guard nsError.domain == NSURLErrorDomain else { return false }
+    return [NSURLErrorTimedOut, NSURLErrorCannotFindHost,
+            NSURLErrorCannotConnectToHost, NSURLErrorNetworkConnectionLost,
+            NSURLErrorNotConnectedToInternet, NSURLErrorDNSLookupFailed]
+      .contains(nsError.code)
+  }
+
   private let lock = NSLock()
 
   /// Active-run state keyed by "channel|taskId". Replaces the origin's single
@@ -411,6 +424,7 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     /// Set when a segment could not be stashed (move/size-check failure). Carries
     /// the terminal error so didCompleteWithError finalizes instead of hanging.
     var stashError: Error?
+    var httpStatus: Int?
     /// §4/§5.4: per-segment indexes whose finished body was a TRANSIENT HTTP
     /// status (429/5xx/408/416) — the body is discarded and the segment is
     /// re-enqueued (G2) instead of failing the whole run. Optional Retry-After
@@ -604,8 +618,10 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
       Array(self.listeners.values)
     }
     guard !snapshot.isEmpty else { return }
+    let wireMessage = channel.stringValue == DownloadChannel.bundle.stringValue && type == "fallback"
+      ? "" : message
     let event = RangeDownloadEvent(
-      channel: channel, taskId: taskId, type: type, progress: progress, message: message
+      channel: channel, taskId: taskId, type: type, progress: progress, message: wireMessage
     )
     for cb in snapshot { cb(event) }
   }
@@ -665,7 +681,7 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     requestTimeoutSeconds: Double? = nil,
     stallTimeoutSeconds: Double? = nil,
     overallDeadlineSeconds: Double? = nil
-  ) async -> (RangeDownloadClass, String, String?, RangeFallbackClass?) {
+  ) async -> (RangeDownloadClass, String, String?, RangeFallbackClass?, Error?) {
     let segCount = max(1, segmentCount ?? Self.defaultSegmentCount)
     let minBytes = minConcurrentBytes ?? Self.defaultMinConcurrentBytes
     let maxAttempts = max(1, maxSegmentAttempts ?? Self.defaultMaxSegmentAttempts)
@@ -683,11 +699,11 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     let key = Self.runKey(channel: channel, taskId: taskId)
 
     guard let url = URL(string: urlString) else {
-      return (.fallbackPermanent, filePath, "invalid url", .rangeUnsupported)
+      return (.fallbackPermanent, filePath, "invalid url", .rangeUnsupported, URLError(.badURL))
     }
     // HTTPS-only: background URLSession + transport hardening.
     guard urlString.hasPrefix("https://") else {
-      return (.fallbackPermanent, filePath, "url must use https", .redirectRejected)
+      return (.fallbackPermanent, filePath, "url must use https", .redirectRejected, nil)
     }
 
     // §5.8 (G7): at most one live run per destination. A second download() for
@@ -702,20 +718,21 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     // avoid join bookkeeping hangs.
     if let existing = run(forKey: key), existing.filePath == filePath {
       return (.fallbackTransient, filePath,
-              "another run is already active for this destination", .budgetExhausted)
+              "another run is already active for this destination", .budgetExhausted, nil)
     }
 
     let probe: ProbeResult
     do {
       probe = try await self.probe(url: url)
     } catch {
-      // A probe that cannot reach the server is a transient network condition.
-      return (.fallbackTransient, filePath,
-              "probe failed: \(error.localizedDescription)", .transientNetwork)
+      let retryable = Self.isRetryableNetworkError(error)
+      let klass: RangeDownloadClass = retryable ? .fallbackTransient : .fallbackPermanent
+      return (klass, filePath,
+              "probe failed: \(error.localizedDescription)", retryable ? .transientNetwork : nil, error)
     }
     guard probe.supportsRange, probe.total >= minBytes else {
       return (.fallbackPermanent, filePath,
-              "range unsupported or file too small", .rangeUnsupported)
+              "range unsupported or file too small", .rangeUnsupported, nil)
     }
 
     let state = RunState(
@@ -742,7 +759,7 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     if let existing = runs[key], existing.filePath == filePath, existing !== state {
       lock.unlock()
       return (.fallbackTransient, filePath,
-              "another run is already active for this destination", .budgetExhausted)
+              "another run is already active for this destination", .budgetExhausted, nil)
     }
     runs[key] = state
     lock.unlock()
@@ -773,26 +790,30 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
       } else {
         try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
           self.lock.lock()
+          guard self.runs[key] === state else {
+            self.lock.unlock()
+            cont.resume(throwing: CancellationError())
+            return
+          }
           state.continuation = cont
           self.lock.unlock()
           reconcileAndStartTasks(state: state, url: url, ranges: ranges)
         }
       }
     } catch let fb as FallbackError {
-      clearRun(key: key)
+      clearRun(key: key, state: state)
       emit(channel: channel, taskId: taskId, type: "fallback", progress: 0, message: fb.reason)
-      return (fb.kind.failureClass, filePath, fb.reason, fb.kind)
+      return (fb.kind.failureClass, filePath, fb.reason, fb.kind, fb.underlyingError)
     } catch {
-      // A non-FallbackError thrown out of the run is a local/transient condition
-      // (disk I/O, an interrupted segment) → ask the caller to retry the
-      // concurrent path; segments are retained for resume.
-      clearRun(key: key)
+      clearRun(key: key, state: state)
       let reason = error.localizedDescription
       emit(channel: channel, taskId: taskId, type: "fallback", progress: 0, message: reason)
-      return (.fallbackTransient, filePath, reason, .transientNetwork)
+      let retryable = Self.isRetryableNetworkError(error)
+      let klass: RangeDownloadClass = retryable ? .fallbackTransient : .fallbackPermanent
+      return (klass, filePath, reason, retryable ? .transientNetwork : nil, error)
     }
 
-    clearRun(key: key)
+    clearRun(key: key, state: state)
 
     // Optional immediate SHA256 self-check backstop. When omitted, the caller
     // verifies after the fact. A whole-file checksum mismatch is Permanent (§4):
@@ -805,16 +826,20 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
         let reason = "sha256 mismatch (expected \(expected), got \(actual ?? "nil"))"
         OneKeyLog.error("RangeDownloader", "\(channel.stringValue)/\(taskId): \(reason)")
         emit(channel: channel, taskId: taskId, type: "fallback", progress: 0, message: reason)
-        return (.fallbackPermanent, filePath, reason, .checksumMismatch)
+        return (.fallbackPermanent, filePath, reason, .checksumMismatch, nil)
       }
     }
 
     emit(channel: channel, taskId: taskId, type: "complete", progress: 100, message: "")
-    return (.completed, filePath, nil, nil)
+    return (.completed, filePath, nil, nil, nil)
   }
 
-  private func clearRun(key: String) {
-    lock.lock(); runs.removeValue(forKey: key); lock.unlock()
+  private func clearRun(key: String, state: RunState) {
+    lock.lock()
+    if runs[key] === state {
+      runs.removeValue(forKey: key)
+    }
+    lock.unlock()
   }
 
   // MARK: - Range planning / probing
@@ -823,13 +848,16 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
 
   struct FallbackError: Error {
     let reason: String
+    let underlyingError: Error?
     /// §4 typed sub-class. Defaults to a Permanent `serverIgnoredRange` only so an
     /// un-annotated legacy throw keeps the previous "discard + single-stream"
     /// behavior; all new throw sites pass an explicit kind.
     let kind: RangeFallbackClass
-    init(reason: String, kind: RangeFallbackClass = .serverIgnoredRange) {
+    init(reason: String, kind: RangeFallbackClass = .serverIgnoredRange,
+         underlyingError: Error? = nil) {
       self.reason = reason
       self.kind = kind
+      self.underlyingError = underlyingError
     }
   }
 
@@ -859,9 +887,11 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
            let cr = http.value(forHTTPHeaderField: "Content-Range"),
            let total = RangeDownloadLogic.parseContentRangeTotal(cr) {
           cont.resume(returning: ProbeResult(total: total, etag: etag, supportsRange: true))
-        } else {
-          // 200 (Range ignored) or anything else → single-stream.
+        } else if http.statusCode == 200 || http.statusCode == 206 {
+          // Range ignored, or an unusable 206 → single-stream.
           cont.resume(returning: ProbeResult(total: 0, etag: etag, supportsRange: false))
+        } else {
+          cont.resume(throwing: HTTPStatusError(statusCode: http.statusCode))
         }
       }
       task.resume()
@@ -879,6 +909,7 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     let session = session(forChannel: state.channel, segmentCount: state.segmentCount)
     session.getAllTasks { [weak self] tasks in
       guard let self = self else { return }
+      guard self.run(forKey: Self.runKey(channel: state.channel, taskId: state.taskId)) === state else { return }
       var liveIndexes = Set<Int>()
       for t in tasks {
         guard let desc = t.taskDescription,
@@ -938,11 +969,17 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     // §5.4 (G2): the real task now exists and is visible to `getAllTasks`, so
     // clear the pending-retry marker — the in-flight check is authoritative again.
     lock.lock()
+    guard runs[Self.runKey(channel: state.channel, taskId: state.taskId)] === state,
+          state.continuation != nil else {
+      lock.unlock()
+      task.cancel()
+      return
+    }
     if idx < state.segmentWritten.count { state.segmentWritten[idx] = 0 }
     state.pendingRetryIndexes.remove(idx)
     state.lastProgressAt = Date()
-    lock.unlock()
     task.resume()
+    lock.unlock()
   }
 
   /// Marks a segment's finished body as a TRANSIENT HTTP outcome (§4) so
@@ -1230,6 +1267,7 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     }
     if http.statusCode != 206 {
       let kind = RangeDownloadLogic.classifyStatus(http.statusCode)
+      lock.withLockValue { state.httpStatus = http.statusCode }
       if kind.failureClass == .fallbackTransient {
         // §4 (416): a 416 is transient but the requested range may no longer be
         // satisfiable (the object shrank/changed). Flag this segment for a size
@@ -1329,14 +1367,23 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
         if wasStall {
           if retrySegmentIfUnderBudget(state: state, idx: idx, retryAfter: nil) { return }
           finalizeTransientFallback(state: state, idx: idx, reason: "segment \(idx) stalled; retry budget exhausted", ranges: ranges)
+        } else {
+          // Explicit cancel removes the run before delegate delivery. A live
+          // run receiving -999 is an interrupted background transfer.
+          finishContinuation(state: state, with: error, ranges: ranges)
         }
         return
       }
-      // §4: connection lost / timeout / DNS / TLS → Transient. Retry THIS segment
-      // in place under its budget; keep the others and their `.segN`.
+      // Only known transport failures are retryable. TLS/security and local I/O
+      // failures must retain their original type for the update caller.
+      if !Self.isRetryableNetworkError(error) {
+        finishContinuation(state: state, with: error, ranges: ranges)
+        return
+      }
       if retrySegmentIfUnderBudget(state: state, idx: idx, retryAfter: nil) { return }
       finalizeTransientFallback(state: state, idx: idx,
-                                reason: error.localizedDescription, ranges: ranges)
+                                reason: error.localizedDescription, ranges: ranges,
+                                underlyingError: error)
       return
     }
 
@@ -1368,11 +1415,9 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     // A segment failed to stash (move/size-check failure in didFinishDownloadingTo).
     // A short/truncated body is transient (the bytes will be re-fetched), so retry
     // this segment under budget rather than failing the whole run.
-    if lock.withLockValue({ state.stashError }) != nil {
-      lock.lock(); state.stashError = nil; lock.unlock()
-      if retrySegmentIfUnderBudget(state: state, idx: idx, retryAfter: nil) { return }
-      finalizeTransientFallback(state: state, idx: idx,
-                                reason: "segment \(idx) could not be stashed; retry budget exhausted", ranges: ranges)
+    if let stashError = lock.withLockValue({ state.stashError }) {
+      lock.withLockValue { state.stashError = nil }
+      finishContinuation(state: state, with: stashError, ranges: ranges)
       return
     }
 
@@ -1461,16 +1506,24 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
     case .checksumMismatch: reason = "whole-file checksum mismatch"
     case .transientNetwork, .throttled, .budgetExhausted: reason = "permanent fallback"
     }
-    finishContinuation(state: state, with: FallbackError(reason: reason, kind: kind), ranges: ranges)
+    let status = lock.withLockValue { state.httpStatus }
+    let statusError = status.flatMap { $0 >= 400 ? HTTPStatusError(statusCode: $0) : nil }
+    finishContinuation(state: state,
+                       with: FallbackError(reason: reason, kind: kind,
+                                           underlyingError: statusError), ranges: ranges)
   }
 
   /// §4 Transient: finalize the run as a RESUMABLE fallback. `.segN` files are
   /// intentionally KEPT so the next concurrent attempt resumes only the missing
   /// segment(s); never restart from byte 0 while resumable bytes exist.
   private func finalizeTransientFallback(state: RunState, idx: Int, reason: String,
-                                         ranges: [(start: Int64, end: Int64)]) {
+                                         ranges: [(start: Int64, end: Int64)],
+                                         underlyingError: Error? = nil) {
+    let status = lock.withLockValue { state.httpStatus }
+    let statusError = status.flatMap { $0 >= 400 ? HTTPStatusError(statusCode: $0) : nil }
     finishContinuation(state: state,
-                       with: FallbackError(reason: reason, kind: .budgetExhausted),
+                       with: FallbackError(reason: reason, kind: .budgetExhausted,
+                                           underlyingError: statusError ?? underlyingError),
                        ranges: ranges)
   }
 
@@ -1580,6 +1633,14 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
   public func cancel(channel: DownloadChannel, taskId: String,
                      filePath: String) async {
     let session = session(forChannel: channel, segmentCount: Self.defaultSegmentCount)
+    let key = Self.runKey(channel: channel, taskId: taskId)
+    let continuation: CheckedContinuation<Void, Error>? = lock.withLockValue {
+      let state = runs.removeValue(forKey: key)
+      let pending = state?.continuation
+      state?.continuation = nil
+      return pending
+    }
+    continuation?.resume(throwing: CancellationError())
     // Cancel matching tasks first and wait for getAllTasks to return so the
     // cancels have been issued before we touch the files.
     await withCheckedContinuation { (cont: CheckedContinuation<Void, Never>) in
@@ -1595,8 +1656,6 @@ public final class RangeDownloader: NSObject, URLSessionDownloadDelegate {
         cont.resume()
       }
     }
-    // Drop the run state so a late delegate callback can't re-stash a segment.
-    clearRun(key: Self.runKey(channel: channel, taskId: taskId))
     discardArtifacts(filePath: filePath)
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-range-downloader",
-  "version": "6.7.0-1",
+  "version": "6.7.0-alpha.311",
   "description": "react-native-range-downloader",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",