react-native-nitro-fetch 1.3.2 → 1.4.0

package/src/fetch.js

@@ -1,8 +1,5 @@
 import 'web-streams-polyfill/polyfill';
-import {
-  NitroFetch as NitroFetchSingleton,
-  NitroCronetSingleton,
-} from './NitroInstances';
+import { NitroFetch as NitroFetchSingleton, NitroCronetSingleton, } from './NitroInstances';
 import { NativeStorage as NativeStorageSingleton } from './NitroInstances';
 import { NitroHeaders } from './Headers';
 import { NitroResponse } from './Response';
@@ -10,777 +7,916 @@ import { NitroRequest as NitroRequestClass } from './Request';
 import { NetworkInspector } from './NetworkInspector';
 // No base64: pass strings/ArrayBuffers directly
 function headersToPairs(headers) {
-  'worklet';
-  if (!headers) return undefined;
-  const pairs = [];
-  if (headers instanceof Headers) {
-    headers.forEach((v, k) => pairs.push({ key: k, value: v }));
-    return pairs;
-  }
-  if (Array.isArray(headers)) {
-    // Convert tuple pairs to objects if needed
-    for (const entry of headers) {
-      if (Array.isArray(entry) && entry.length >= 2) {
-        pairs.push({ key: String(entry[0]), value: String(entry[1]) });
-      } else if (
-        entry &&
-        typeof entry === 'object' &&
-        'key' in entry &&
-        'value' in entry
-      ) {
-        pairs.push(entry);
-      }
+    'worklet';
+    if (!headers)
+        return undefined;
+    const pairs = [];
+    if (headers instanceof Headers) {
+        headers.forEach((v, k) => pairs.push({ key: k, value: v }));
+        return pairs;
     }
-    return pairs;
-  }
-  // Check if it's a plain object (Record<string, string>) first
-  // Plain objects don't have forEach, so check for its absence
-  if (typeof headers === 'object' && headers !== null) {
-    // Check if it's a Headers instance by checking for forEach method
-    const hasForEach = typeof headers.forEach === 'function';
-    if (hasForEach) {
-      // Headers-like object (duck typing)
-      headers.forEach((v, k) => pairs.push({ key: k, value: v }));
-      return pairs;
-    } else {
-      // Plain object (Record<string, string>)
-      // Use Object.keys to iterate since Object.entries might not work in worklets
-      const keys = Object.keys(headers);
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i];
-        const v = headers[k];
-        if (v !== undefined) {
-          pairs.push({ key: k, value: String(v) });
+    if (Array.isArray(headers)) {
+        // Convert tuple pairs to objects if needed
+        for (const entry of headers) {
+            if (Array.isArray(entry) && entry.length >= 2) {
+                pairs.push({ key: String(entry[0]), value: String(entry[1]) });
+            }
+            else if (entry &&
+                typeof entry === 'object' &&
+                'key' in entry &&
+                'value' in entry) {
+                pairs.push(entry);
+            }
         }
-      }
-      return pairs;
+        return pairs;
     }
-  }
-  return pairs;
+    // Check if it's a plain object (Record<string, string>) first
+    // Plain objects don't have forEach, so check for its absence
+    if (typeof headers === 'object' && headers !== null) {
+        // Check if it's a Headers instance by checking for forEach method
+        const hasForEach = typeof headers.forEach === 'function';
+        if (hasForEach) {
+            // Headers-like object (duck typing)
+            headers.forEach((v, k) => pairs.push({ key: k, value: v }));
+            return pairs;
+        }
+        else {
+            // Plain object (Record<string, string>)
+            // Use Object.keys to iterate since Object.entries might not work in worklets
+            const keys = Object.keys(headers);
+            for (let i = 0; i < keys.length; i++) {
+                const k = keys[i];
+                const v = headers[k];
+                if (v !== undefined) {
+                    pairs.push({ key: k, value: String(v) });
+                }
+            }
+            return pairs;
+        }
+    }
+    return pairs;
 }
 function serializeFormData(fd) {
-  const parts = [];
-  if (typeof fd.getParts === 'function') {
-    const rnParts = fd.getParts();
-    for (const part of rnParts) {
-      if (part.string !== undefined) {
-        parts.push({ name: part.fieldName, value: String(part.string) });
-      } else if (part.uri) {
-        parts.push({
-          name: part.fieldName,
-          fileUri: part.uri,
-          fileName: part.fileName ?? part.name ?? 'file',
-          mimeType: part.type ?? 'application/octet-stream',
-        });
-      }
+    const parts = [];
+    if (typeof fd.getParts === 'function') {
+        const rnParts = fd.getParts();
+        for (const part of rnParts) {
+            if (part.string !== undefined) {
+                parts.push({ name: part.fieldName, value: String(part.string) });
+            }
+            else if (part.uri) {
+                parts.push({
+                    name: part.fieldName,
+                    fileUri: part.uri,
+                    fileName: part.fileName ?? part.name ?? 'file',
+                    mimeType: part.type ?? 'application/octet-stream',
+                });
+            }
+        }
+        return parts;
     }
+    fd.forEach((value, key) => {
+        if (typeof value === 'string') {
+            parts.push({ name: key, value });
+        }
+        else if (value && typeof value === 'object') {
+            parts.push({
+                name: key,
+                fileUri: value.uri ?? value.fileUri,
+                fileName: value.name ?? value.fileName ?? 'file',
+                mimeType: value.type ?? value.mimeType ?? 'application/octet-stream',
+            });
+        }
+    });
     return parts;
-  }
-  fd.forEach((value, key) => {
-    if (typeof value === 'string') {
-      parts.push({ name: key, value });
-    } else if (value && typeof value === 'object') {
-      parts.push({
-        name: key,
-        fileUri: value.uri ?? value.fileUri,
-        fileName: value.name ?? value.fileName ?? 'file',
-        mimeType: value.type ?? value.mimeType ?? 'application/octet-stream',
-      });
-    }
-  });
-  return parts;
 }
 function isFormData(body) {
-  if (typeof FormData !== 'undefined' && body instanceof FormData) return true;
-  if (
-    body &&
-    typeof body === 'object' &&
-    typeof body.append === 'function' &&
-    typeof body.getParts === 'function'
-  ) {
-    return true;
-  }
-  return false;
+    if (typeof FormData !== 'undefined' && body instanceof FormData)
+        return true;
+    if (body &&
+        typeof body === 'object' &&
+        typeof body.append === 'function' &&
+        typeof body.getParts === 'function') {
+        return true;
+    }
+    return false;
 }
 function normalizeBody(body) {
-  'worklet';
-  if (body == null) return undefined;
-  if (typeof body === 'string') return { bodyString: body };
-  if (isFormData(body)) {
-    return { bodyFormData: serializeFormData(body) };
-  }
-  if (body instanceof URLSearchParams) return { bodyString: body.toString() };
-  if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer)
-    return { bodyBytes: body };
-  if (ArrayBuffer.isView(body)) {
-    const view = body;
-    return {
-      //@ts-ignore
-      bodyBytes: view.buffer.slice(
-        view.byteOffset,
-        view.byteOffset + view.byteLength
-      ),
-    };
-  }
-  throw new Error('Unsupported body type for nitro fetch');
+    'worklet';
+    if (body == null)
+        return undefined;
+    if (typeof body === 'string')
+        return { bodyString: body };
+    if (isFormData(body)) {
+        return { bodyFormData: serializeFormData(body) };
+    }
+    if (body instanceof URLSearchParams)
+        return { bodyString: body.toString() };
+    if (typeof ArrayBuffer !== 'undefined' && body instanceof ArrayBuffer)
+        return { bodyBytes: body };
+    if (ArrayBuffer.isView(body)) {
+        const view = body;
+        return {
+            //@ts-ignore
+            bodyBytes: view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength),
+        };
+    }
+    throw new Error('Unsupported body type for nitro fetch');
 }
 const NitroFetchHybrid = NitroFetchSingleton;
 let client;
 function ensureClient() {
-  if (client) return client;
-  try {
-    client = NitroFetchHybrid.createClient();
-  } catch (err) {
-    console.error('Failed to create NitroFetch client', err);
-    // native not ready; keep undefined
-  }
-  return client;
+    if (client)
+        return client;
+    try {
+        client = NitroFetchHybrid.createClient();
+    }
+    catch (err) {
+        console.error('Failed to create NitroFetch client', err);
+        // native not ready; keep undefined
+    }
+    return client;
 }
 function buildNitroRequest(input, init) {
-  'worklet';
-  let url;
-  let method;
-  let headersInit;
-  let body;
-  let redirectOption = init?.redirect ?? 'follow';
-  let cacheOption = init?.cache;
-  if (input instanceof NitroRequestClass) {
-    url = input.url;
-    method = init?.method ?? input.method;
-    headersInit = init?.headers ?? input.headers;
-    body = init?.body ?? input.body ?? null;
-    if (!init?.redirect) redirectOption = input.redirect;
-    if (!init?.cache) cacheOption = input.cache;
-  } else if (typeof input === 'string' || input instanceof URL) {
-    url = String(input);
-    method = init?.method;
-    headersInit = init?.headers;
-    body = init?.body ?? null;
-  } else {
-    // Standard Request object
-    url = input.url;
-    method = input.method;
-    headersInit = input.headers;
-    body = init?.body ?? null;
-  }
-  const headers = headersToPairs(headersInit) ?? [];
-  const normalized = normalizeBody(body);
-  // Inject cache-control headers based on cache option
-  if (cacheOption === 'no-store') {
-    headers.push({ key: 'Cache-Control', value: 'no-store' });
-  } else if (cacheOption === 'no-cache') {
-    headers.push({ key: 'Cache-Control', value: 'no-cache' });
-  } else if (cacheOption === 'reload') {
-    headers.push({ key: 'Cache-Control', value: 'no-cache' });
-    headers.push({ key: 'Pragma', value: 'no-cache' });
-  }
-  // Determine followRedirects based on redirect option
-  const followRedirects = redirectOption === 'follow';
-  const prefetchCacheTtlMs =
-    typeof init?.prefetchCacheTtlMs === 'number'
-      ? init.prefetchCacheTtlMs
-      : undefined;
-  return {
-    url,
-    method: method?.toUpperCase() ?? 'GET',
-    headers: headers.length > 0 ? headers : undefined,
-    bodyString: normalized?.bodyString,
-    bodyBytes: undefined,
-    bodyFormData: normalized?.bodyFormData,
-    followRedirects,
-    prefetchCacheTtlMs,
-  };
+    'worklet';
+    let url;
+    let method;
+    let headersInit;
+    let body;
+    let redirectOption = init?.redirect ?? 'follow';
+    let cacheOption = init?.cache;
+    if (input instanceof NitroRequestClass) {
+        url = input.url;
+        method = init?.method ?? input.method;
+        headersInit = init?.headers ?? input.headers;
+        body = init?.body ?? input.body ?? null;
+        if (!init?.redirect)
+            redirectOption = input.redirect;
+        if (!init?.cache)
+            cacheOption = input.cache;
+    }
+    else if (typeof input === 'string' || input instanceof URL) {
+        url = String(input);
+        method = init?.method;
+        headersInit = init?.headers;
+        body = init?.body ?? null;
+    }
+    else {
+        // Standard Request object
+        url = input.url;
+        method = input.method;
+        headersInit = input.headers;
+        body = init?.body ?? null;
+    }
+    const headers = headersToPairs(headersInit) ?? [];
+    const normalized = normalizeBody(body);
+    // Inject cache-control headers based on cache option
+    if (cacheOption === 'no-store') {
+        headers.push({ key: 'Cache-Control', value: 'no-store' });
+    }
+    else if (cacheOption === 'no-cache') {
+        headers.push({ key: 'Cache-Control', value: 'no-cache' });
+    }
+    else if (cacheOption === 'reload') {
+        headers.push({ key: 'Cache-Control', value: 'no-cache' });
+        headers.push({ key: 'Pragma', value: 'no-cache' });
+    }
+    // Determine followRedirects based on redirect option
+    const followRedirects = redirectOption === 'follow';
+    const prefetchCacheTtlMs = typeof init?.prefetchCacheTtlMs === 'number'
+        ? init.prefetchCacheTtlMs
+        : undefined;
+    return {
+        url,
+        method: method?.toUpperCase() ?? 'GET',
+        headers: headers.length > 0 ? headers : undefined,
+        bodyString: normalized?.bodyString,
+        bodyBytes: undefined,
+        bodyFormData: normalized?.bodyFormData,
+        followRedirects,
+        prefetchCacheTtlMs,
+    };
 }
 // Pure JS version of buildNitroRequest that doesnt use anything that breaks worklets. TODO: Merge this to use Same logic for Worklets and normal Fetch
 function headersToPairsPure(headers) {
-  'worklet';
-  if (!headers) return undefined;
-  const pairs = [];
-  if (Array.isArray(headers)) {
-    // Convert tuple pairs to objects if needed
-    for (const entry of headers) {
-      if (Array.isArray(entry) && entry.length >= 2) {
-        pairs.push({ key: String(entry[0]), value: String(entry[1]) });
-      } else if (
-        entry &&
-        typeof entry === 'object' &&
-        'key' in entry &&
-        'value' in entry
-      ) {
-        pairs.push(entry);
-      }
+    'worklet';
+    if (!headers)
+        return undefined;
+    const pairs = [];
+    if (Array.isArray(headers)) {
+        // Convert tuple pairs to objects if needed
+        for (const entry of headers) {
+            if (Array.isArray(entry) && entry.length >= 2) {
+                pairs.push({ key: String(entry[0]), value: String(entry[1]) });
+            }
+            else if (entry &&
+                typeof entry === 'object' &&
+                'key' in entry &&
+                'value' in entry) {
+                pairs.push(entry);
+            }
+        }
+        return pairs;
     }
-    return pairs;
-  }
-  // Check if it's a plain object (Record<string, string>) first
-  // Plain objects don't have forEach, so check for its absence
-  if (typeof headers === 'object' && headers !== null) {
-    // Check if it's a Headers instance by checking for forEach method
-    const hasForEach = typeof headers.forEach === 'function';
-    if (hasForEach) {
-      // Headers-like object (duck typing)
-      headers.forEach((v, k) => pairs.push({ key: k, value: v }));
-      return pairs;
-    } else {
-      // Plain object (Record<string, string>)
-      // Use Object.keys to iterate since Object.entries might not work in worklets
-      const keys = Object.keys(headers);
-      for (let i = 0; i < keys.length; i++) {
-        const k = keys[i];
-        const v = headers[k];
-        if (v !== undefined) {
-          pairs.push({ key: k, value: String(v) });
+    // Check if it's a plain object (Record<string, string>) first
+    // Plain objects don't have forEach, so check for its absence
+    if (typeof headers === 'object' && headers !== null) {
+        // Check if it's a Headers instance by checking for forEach method
+        const hasForEach = typeof headers.forEach === 'function';
+        if (hasForEach) {
+            // Headers-like object (duck typing)
+            headers.forEach((v, k) => pairs.push({ key: k, value: v }));
+            return pairs;
+        }
+        else {
+            // Plain object (Record<string, string>)
+            // Use Object.keys to iterate since Object.entries might not work in worklets
+            const keys = Object.keys(headers);
+            for (let i = 0; i < keys.length; i++) {
+                const k = keys[i];
+                const v = headers[k];
+                if (v !== undefined) {
+                    pairs.push({ key: k, value: String(v) });
+                }
+            }
+            return pairs;
         }
-      }
-      return pairs;
     }
-  }
-  return pairs;
+    return pairs;
 }
 // Pure JS version of buildNitroRequest that doesnt use anything that breaks worklets
 function normalizeBodyPure(body) {
-  'worklet';
-  if (body == null) return undefined;
-  if (typeof body === 'string') return { bodyString: body };
-  // Check for URLSearchParams (duck typing)
-  // It should be an object, have a toString method, and typically append/delete methods
-  // But mainly we care about toString() returning the query string
-  if (
-    typeof body === 'object' &&
-    body !== null &&
-    typeof body.toString === 'function' &&
-    Object.prototype.toString.call(body) === '[object URLSearchParams]'
-  ) {
-    return { bodyString: body.toString() };
-  }
-  // Check for ArrayBuffer (using toString tag to avoid instanceof)
-  if (
-    typeof ArrayBuffer !== 'undefined' &&
-    Object.prototype.toString.call(body) === '[object ArrayBuffer]'
-  ) {
-    return { bodyBytes: body };
-  }
-  if (ArrayBuffer.isView(body)) {
-    const view = body;
-    return {
-      //@ts-ignore
-      bodyBytes: view.buffer.slice(
-        view.byteOffset,
-        view.byteOffset + view.byteLength
-      ),
-    };
-  }
-  throw new Error(
-    'Unsupported body type for nitro fetch worklet (FormData is not available in worklets)'
-  );
+    'worklet';
+    if (body == null)
+        return undefined;
+    if (typeof body === 'string')
+        return { bodyString: body };
+    // Check for URLSearchParams (duck typing)
+    // It should be an object, have a toString method, and typically append/delete methods
+    // But mainly we care about toString() returning the query string
+    if (typeof body === 'object' &&
+        body !== null &&
+        typeof body.toString === 'function' &&
+        Object.prototype.toString.call(body) === '[object URLSearchParams]') {
+        return { bodyString: body.toString() };
+    }
+    // Check for ArrayBuffer (using toString tag to avoid instanceof)
+    if (typeof ArrayBuffer !== 'undefined' &&
+        Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
+        return { bodyBytes: body };
+    }
+    if (ArrayBuffer.isView(body)) {
+        const view = body;
+        return {
+            //@ts-ignore
+            bodyBytes: view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength),
+        };
+    }
+    throw new Error('Unsupported body type for nitro fetch worklet (FormData is not available in worklets)');
 }
 // Pure JS version of buildNitroRequest that doesnt use anything that breaks worklets
 export function buildNitroRequestPure(input, init) {
-  'worklet';
-  let url;
-  let method;
-  let headersInit;
-  let body;
-  // Check if input is URL-like without instanceof
-  const isUrlObject =
-    typeof input === 'object' &&
-    input !== null &&
-    Object.prototype.toString.call(input) === '[object URL]';
-  if (typeof input === 'string' || isUrlObject) {
-    url = String(input);
-    method = init?.method;
-    headersInit = init?.headers;
-    body = init?.body ?? null;
-  } else {
-    // Request object
-    const req = input;
-    url = req.url;
-    method = req.method;
-    headersInit = req.headers;
-    // Clone body if needed – Request objects in RN typically allow direct access
-    body = init?.body ?? null;
-  }
-  const headers = headersToPairsPure(headersInit);
-  const normalized = normalizeBodyPure(body);
-  const prefetchCacheTtlMs =
-    typeof init?.prefetchCacheTtlMs === 'number'
-      ? init.prefetchCacheTtlMs
-      : undefined;
-  return {
-    url,
-    method: method?.toUpperCase() ?? 'GET',
-    headers,
-    bodyString: normalized?.bodyString,
-    // Only include bodyBytes when provided to avoid signaling upload data unintentionally
-    bodyBytes: undefined,
-    followRedirects: true,
-    prefetchCacheTtlMs,
-  };
+    'worklet';
+    let url;
+    let method;
+    let headersInit;
+    let body;
+    // Check if input is URL-like without instanceof
+    const isUrlObject = typeof input === 'object' &&
+        input !== null &&
+        Object.prototype.toString.call(input) === '[object URL]';
+    if (typeof input === 'string' || isUrlObject) {
+        url = String(input);
+        method = init?.method;
+        headersInit = init?.headers;
+        body = init?.body ?? null;
+    }
+    else {
+        // Request object
+        const req = input;
+        url = req.url;
+        method = req.method;
+        headersInit = req.headers;
+        // Clone body if needed – Request objects in RN typically allow direct access
+        body = init?.body ?? null;
+    }
+    const headers = headersToPairsPure(headersInit);
+    const normalized = normalizeBodyPure(body);
+    const prefetchCacheTtlMs = typeof init?.prefetchCacheTtlMs === 'number'
+        ? init.prefetchCacheTtlMs
+        : undefined;
+    return {
+        url,
+        method: method?.toUpperCase() ?? 'GET',
+        headers,
+        bodyString: normalized?.bodyString,
+        // Only include bodyBytes when provided to avoid signaling upload data unintentionally
+        bodyBytes: undefined,
+        followRedirects: true,
+        prefetchCacheTtlMs,
+    };
 }
 function createAbortError() {
-  const err = new Error('The operation was aborted.');
-  err.name = 'AbortError';
-  return err;
+    const err = new Error('The operation was aborted.');
+    err.name = 'AbortError';
+    return err;
 }
 async function resolveRequestBody(input, init) {
-  if (typeof input === 'string' || input instanceof URL) return init;
-  if (input instanceof NitroRequestClass) return init;
-  if (init?.body != null) return init;
-  const req = input;
-  if (typeof req.clone !== 'function') return init;
-  const method = (init?.method ?? req.method ?? 'GET').toUpperCase();
-  if (method === 'GET' || method === 'HEAD') return init;
-  try {
-    const text = await req.clone().text();
-    if (text.length === 0) return init;
-    return { ...(init ?? {}), body: text };
-  } catch {
-    return init;
-  }
+    if (typeof input === 'string' || input instanceof URL)
+        return init;
+    if (input instanceof NitroRequestClass)
+        return init;
+    if (init?.body != null)
+        return init;
+    const req = input;
+    if (typeof req.clone !== 'function')
+        return init;
+    const method = (init?.method ?? req.method ?? 'GET').toUpperCase();
+    if (method === 'GET' || method === 'HEAD')
+        return init;
+    try {
+        const text = await req.clone().text();
+        if (text.length === 0)
+            return init;
+        return { ...(init ?? {}), body: text };
+    }
+    catch {
+        return init;
+    }
 }
 async function resolveBlobBody(init) {
-  if (!init?.body) return init;
-  if (typeof Blob !== 'undefined' && init.body instanceof Blob) {
-    const blob = init.body;
-    const text = await new Promise((resolve, reject) => {
-      const reader = new FileReader();
-      reader.onload = () => resolve(reader.result);
-      reader.onerror = () => reject(reader.error);
-      reader.readAsText(blob);
-    });
-    // Auto-set Content-Type from Blob.type if not already provided
-    let headers = init.headers;
-    if (blob.type) {
-      const pairs = headersToPairs(headers) ?? [];
-      const hasContentType = pairs.some(
-        (h) => h.key.toLowerCase() === 'content-type'
-      );
-      if (!hasContentType) {
-        pairs.push({ key: 'Content-Type', value: blob.type });
-        headers = pairs.map((h) => [h.key, h.value]);
-      }
-    }
-    return { ...init, body: text, headers };
-  }
-  return init;
+    if (!init?.body)
+        return init;
+    if (typeof Blob !== 'undefined' && init.body instanceof Blob) {
+        const blob = init.body;
+        const text = await new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => resolve(reader.result);
+            reader.onerror = () => reject(reader.error);
+            reader.readAsText(blob);
+        });
+        // Auto-set Content-Type from Blob.type if not already provided
+        let headers = init.headers;
+        if (blob.type) {
+            const pairs = headersToPairs(headers) ?? [];
+            const hasContentType = pairs.some((h) => h.key.toLowerCase() === 'content-type');
+            if (!hasContentType) {
+                pairs.push({ key: 'Content-Type', value: blob.type });
+                headers = pairs.map((h) => [h.key, h.value]);
+            }
+        }
+        return { ...init, body: text, headers };
+    }
+    return init;
 }
-async function nitroFetchRaw(input, init) {
-  const signal = init?.signal;
-  // Fast-abort: reject synchronously before any bridge work.
-  if (signal?.aborted) {
-    throw createAbortError();
-  }
-  // Extract body from standard Request when init.body is absent (ky/undici pattern)
-  init = await resolveRequestBody(input, init);
-  // Resolve Blob body to string before passing to sync buildNitroRequest
-  init = await resolveBlobBody(init);
-  const hasNative = typeof NitroFetchHybrid?.createClient === 'function';
-  if (!hasNative) {
-    // Fallback path not supported for raw; use global fetch and synthesize minimal shape
-    // @ts-ignore: global fetch exists in RN
-    const res = await fetch(input, init);
-    const url = res.url ?? String(input);
-    const bytes = await res.arrayBuffer();
-    const headers = [];
-    res.headers.forEach((v, k) => headers.push({ key: k, value: v }));
+// http(s) -> native client; anything else is a local resource (hot path).
+function isHttpUrl(url) {
+    if (url.startsWith('http://') || url.startsWith('https://'))
+        return true;
+    const c = url.charCodeAt(0);
+    if (c !== 104 && c !== 72)
+        return false; // not 'h'/'H'
+    return /^https?:/i.test(url);
+}
+function getUrlString(input) {
+    if (typeof input === 'string')
+        return input;
+    if (input instanceof URL)
+        return input.toString();
+    const u = input?.url;
+    return typeof u === 'string' ? u : String(input);
+}
+function base64ToBytes(b64) {
+    const decode = globalThis.atob;
+    if (typeof decode === 'function') {
+        const bin = decode(b64);
+        const out = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++)
+            out[i] = bin.charCodeAt(i);
+        return out;
+    }
+    // base64 fallback for runtimes without a global atob.
+    /* eslint-disable no-bitwise */
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const clean = b64.replace(/[^A-Za-z0-9+/]/g, '');
+    const out = new Uint8Array(Math.floor((clean.length * 3) / 4));
+    let p = 0;
+    let buf = 0;
+    let bits = 0;
+    for (let i = 0; i < clean.length; i++) {
+        buf = (buf << 6) | chars.indexOf(clean[i]);
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out[p++] = (buf >> bits) & 0xff;
+        }
+    }
+    return out;
+    /* eslint-enable no-bitwise */
+}
+// Cached: our nitro-text-decoder if the app bundles it (aliased require keeps it optional, not a dep), else a global TextDecoder.
+let _decoder;
+function resolveTextDecoder() {
+    if (_decoder !== undefined)
+        return _decoder;
+    try {
+        const dynamicRequire = require;
+        const mod = dynamicRequire('react-native-nitro-text-decoder');
+        if (mod && typeof mod.TextDecoder === 'function') {
+            _decoder = new mod.TextDecoder('utf-8', { fatal: true });
+            return _decoder;
+        }
+    }
+    catch {
+        // optional, not bundled
+    }
+    const GlobalTextDecoder = globalThis
+        .TextDecoder;
+    if (typeof GlobalTextDecoder === 'function') {
+        _decoder = new GlobalTextDecoder('utf-8', { fatal: true });
+        return _decoder;
+    }
+    _decoder = null;
+    return _decoder;
+}
+// data: text via a TextDecoder; null (bytes-only) + a one-time warn if none.
+let _warnedNoTextDecoder = false;
+function decodeUtf8(bytes) {
+    const decoder = resolveTextDecoder();
+    if (decoder) {
+        try {
+            return decoder.decode(bytes);
+        }
+        catch {
+            return null; // invalid UTF-8 -> keep bytes only
+        }
+    }
+    if (!_warnedNoTextDecoder) {
+        _warnedNoTextDecoder = true;
+        console.warn('[nitro-fetch] Reading a data: URL as text needs a TextDecoder. Install ' +
+            'react-native-nitro-text-decoder or expose a global TextDecoder. The ' +
+            'body is still available via response.arrayBuffer()/bytes().');
+    }
+    return null;
+}
+// Decode a data: URL into a synthetic 200 response, entirely in JS.
+function decodeDataUrl(url) {
+    const comma = url.indexOf(',');
+    if (comma < 0)
+        throw new TypeError('Failed to fetch: invalid data: URL');
+    const meta = url.slice(5, comma); // strip leading "data:"
+    const rawData = url.slice(comma + 1);
+    const isBase64 = /;base64\s*$/i.test(meta);
+    const mediaType = (isBase64 ? meta.replace(/;base64\s*$/i, '') : meta).trim() ||
+        'text/plain;charset=US-ASCII';
+    let bodyString;
+    let bodyBytes;
+    let length;
+    if (isBase64) {
+        const bytes = base64ToBytes(rawData);
+        length = bytes.byteLength;
+        // bytes for arrayBuffer/bytes; string for text/json when a decoder exists.
+        bodyBytes = bytes.buffer;
+        const decoded = decodeUtf8(bytes);
+        if (decoded != null)
+            bodyString = decoded;
+    }
+    else {
+        bodyString = decodeURIComponent(rawData);
+        length =
+            typeof TextEncoder !== 'undefined'
+                ? new TextEncoder().encode(bodyString).length
+                : bodyString.length;
+    }
     return {
-      url,
-      status: res.status,
-      statusText: res.statusText,
-      ok: res.ok,
-      redirected: res.redirected ?? false,
-      headers,
-      bodyBytes: bytes,
-      bodyString: undefined,
-    }; // bleee
-  }
-  const req = buildNitroRequest(input, init);
-  // Inspector: record start (zero cost when disabled — single boolean check)
-  let inspectorId;
-  if (NetworkInspector.isEnabled()) {
-    inspectorId = String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
-    NetworkInspector._recordStart(
-      inspectorId,
-      req.url,
-      req.method ?? 'GET',
-      req.headers ?? [],
-      req.bodyString
-    );
-  }
-  // Only allocate a requestId when a signal is present — zero overhead otherwise.
-  const requestId = signal ? String(Math.random()) : undefined;
-  if (requestId) req.requestId = requestId;
-  ensureClient();
-  if (!client || typeof client.request !== 'function')
-    throw new Error('NitroFetch client not available');
-  // Wire up the abort listener with { once: true } so it auto-removes
-  // after firing, avoiding a dangling reference to the client closure.
-  let abortListener;
-  if (signal && requestId) {
-    abortListener = () => {
-      try {
-        client.cancelRequest(requestId);
-      } catch {
-        // Client may already be torn down — swallow.
-      }
+        url,
+        status: 200,
+        statusText: 'OK',
+        ok: true,
+        redirected: false,
+        headers: [
+            { key: 'Content-Type', value: mediaType },
+            { key: 'Content-Length', value: String(length) },
+        ],
+        bodyString,
+        bodyBytes,
     };
-    signal.addEventListener('abort', abortListener, { once: true });
-  }
-  try {
-    const res = await client.request(req);
-    if (inspectorId) {
-      NetworkInspector._recordEnd(
-        inspectorId,
-        res.status,
-        res.statusText,
-        res.headers ?? [],
-        res.bodyString?.length ?? 0,
-        undefined,
-        res.bodyString ?? undefined
-      );
-    }
-    return res;
-  } catch (e) {
-    if (inspectorId) {
-      NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, String(e));
-    }
-    // If the signal was aborted (either before or during the request),
-    // surface a spec-compliant AbortError regardless of what native threw.
+}
+// Non-http(s): decode data: in JS, reject blob:, read file/content/path natively.
+async function fetchLocalResource(req) {
+    const url = req.url;
+    if (url.startsWith('data:'))
+        return decodeDataUrl(url);
+    if (url.startsWith('blob:')) {
+        throw new TypeError('nitro-fetch cannot read blob: URLs (the React Native blob registry is not ' +
+            'reachable from native). Read blobs with the platform fetch/FileReader instead.');
+    }
+    ensureClient();
+    if (!client || typeof client.request !== 'function') {
+        throw new Error('NitroFetch client not available');
+    }
+    return client.request(req);
+}
+async function nitroFetchRaw(input, init) {
+    const signal = init?.signal;
+    // Fast-abort: reject synchronously before any bridge work.
     if (signal?.aborted) {
-      throw createAbortError();
+        throw createAbortError();
+    }
+    // Extract body from standard Request when init.body is absent (ky/undici pattern)
+    init = await resolveRequestBody(input, init);
+    // Resolve Blob body to string before passing to sync buildNitroRequest
+    init = await resolveBlobBody(init);
+    const hasNative = typeof NitroFetchHybrid?.createClient === 'function';
+    if (!hasNative) {
+        // Fallback path not supported for raw; use global fetch and synthesize minimal shape
+        // @ts-ignore: global fetch exists in RN
+        const res = await fetch(input, init);
+        const url = res.url ?? String(input);
+        const bytes = await res.arrayBuffer();
+        const headers = [];
+        res.headers.forEach((v, k) => headers.push({ key: k, value: v }));
+        return {
+            url,
+            status: res.status,
+            statusText: res.statusText,
+            ok: res.ok,
+            redirected: res.redirected ?? false,
+            headers,
+            bodyBytes: bytes,
+            bodyString: undefined,
+        }; // bleee
+    }
+    const req = buildNitroRequest(input, init);
+    // Route non-http(s) (data:/file://content://scheme-less) off the HTTP client.
+    if (!isHttpUrl(req.url)) {
+        return fetchLocalResource(req);
+    }
+    // Inspector: record start (zero cost when disabled — single boolean check)
+    let inspectorId;
+    if (NetworkInspector.isEnabled()) {
+        inspectorId = String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
+        NetworkInspector._recordStart(inspectorId, req.url, req.method ?? 'GET', req.headers ?? [], req.bodyString);
+    }
+    // Only allocate a requestId when a signal is present — zero overhead otherwise.
+    const requestId = signal ? String(Math.random()) : undefined;
+    if (requestId)
+        req.requestId = requestId;
+    ensureClient();
+    if (!client || typeof client.request !== 'function')
+        throw new Error('NitroFetch client not available');
+    // Wire up the abort listener with { once: true } so it auto-removes
+    // after firing, avoiding a dangling reference to the client closure.
+    let abortListener;
+    if (signal && requestId) {
+        abortListener = () => {
+            try {
+                client.cancelRequest(requestId);
+            }
+            catch {
+                // Client may already be torn down — swallow.
+            }
+        };
+        signal.addEventListener('abort', abortListener, { once: true });
+    }
+    try {
+        const res = await client.request(req);
+        if (inspectorId) {
+            NetworkInspector._recordEnd(inspectorId, res.status, res.statusText, res.headers ?? [], res.bodyString?.length ?? 0, undefined, res.bodyString ?? undefined);
+        }
+        return res;
     }
-    throw e;
-  } finally {
-    // Idempotent cleanup — removeEventListener is a no-op if the listener
-    // already fired (thanks to { once: true }) or was never added.
-    if (signal && abortListener) {
-      signal.removeEventListener('abort', abortListener);
+    catch (e) {
+        if (inspectorId) {
+            NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, String(e));
+        }
+        // If the signal was aborted (either before or during the request),
+        // surface a spec-compliant AbortError regardless of what native threw.
+        if (signal?.aborted) {
+            throw createAbortError();
+        }
+        throw e;
+    }
+    finally {
+        // Idempotent cleanup — removeEventListener is a no-op if the listener
+        // already fired (thanks to { once: true }) or was never added.
+        if (signal && abortListener) {
+            signal.removeEventListener('abort', abortListener);
+        }
     }
-  }
 }
 // NitroHeaders is now imported from './Headers'
 async function nitroStreamFetch(input, init) {
-  const url = typeof input === 'string' ? input : String(input);
-  const method = init?.method?.toUpperCase() ?? 'GET';
-  const headers = headersToPairs(init?.headers);
-  // Inspector: record start
-  let inspectorId;
-  if (NetworkInspector.isEnabled()) {
-    inspectorId = String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
-    NetworkInspector._recordStart(
-      inspectorId,
-      url,
-      method,
-      headers ?? [],
-      typeof init?.body === 'string' ? init.body : undefined
-    );
-  }
-  const builder = NitroCronetSingleton.newUrlRequestBuilder(url);
-  builder.setHttpMethod(method);
-  headers?.forEach((h) => builder.addHeader(h.key, h.value));
-  const body = init?.body;
-  if (body != null) {
-    if (typeof body === 'string') builder.setUploadBody(body);
-    else if (body instanceof ArrayBuffer) builder.setUploadBody(body);
-  }
-  return new Promise((resolveResponse, rejectResponse) => {
-    let streamController;
-    const stream = new ReadableStream({
-      start(controller) {
-        streamController = controller;
-      },
-    });
-    let responseResolved = false;
-    let streamBytesReceived = 0;
-    builder.onResponseStarted((info) => {
-      if (responseResolved) return;
-      responseResolved = true;
-      const status = info.httpStatusCode;
-      const responseHeaders = new NitroHeaders(
-        Object.entries(info.allHeaders).map(([key, value]) => ({ key, value }))
-      );
-      const response = new NitroResponse({
-        url: info.url,
-        ok: status >= 200 && status < 300,
-        status,
-        statusText: info.httpStatusText,
-        headers: responseHeaders,
-        redirected: false,
-        body: stream,
-      });
-      resolveResponse(response);
-      // Android/Cronet: kick off the first buffer read.
-      // iOS/URLSession handles reading automatically so this is a no-op there.
-      request.read();
-    });
-    builder.onReadCompleted((_info, byteBuffer, bytesRead) => {
-      const chunk = new Uint8Array(byteBuffer, 0, bytesRead).slice();
-      streamBytesReceived += bytesRead;
-      streamController.enqueue(chunk);
-      if (!request.isDone()) {
-        request.read();
-      }
-    });
-    builder.onSucceeded((_info) => {
-      streamController.close();
-      if (inspectorId) {
-        const info = _info;
-        const status = info?.httpStatusCode ?? 0;
-        const hdrs = info?.allHeadersAsList ?? [];
-        NetworkInspector._recordEnd(
-          inspectorId,
-          status,
-          info?.httpStatusText ?? '',
-          hdrs,
-          streamBytesReceived
-        );
-      }
-    });
-    builder.onFailed((_info, error) => {
-      const err = new Error(error.message);
-      if (inspectorId) {
-        NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, error.message);
-      }
-      if (!responseResolved) {
-        responseResolved = true;
-        rejectResponse(err);
-      } else {
-        streamController.error(err);
-      }
-    });
-    builder.onCanceled(() => {
-      const err = createAbortError();
-      if (inspectorId) {
-        NetworkInspector._recordEnd(
-          inspectorId,
-          0,
-          '',
-          [],
-          0,
-          'Request canceled'
-        );
-      }
-      if (!responseResolved) {
-        responseResolved = true;
-        rejectResponse(err);
-      } else {
-        streamController.error(err);
-      }
+    const url = typeof input === 'string' ? input : String(input);
+    const method = init?.method?.toUpperCase() ?? 'GET';
+    const headers = headersToPairs(init?.headers);
+    // Inspector: record start
+    let inspectorId;
+    if (NetworkInspector.isEnabled()) {
+        inspectorId = String(Date.now()) + '-' + String(Math.random()).slice(2, 8);
+        NetworkInspector._recordStart(inspectorId, url, method, headers ?? [], typeof init?.body === 'string' ? init.body : undefined);
+    }
+    const builder = NitroCronetSingleton.newUrlRequestBuilder(url);
+    builder.setHttpMethod(method);
+    headers?.forEach((h) => builder.addHeader(h.key, h.value));
+    const body = init?.body;
+    if (body != null) {
+        if (typeof body === 'string')
+            builder.setUploadBody(body);
+        else if (body instanceof ArrayBuffer)
+            builder.setUploadBody(body);
+    }
+    return new Promise((resolveResponse, rejectResponse) => {
+        let streamController;
+        const stream = new ReadableStream({
+            start(controller) {
+                streamController = controller;
+            },
+        });
+        let responseResolved = false;
+        let streamBytesReceived = 0;
+        builder.onResponseStarted((info) => {
+            if (responseResolved)
+                return;
+            responseResolved = true;
+            const status = info.httpStatusCode;
+            const responseHeaders = new NitroHeaders(Object.entries(info.allHeaders).map(([key, value]) => ({ key, value })));
+            const response = new NitroResponse({
+                url: info.url,
+                ok: status >= 200 && status < 300,
+                status,
+                statusText: info.httpStatusText,
+                headers: responseHeaders,
+                redirected: false,
+                body: stream,
+            });
+            resolveResponse(response);
+            // Android/Cronet: kick off the first buffer read.
+            // iOS/URLSession handles reading automatically so this is a no-op there.
+            request.read();
+        });
+        builder.onReadCompleted((_info, byteBuffer, bytesRead) => {
+            const chunk = new Uint8Array(byteBuffer, 0, bytesRead).slice();
+            streamBytesReceived += bytesRead;
+            streamController.enqueue(chunk);
+            if (!request.isDone()) {
+                request.read();
+            }
+        });
+        builder.onSucceeded((_info) => {
+            streamController.close();
+            if (inspectorId) {
+                const info = _info;
+                const status = info?.httpStatusCode ?? 0;
+                const hdrs = info?.allHeadersAsList ?? [];
+                NetworkInspector._recordEnd(inspectorId, status, info?.httpStatusText ?? '', hdrs, streamBytesReceived);
+            }
+        });
+        builder.onFailed((_info, error) => {
+            const err = new Error(error.message);
+            if (inspectorId) {
+                NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, error.message);
+            }
+            if (!responseResolved) {
+                responseResolved = true;
+                rejectResponse(err);
+            }
+            else {
+                streamController.error(err);
+            }
+        });
+        builder.onCanceled(() => {
+            const err = createAbortError();
+            if (inspectorId) {
+                NetworkInspector._recordEnd(inspectorId, 0, '', [], 0, 'Request canceled');
+            }
+            if (!responseResolved) {
+                responseResolved = true;
+                rejectResponse(err);
+            }
+            else {
+                streamController.error(err);
+            }
+        });
+        const request = builder.build();
+        request.start();
     });
-    const request = builder.build();
-    request.start();
-  });
 }
 export async function nitroFetch(input, init) {
-  // Merge defaults from NitroRequestClass if input is one
-  if (input instanceof NitroRequestClass) {
-    init = {
-      ...init,
-      signal: init?.signal ?? input.signal,
-      redirect: init?.redirect ?? input.redirect,
-      cache: init?.cache ?? input.cache,
-    };
-  }
-  if (init?.stream === true) {
-    return nitroStreamFetch(input, init);
-  }
-  const redirectOption = init?.redirect ?? 'follow';
-  const res = await nitroFetchRaw(input, init);
-  // Handle redirect: "error" — if we got a 3xx back (followRedirects was false), throw
-  if (redirectOption === 'error' && res.status >= 300 && res.status < 400) {
-    throw new TypeError(
-      `redirect mode is "error": redirected request to "${res.url}"`
-    );
-  }
-  const response = new NitroResponse({
-    url: res.url,
-    status: res.status,
-    statusText: res.statusText,
-    ok: res.ok,
-    redirected: res.redirected,
-    headers: res.headers,
-    bodyBytes: res.bodyBytes,
-    bodyString: res.bodyString,
-  });
-  return response;
+    // Merge defaults from NitroRequestClass if input is one
+    if (input instanceof NitroRequestClass) {
+        init = {
+            ...init,
+            signal: init?.signal ?? input.signal,
+            redirect: init?.redirect ?? input.redirect,
+            cache: init?.cache ?? input.cache,
+        };
+    }
+    // Streaming is http(s)-only; local URLs fall through to nitroFetchRaw (check runs only when streaming).
+    if (init?.stream === true && isHttpUrl(getUrlString(input))) {
+        return nitroStreamFetch(input, init);
+    }
+    const redirectOption = init?.redirect ?? 'follow';
+    const res = await nitroFetchRaw(input, init);
+    // Handle redirect: "error" — if we got a 3xx back (followRedirects was false), throw
+    if (redirectOption === 'error' && res.status >= 300 && res.status < 400) {
+        throw new TypeError(`redirect mode is "error": redirected request to "${res.url}"`);
+    }
+    const response = new NitroResponse({
+        url: res.url,
+        status: res.status,
+        statusText: res.statusText,
+        ok: res.ok,
+        redirected: res.redirected,
+        headers: res.headers,
+        bodyBytes: res.bodyBytes,
+        bodyString: res.bodyString,
+    });
+    return response;
 }
 // Start a native prefetch. Requires a `prefetchKey` header on the request.
 export async function prefetch(input, init) {
-  // If native implementation is not present yet, do nothing
-  const hasNative = typeof NitroFetchHybrid?.createClient === 'function';
-  if (!hasNative) return;
-  // Build NitroRequest and ensure prefetchKey header exists
-  const req = buildNitroRequest(input, init);
-  const hasKey =
-    req.headers?.some((h) => h.key.toLowerCase() === 'prefetchkey') ?? false;
-  // Also support passing prefetchKey via non-standard field on init
-  const fromInit = init?.prefetchKey;
-  if (!hasKey && fromInit) {
-    req.headers = (req.headers ?? []).concat([
-      { key: 'prefetchKey', value: fromInit },
-    ]);
-  }
-  const finalHasKey = req.headers?.some(
-    (h) => h.key.toLowerCase() === 'prefetchkey'
-  );
-  if (!finalHasKey) {
-    throw new Error('prefetch requires a "prefetchKey" header');
-  }
-  // Ensure client and call native prefetch
-  ensureClient();
-  if (!client || typeof client.prefetch !== 'function') return;
-  await client.prefetch(req);
+    // If native implementation is not present yet, do nothing
+    const hasNative = typeof NitroFetchHybrid?.createClient === 'function';
+    if (!hasNative)
+        return;
+    // Build NitroRequest and ensure prefetchKey header exists
+    const req = buildNitroRequest(input, init);
+    const hasKey = req.headers?.some((h) => h.key.toLowerCase() === 'prefetchkey') ?? false;
+    // Also support passing prefetchKey via non-standard field on init
+    const fromInit = init?.prefetchKey;
+    if (!hasKey && fromInit) {
+        req.headers = (req.headers ?? []).concat([
+            { key: 'prefetchKey', value: fromInit },
+        ]);
+    }
+    const finalHasKey = req.headers?.some((h) => h.key.toLowerCase() === 'prefetchkey');
+    if (!finalHasKey) {
+        throw new Error('prefetch requires a "prefetchKey" header');
+    }
+    // Ensure client and call native prefetch
+    ensureClient();
+    if (!client || typeof client.prefetch !== 'function')
+        return;
+    await client.prefetch(req);
 }
 const AUTOPREFETCH_QUEUE_KEY = 'nitrofetch_autoprefetch_queue';
 // Persist a request to storage so native can prefetch it on app start.
 export async function prefetchOnAppStart(input, init) {
-  // Resolve request and prefetchKey
-  const req = buildNitroRequest(input, init);
-  const fromHeader = req.headers?.find(
-    (h) => h.key.toLowerCase() === 'prefetchkey'
-  )?.value;
-  const fromInit = init?.prefetchKey;
-  const prefetchKey = fromHeader ?? fromInit;
-  if (!prefetchKey) {
-    throw new Error(
-      'prefetchOnAppStart requires a "prefetchKey" (header or init.prefetchKey)'
-    );
-  }
-  // Convert headers to a plain object for storage
-  const headersObj = (req.headers ?? []).reduce((acc, { key, value }) => {
-    acc[String(key)] = String(value);
-    return acc;
-  }, {});
-  const entry = {
-    url: req.url,
-    prefetchKey,
-    headers: headersObj,
-  };
-  if (req.method && req.method !== 'GET') entry.method = req.method;
-  if (req.bodyString !== undefined) entry.bodyString = req.bodyString;
-  if (typeof req.bodyBytes === 'string' && req.bodyBytes.length > 0)
-    entry.bodyBytes = req.bodyBytes;
-  if (req.bodyFormData && req.bodyFormData.length > 0)
-    entry.bodyFormData = req.bodyFormData;
-  if (typeof req.timeoutMs === 'number') entry.timeoutMs = req.timeoutMs;
-  if (req.followRedirects === false) entry.followRedirects = false;
-  if (typeof req.prefetchCacheTtlMs === 'number')
-    entry.prefetchCacheTtlMs = req.prefetchCacheTtlMs;
-  // Write or append to storage queue
-  try {
-    let arr = [];
+    // Resolve request and prefetchKey
+    const req = buildNitroRequest(input, init);
+    const fromHeader = req.headers?.find((h) => h.key.toLowerCase() === 'prefetchkey')?.value;
+    const fromInit = init?.prefetchKey;
+    const prefetchKey = fromHeader ?? fromInit;
+    if (!prefetchKey) {
+        throw new Error('prefetchOnAppStart requires a "prefetchKey" (header or init.prefetchKey)');
+    }
+    // Convert headers to a plain object for storage
+    const headersObj = (req.headers ?? []).reduce((acc, { key, value }) => {
+        acc[String(key)] = String(value);
+        return acc;
+    }, {});
+    const entry = {
+        url: req.url,
+        prefetchKey,
+        headers: headersObj,
+    };
+    if (req.method && req.method !== 'GET')
+        entry.method = req.method;
+    if (req.bodyString !== undefined)
+        entry.bodyString = req.bodyString;
+    if (typeof req.bodyBytes === 'string' && req.bodyBytes.length > 0)
+        entry.bodyBytes = req.bodyBytes;
+    if (req.bodyFormData && req.bodyFormData.length > 0)
+        entry.bodyFormData = req.bodyFormData;
+    if (typeof req.timeoutMs === 'number')
+        entry.timeoutMs = req.timeoutMs;
+    if (req.followRedirects === false)
+        entry.followRedirects = false;
+    if (typeof req.prefetchCacheTtlMs === 'number')
+        entry.prefetchCacheTtlMs = req.prefetchCacheTtlMs;
+    // Write or append to storage queue
     try {
-      const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
-      if (raw) arr = JSON.parse(raw);
-      if (!Array.isArray(arr)) arr = [];
-    } catch {
-      arr = [];
-    }
-    if (arr.some((e) => e && e.prefetchKey === prefetchKey)) {
-      arr = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
-    }
-    arr.push(entry);
-    NativeStorageSingleton.setString(
-      AUTOPREFETCH_QUEUE_KEY,
-      JSON.stringify(arr)
-    );
-  } catch (e) {
-    console.warn('Failed to persist prefetch queue', e);
-  }
+        let arr = [];
+        try {
+            const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
+            if (raw)
+                arr = JSON.parse(raw);
+            if (!Array.isArray(arr))
+                arr = [];
+        }
+        catch {
+            arr = [];
+        }
+        if (arr.some((e) => e && e.prefetchKey === prefetchKey)) {
+            arr = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
+        }
+        arr.push(entry);
+        NativeStorageSingleton.setString(AUTOPREFETCH_QUEUE_KEY, JSON.stringify(arr));
+    }
+    catch (e) {
+        console.warn('Failed to persist prefetch queue', e);
+    }
 }
 // Remove one entry (by prefetchKey) from the auto-prefetch queue.
 export async function removeFromAutoPrefetch(prefetchKey) {
-  try {
-    let arr = [];
     try {
-      const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
-      if (raw) arr = JSON.parse(raw);
-      if (!Array.isArray(arr)) arr = [];
-    } catch {
-      arr = [];
-    }
-    const next = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
-    if (next.length === 0) {
-      NativeStorageSingleton.removeString(AUTOPREFETCH_QUEUE_KEY);
-    } else if (next.length !== arr.length) {
-      NativeStorageSingleton.setString(
-        AUTOPREFETCH_QUEUE_KEY,
-        JSON.stringify(next)
-      );
-    }
-  } catch (e) {
-    console.warn('Failed to remove from prefetch queue', e);
-  }
+        let arr = [];
+        try {
+            const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
+            if (raw)
+                arr = JSON.parse(raw);
+            if (!Array.isArray(arr))
+                arr = [];
+        }
+        catch {
+            arr = [];
+        }
+        const next = arr.filter((e) => e && e.prefetchKey !== prefetchKey);
+        if (next.length === 0) {
+            NativeStorageSingleton.removeString(AUTOPREFETCH_QUEUE_KEY);
+        }
+        else if (next.length !== arr.length) {
+            NativeStorageSingleton.setString(AUTOPREFETCH_QUEUE_KEY, JSON.stringify(next));
+        }
+    }
+    catch (e) {
+        console.warn('Failed to remove from prefetch queue', e);
+    }
 }
 // Remove all entries from the auto-prefetch queue.
 export async function removeAllFromAutoprefetch() {
-  NativeStorageSingleton.setString(AUTOPREFETCH_QUEUE_KEY, JSON.stringify([]));
+    NativeStorageSingleton.setString(AUTOPREFETCH_QUEUE_KEY, JSON.stringify([]));
 }
 export function __readAutoPrefetchQueue() {
-  try {
-    const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
-    if (!raw) return [];
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
+    try {
+        const raw = NativeStorageSingleton.getString(AUTOPREFETCH_QUEUE_KEY);
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
 }
 let nitroRuntime;
 function ensureWorkletRuntime(name = 'nitro-fetch') {
-  try {
-    const { createWorkletRuntime } = require('react-native-worklets');
-    nitroRuntime = nitroRuntime ?? createWorkletRuntime(name);
-    return nitroRuntime;
-  } catch {
-    console.warn('react-native-worklets not available');
-    return undefined;
-  }
+    try {
+        const { createWorkletRuntime } = require('react-native-worklets');
+        nitroRuntime = nitroRuntime ?? createWorkletRuntime(name);
+        return nitroRuntime;
+    }
+    catch {
+        console.warn('react-native-worklets not available');
+        return undefined;
+    }
 }
 export async function nitroFetchOnWorklet(input, init, mapWorklet, options) {
-  const preferBytes = options?.preferBytes === true; // default true
-  let runOnRuntimeAsync;
-  let rt;
-  try {
-    rt = ensureWorkletRuntime(options?.runtimeName);
-    const worklets = require('react-native-worklets');
-    runOnRuntimeAsync = worklets.runOnRuntimeAsync;
-  } catch {
-    // Module not available
-  }
-  // Fallback: if runtime is not available, do the work on JS
-  if (!runOnRuntimeAsync || !rt) {
-    console.warn('nitroFetchOnWorklet: no runtime, mapping on JS thread');
-    const res = await nitroFetchRaw(input, init);
-    const payload = {
-      url: res.url,
-      status: res.status,
-      statusText: res.statusText,
-      ok: res.ok,
-      redirected: res.redirected,
-      headers: res.headers,
-      bodyBytes: preferBytes ? res.bodyBytes : undefined,
-      bodyString: preferBytes ? undefined : res.bodyString,
-    };
-    return mapWorklet(payload);
-  }
-  return await runOnRuntimeAsync(rt, () => {
-    'worklet';
-    const nitroFetchClient = NitroFetchHybrid.createClient();
-    const request = buildNitroRequestPure(input, init);
-    const res = nitroFetchClient.requestSync(request);
-    const payload = {
-      url: res.url,
-      status: res.status,
-      statusText: res.statusText,
-      ok: res.ok,
-      redirected: res.redirected,
-      headers: res.headers,
-      bodyBytes: preferBytes ? res.bodyBytes : undefined,
-      bodyString: preferBytes ? undefined : res.bodyString,
-    };
-    return mapWorklet(payload);
-  });
+    const preferBytes = options?.preferBytes === true; // default true
+    let runOnRuntimeAsync;
+    let rt;
+    try {
+        rt = ensureWorkletRuntime(options?.runtimeName);
+        const worklets = require('react-native-worklets');
+        runOnRuntimeAsync = worklets.runOnRuntimeAsync;
+    }
+    catch {
+        // Module not available
+    }
+    // Fallback: if runtime is not available, do the work on JS
+    if (!runOnRuntimeAsync || !rt) {
+        console.warn('nitroFetchOnWorklet: no runtime, mapping on JS thread');
+        const res = await nitroFetchRaw(input, init);
+        const payload = {
+            url: res.url,
+            status: res.status,
+            statusText: res.statusText,
+            ok: res.ok,
+            redirected: res.redirected,
+            headers: res.headers,
+            bodyBytes: preferBytes ? res.bodyBytes : undefined,
+            bodyString: preferBytes ? undefined : res.bodyString,
+        };
+        return mapWorklet(payload);
+    }
+    return await runOnRuntimeAsync(rt, () => {
+        'worklet';
+        const nitroFetchClient = NitroFetchHybrid.createClient();
+        const request = buildNitroRequestPure(input, init);
+        const res = nitroFetchClient.requestSync(request);
+        const payload = {
+            url: res.url,
+            status: res.status,
+            statusText: res.statusText,
+            ok: res.ok,
+            redirected: res.redirected,
+            headers: res.headers,
+            bodyBytes: preferBytes ? res.bodyBytes : undefined,
+            bodyString: preferBytes ? undefined : res.bodyString,
+        };
+        return mapWorklet(payload);
+    });
 }
 export { NitroHeaders } from './Headers';
 export { NitroResponse } from './Response';