expo-blob 0.0.0 → 0.1.0

package/.eslintrc.js

@@ -0,0 +1,2 @@
+// @generated by expo-module-scripts
+module.exports = require('expo-module-scripts/eslintrc.base.js');

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## Unpublished
+
+### 🛠 Breaking changes
+
+### 🎉 New features
+
+### 🐛 Bug fixes
+
+### 💡 Others
+
+## 0.1.0 — 2025-08-15
+
+_This version does not introduce any user-facing changes._

package/README.md

@@ -0,0 +1,148 @@
+# ExpoBlob
+
+A Expo package that provides a Blob implementation for handling binary data, similar to the web Blob API.
+
+# Installation in managed Expo projects
+
+For [managed](https://docs.expo.dev/archive/managed-vs-bare/) Expo projects, please follow the installation instructions in the [API documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/blob/).
+
+# Installation in bare React Native projects
+
+For bare React Native projects, you must ensure that you have [installed and configured the `expo` package](https://docs.expo.dev/bare/installing-expo-modules/) before continuing.
+
+### Add the package to your npm dependencies
+
+```bash
+npx expo install expo-blob
+```
+
+### Configure for Android
+
+No additional set up necessary.
+
+### Configure for iOS
+
+Run `npx pod-install` after installing the npm package.
+
+## Usage
+
+### Basic Blob Creation
+
+```typescript
+import { ExpoBlob as Blob } from 'expo-blob';
+
+// Create an empty blob
+const emptyBlob = new Blob();
+
+// Create a blob from text
+const textBlob = new Blob(['Hello, World!'], { type: 'text/plain' });
+
+// Create a blob from binary data
+const binaryBlob = new Blob([new Uint8Array([1, 2, 3, 4])], {
+  type: 'application/octet-stream',
+});
+
+// Create a blob from mixed content
+const mixedBlob = new Blob(
+  [
+    'Text content',
+    new Uint8Array([65, 66, 67]), // ABC in ASCII
+    'More text',
+  ],
+  { type: 'text/plain' }
+);
+```
+
+### Blob Properties
+
+```typescript
+const blob = new Blob(['Hello, World!'], { type: 'text/plain' });
+
+console.log(blob.size); // 13 (bytes)
+console.log(blob.type); // "text/plain"
+```
+
+### Reading Blob Content
+
+```typescript
+const blob = new Blob(['Hello, World!'], { type: 'text/plain' });
+
+// Read as text
+const text = await blob.text();
+console.log(text); // "Hello, World!"
+
+// Read as bytes
+const bytes = await blob.bytes();
+console.log(bytes); // Uint8Array(13) [72, 101, 108, 108, 111, 44, 32, 87, 111, 114, 108, 100, 33]
+
+// Read as ArrayBuffer
+const arrayBuffer = await blob.arrayBuffer();
+console.log(arrayBuffer); // ArrayBuffer(13)
+```
+
+### Slicing Blobs
+
+```typescript
+const blob = new Blob(['Hello, World!'], { type: 'text/plain' });
+
+// Slice from position 0 to 5
+const slice1 = blob.slice(0, 5);
+console.log(await slice1.text()); // "Hello"
+
+// Slice from position 7 to end
+const slice2 = blob.slice(7);
+console.log(await slice2.text()); // "World!"
+
+// Slice with custom type
+const slice3 = blob.slice(0, 5, 'text/html');
+console.log(slice3.type); // "text/html"
+```
+
+### Streaming
+
+```typescript
+const blob = new Blob(['Large content...'], { type: 'text/plain' });
+
+// Create a readable stream
+const stream = blob.stream();
+const reader = stream.getReader();
+
+// Read chunks
+while (true) {
+  const { done, value } = await reader.read();
+  if (done) break;
+  console.log('Chunk:', value);
+}
+```
+
+## API Reference
+
+### Constructor
+
+```typescript
+new Blob(blobParts?: BlobPart[], options?: BlobPropertyBag)
+```
+
+**Parameters:**
+
+- `blobParts` (optional): Array of data to include in the blob
+- `options` (optional): Configuration object with:
+  - `type`: MIME type string
+  - `endings`: Line ending normalization ('transparent' or 'native')
+
+### Properties
+
+- `size`: The size of the blob in bytes (read-only)
+- `type`: The MIME type of the blob (read-only)
+
+### Methods
+
+- `slice(start?, end?, contentType?)`: Returns a new Blob containing a subset of the data
+- `text()`: Returns a Promise that resolves with the blob's content as a string
+- `bytes()`: Returns a Promise that resolves with the blob's content as a Uint8Array
+- `arrayBuffer()`: Returns a Promise that resolves with the blob's content as an ArrayBuffer
+- `stream()`: Returns a ReadableStream for streaming the blob's content
+
+# Contributing
+
+Contributions are very welcome! Please refer to guidelines described in the [contributing guide](https://github.com/expo/expo#contributing).

package/android/build.gradle

@@ -0,0 +1,15 @@
+plugins {
+  id 'com.android.library'
+  id 'expo-module-gradle-plugin'
+}
+
+group = 'host.exp.exponent'
+version = '0.1.0'
+
+android {
+  namespace "expo.modules.blob"
+  defaultConfig {
+    versionCode 1
+    versionName '0.1.0'
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/java/expo/modules/blob/Blob.kt

@@ -0,0 +1,185 @@
+package expo.modules.blob
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+import expo.modules.kotlin.sharedobjects.SharedObject
+import expo.modules.kotlin.typedarray.TypedArray
+import expo.modules.kotlin.types.EitherOfThree
+import expo.modules.kotlin.types.Enumerable
+import java.io.ByteArrayOutputStream
+import kotlin.math.max
+import kotlin.math.min
+
+internal const val DEFAULT_TYPE = ""
+
+internal class Blob(val blobParts: List<InternalBlobPart> = listOf(), rawType: String = DEFAULT_TYPE) : SharedObject() {
+  val size: Int by lazy {
+    blobParts.sumOf { it.size() }
+  }
+
+  val type = if (validType(rawType)) {
+    rawType.lowercase()
+  } else {
+    DEFAULT_TYPE
+  }
+
+  override fun getAdditionalMemoryPressure(): Int {
+    return size
+  }
+
+  fun bytesToStream(byteStream: ByteArrayOutputStream) {
+    for (blobPart in blobParts) {
+      blobPart.bytesToStream(byteStream)
+    }
+  }
+
+  fun bytes(): ByteArray {
+    val byteStream = ByteArrayOutputStream(size)
+    bytesToStream(byteStream)
+    return byteStream.toByteArray()
+  }
+
+  private fun InternalBlobPart.offsetSlice(start: Int, end: Int, offset: Int): InternalBlobPart {
+    val startIndex: Int = max(start - offset, 0)
+    val endIndex: Int = min(end - offset, size())
+    if (startIndex == 0 && endIndex == size()) {
+      return this
+    }
+    return when (this) {
+      is InternalBlobPart.StringWrapper -> InternalBlobPart.BufferWrapper(cachedBytes.slice(startIndex..<endIndex).toByteArray())
+      is InternalBlobPart.BlobWrapper -> InternalBlobPart.BlobWrapper(blob.slice(startIndex, endIndex, ""))
+      is InternalBlobPart.BufferWrapper -> InternalBlobPart.BufferWrapper(buffer.slice(startIndex..<endIndex).toByteArray())
+    }
+  }
+
+  fun slice(start: Int, end: Int, contentType: String): Blob {
+    if (start <= 0 && end >= size) {
+      return Blob(blobParts, contentType)
+    }
+    if (start >= end) {
+      return Blob(listOf(), contentType)
+    }
+    var i = 0
+    val bps = mutableListOf<InternalBlobPart>()
+    for (blobPart in blobParts) {
+      if (i + blobPart.size() <= start) {
+        i += blobPart.size()
+        continue
+      }
+      if (i >= end) {
+        break
+      }
+      bps.add(blobPart.offsetSlice(start, end, i))
+      i += blobPart.size()
+    }
+
+    return Blob(bps, contentType)
+  }
+}
+
+private fun validType(type: String): Boolean {
+  for (char in type) {
+    if (char.code < 0x20 || char.code > 0x7E) {
+      return false
+    }
+  }
+  return true
+}
+
+internal typealias BlobPart = EitherOfThree<String, Blob, TypedArray>
+
+private fun TypedArray.bytes(): ByteArray {
+  val byteArray = ByteArray(this.byteLength)
+
+  for (i in 0..<this.byteLength) {
+    byteArray[i] = this.readByte(i)
+  }
+
+  return byteArray
+}
+
+private fun String.toNativeNewlines(): String {
+  val result = StringBuilder(length)
+  var prevCR = false
+  for (char in this) {
+    if (char == '\r') {
+      result.append('\n')
+      prevCR = true
+      continue
+    }
+    if (!prevCR || char != '\n') {
+      result.append(char)
+    }
+    prevCR = false
+  }
+  return result.toString()
+}
+
+internal fun List<BlobPart>.internal(nativeNewlines: Boolean): List<InternalBlobPart> {
+  return this.map { blobPart: BlobPart ->
+    if (blobPart.`is`(String::class)) {
+      blobPart.get(String::class).let {
+        val str = if (nativeNewlines) {
+          it.toNativeNewlines()
+        } else {
+          it
+        }
+        InternalBlobPart.StringWrapper(str)
+      }
+    } else if (blobPart.`is`(Blob::class)) {
+      blobPart.get(Blob::class).let {
+        InternalBlobPart.BlobWrapper(it)
+      }
+    } else {
+      blobPart.get(TypedArray::class).let {
+        InternalBlobPart.BufferWrapper(it.bytes())
+      }
+    }
+  }
+}
+
+internal fun makeBlob(blobParts: List<BlobPart>?, options: BlobOptionsBag?): Blob {
+  val safeBlobParts = blobParts ?: listOf()
+  val safeOptions = options ?: BlobOptionsBag()
+  return Blob(safeBlobParts.internal(safeOptions.endings == EndingType.NATIVE), safeOptions.type)
+}
+
+internal sealed class InternalBlobPart {
+  class StringWrapper(string: String) : InternalBlobPart() {
+    val cachedBytes: ByteArray by lazy {
+      string.toByteArray()
+    }
+  }
+
+  data class BlobWrapper(val blob: Blob) : InternalBlobPart()
+  data class BufferWrapper(val buffer: ByteArray) : InternalBlobPart()
+
+  fun size(): Int {
+    return when (this) {
+      is StringWrapper -> cachedBytes.size
+      is BlobWrapper -> blob.size
+      is BufferWrapper -> buffer.size
+    }
+  }
+
+  fun bytesToStream(byteStream: ByteArrayOutputStream) {
+    when (this) {
+      is StringWrapper -> byteStream.write(cachedBytes)
+      is BlobWrapper -> blob.bytesToStream(byteStream)
+      is BufferWrapper -> byteStream.write(buffer)
+    }
+  }
+}
+
+internal enum class EndingType(val str: String) : Enumerable {
+  TRANSPARENT("transparent"),
+  NATIVE("native")
+}
+
+internal class BlobOptionsBag : Record {
+  @Field
+  val type: String = DEFAULT_TYPE
+
+  @Field
+  val endings: EndingType = EndingType.TRANSPARENT
+}

package/android/src/main/java/expo/modules/blob/BlobModule.kt

@@ -0,0 +1,50 @@
+package expo.modules.blob
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import kotlin.math.max
+import kotlin.math.min
+
+class BlobModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExpoBlob")
+
+    Class(Blob::class) {
+      Constructor { blobParts: List<BlobPart>?, options: BlobOptionsBag? ->
+        makeBlob(blobParts, options)
+      }
+
+      Property("size") { blob: Blob ->
+        blob.size
+      }
+
+      Property("type") { blob: Blob ->
+        blob.type
+      }
+
+      Function("slice") { blob: Blob, start: Int?, end: Int?, contentType: String? ->
+        var sliceStart: Int = start ?: 0
+        var sliceEnd: Int = end ?: blob.size
+        if (sliceStart < 0) {
+          sliceStart = max(blob.size + sliceStart, 0)
+        } else {
+          sliceStart = min(sliceStart, blob.size)
+        }
+        if (sliceEnd < 0) {
+          sliceEnd = max(blob.size + sliceEnd, 0)
+        } else {
+          sliceEnd = min(sliceEnd, blob.size)
+        }
+        blob.slice(sliceStart, sliceEnd, contentType ?: "")
+      }
+
+      AsyncFunction("bytes") { blob: Blob ->
+        blob.bytes()
+      }
+
+      AsyncFunction("text") { blob: Blob ->
+        blob.bytes().decodeToString()
+      }
+    }
+  }
+}

package/build/ExpoBlob.d.ts

@@ -0,0 +1,12 @@
+import { BlobPart, ExpoBlobModule } from './ExpoBlob.types';
+declare const NativeBlobModule: ExpoBlobModule;
+export declare class Blob extends NativeBlobModule.Blob {
+    constructor(blobParts?: BlobPart[] | Iterable<BlobPart>, options?: BlobPropertyBag);
+    slice(start?: number, end?: number, contentType?: string): Blob;
+    stream(): ReadableStream;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    toString(): string;
+    static get length(): number;
+}
+export {};
+//# sourceMappingURL=ExpoBlob.d.ts.map

package/build/ExpoBlob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBlob.d.ts","sourceRoot":"","sources":["../src/ExpoBlob.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAkB5D,QAAA,MAAM,gBAAgB,gBAAkD,CAAC;AAEzE,qBAAa,IAAK,SAAQ,gBAAgB,CAAC,IAAI;gBACjC,SAAS,CAAC,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe;IAmBlF,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI;IAO/D,MAAM,IAAI,cAAc;IAgDlB,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;IAQzC,QAAQ,IAAI,MAAM;IAKlB,MAAM,KAAK,MAAM,WAEhB;CACF"}

package/build/ExpoBlob.js

@@ -0,0 +1,90 @@
+import { requireNativeModule } from 'expo';
+import { DEFAULT_CHUNK_SIZE, isTypedArray, normalizedContentType, preprocessOptions, } from './utils';
+const inputMapping = (blobPart) => {
+    if (blobPart instanceof ArrayBuffer) {
+        return new Uint8Array(blobPart);
+    }
+    if (blobPart instanceof Blob || isTypedArray(blobPart)) {
+        return blobPart;
+    }
+    return String(blobPart);
+};
+const NativeBlobModule = requireNativeModule('ExpoBlob');
+export class Blob extends NativeBlobModule.Blob {
+    constructor(blobParts, options) {
+        if (!new.target) {
+            throw new TypeError("Blob constructor requires 'new' operator");
+        }
+        const processedBlobParts = [];
+        if (blobParts === undefined) {
+            super([], preprocessOptions(options));
+        }
+        else if (blobParts === null || typeof blobParts !== 'object') {
+            throw TypeError('Blob constructor requires blobParts to be a non-null object or undefined');
+        }
+        else {
+            for (const blobPart of blobParts) {
+                processedBlobParts.push(inputMapping(blobPart));
+            }
+            super(processedBlobParts, preprocessOptions(options));
+        }
+    }
+    slice(start, end, contentType) {
+        const normalizedType = normalizedContentType(contentType);
+        const slicedBlob = super.slice(start, end, normalizedType);
+        Object.setPrototypeOf(slicedBlob, Blob.prototype);
+        return slicedBlob;
+    }
+    stream() {
+        let getBlobBytes = this.bytes.bind(this);
+        let offset = 0;
+        let cachedBytes = null;
+        return new ReadableStream({
+            type: 'bytes',
+            async pull(controller) {
+                if (!cachedBytes) {
+                    if (!getBlobBytes) {
+                        throw new Error('Cannot read from a closed stream');
+                    }
+                    cachedBytes = await getBlobBytes();
+                    getBlobBytes = null;
+                }
+                if (offset >= cachedBytes.length) {
+                    controller.close();
+                    cachedBytes = null;
+                    return;
+                }
+                if (controller.byobRequest?.view) {
+                    const view = new Uint8Array(controller.byobRequest.view.buffer, controller.byobRequest.view.byteOffset, controller.byobRequest.view.byteLength);
+                    const end = Math.min(offset + view.byteLength, cachedBytes.length);
+                    const chunk = cachedBytes.subarray(offset, end);
+                    view.set(chunk, 0);
+                    controller.byobRequest.respond(chunk.length);
+                    offset = end;
+                    if (offset >= cachedBytes.length) {
+                        controller.close();
+                        cachedBytes = null;
+                    }
+                    return;
+                }
+                const chunkSize = DEFAULT_CHUNK_SIZE;
+                const end = Math.min(offset + chunkSize, cachedBytes.length);
+                controller.enqueue(cachedBytes.subarray(offset, end));
+                offset = end;
+            },
+        });
+    }
+    async arrayBuffer() {
+        return super.bytes().then((bytes) => 
+        // The Blob spec requires we always return a new ArrayBuffer even when its bounds match the TypedArray's
+        bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+    }
+    toString() {
+        return '[object Blob]';
+    }
+    // Changed the length property to match that of the default js implementation
+    static get length() {
+        return 0;
+    }
+}
+//# sourceMappingURL=ExpoBlob.js.map

package/build/ExpoBlob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBlob.js","sourceRoot":"","sources":["../src/ExpoBlob.ts"],"names":[],"mappings":"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","sourcesContent":["import { requireNativeModule } from 'expo';\n\nimport { BlobPart, ExpoBlobModule } from './ExpoBlob.types';\nimport {\n  DEFAULT_CHUNK_SIZE,\n  isTypedArray,\n  normalizedContentType,\n  preprocessOptions,\n} from './utils';\n\nconst inputMapping = (blobPart: BlobPart) => {\n  if (blobPart instanceof ArrayBuffer) {\n    return new Uint8Array(blobPart);\n  }\n  if (blobPart instanceof Blob || isTypedArray(blobPart)) {\n    return blobPart;\n  }\n  return String(blobPart);\n};\n\nconst NativeBlobModule = requireNativeModule<ExpoBlobModule>('ExpoBlob');\n\nexport class Blob extends NativeBlobModule.Blob {\n  constructor(blobParts?: BlobPart[] | Iterable<BlobPart>, options?: BlobPropertyBag) {\n    if (!new.target) {\n      throw new TypeError(\"Blob constructor requires 'new' operator\");\n    }\n\n    const processedBlobParts: BlobPart[] = [];\n\n    if (blobParts === undefined) {\n      super([], preprocessOptions(options));\n    } else if (blobParts === null || typeof blobParts !== 'object') {\n      throw TypeError('Blob constructor requires blobParts to be a non-null object or undefined');\n    } else {\n      for (const blobPart of blobParts) {\n        processedBlobParts.push(inputMapping(blobPart));\n      }\n      super(processedBlobParts, preprocessOptions(options));\n    }\n  }\n\n  slice(start?: number, end?: number, contentType?: string): Blob {\n    const normalizedType = normalizedContentType(contentType);\n    const slicedBlob = super.slice(start, end, normalizedType);\n    Object.setPrototypeOf(slicedBlob, Blob.prototype);\n    return slicedBlob as Blob;\n  }\n\n  stream(): ReadableStream {\n    let getBlobBytes: (() => Promise<Uint8Array>) | null = this.bytes.bind(this);\n    let offset = 0;\n    let cachedBytes: Uint8Array | null = null;\n\n    return new ReadableStream({\n      type: 'bytes',\n      async pull(controller: ReadableByteStreamController) {\n        if (!cachedBytes) {\n          if (!getBlobBytes) {\n            throw new Error('Cannot read from a closed stream');\n          }\n          cachedBytes = await getBlobBytes();\n          getBlobBytes = null;\n        }\n\n        if (offset >= cachedBytes.length) {\n          controller.close();\n          cachedBytes = null;\n          return;\n        }\n\n        if (controller.byobRequest?.view) {\n          const view: Uint8Array = new Uint8Array(\n            controller.byobRequest.view.buffer,\n            controller.byobRequest.view.byteOffset,\n            controller.byobRequest.view.byteLength\n          );\n          const end = Math.min(offset + view.byteLength, cachedBytes.length);\n          const chunk = cachedBytes.subarray(offset, end);\n          view.set(chunk, 0);\n          controller.byobRequest.respond(chunk.length);\n          offset = end;\n          if (offset >= cachedBytes.length) {\n            controller.close();\n            cachedBytes = null;\n          }\n          return;\n        }\n\n        const chunkSize = DEFAULT_CHUNK_SIZE;\n        const end = Math.min(offset + chunkSize, cachedBytes.length);\n        controller.enqueue(cachedBytes.subarray(offset, end) as ArrayBufferView<ArrayBuffer>);\n        offset = end;\n      },\n    });\n  }\n\n  async arrayBuffer(): Promise<ArrayBuffer> {\n    return super.bytes().then(\n      (bytes: Uint8Array) =>\n        // The Blob spec requires we always return a new ArrayBuffer even when its bounds match the TypedArray's\n        bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer\n    );\n  }\n\n  toString(): string {\n    return '[object Blob]';\n  }\n\n  // Changed the length property to match that of the default js implementation\n  static get length() {\n    return 0;\n  }\n}\n"]}

package/build/ExpoBlob.types.d.ts

@@ -0,0 +1,65 @@
+import { NativeModule, SharedObject } from 'expo';
+export declare class Blob {
+    /**
+     * The size of the `Blob` in bytes.
+     */
+    readonly size: number;
+    /**
+     * The MIME type of the `Blob`, or the empty string if the type cannot be determined.
+     */
+    readonly type: string;
+    /**
+     * Creates a new `Blob` object from the given parts and options.
+     * @param blobParts An array of `BlobPart` to include in the `Blob`.
+     * @param options An optional `BlobPropertyBag` dictionary.
+     */
+    constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);
+    /**
+     * @param start The starting byte index (inclusive) represented as a signed 32 bit integer (up to 2^31 - 1).
+     * @param end The ending byte index (exclusive) represented as a signed 32 bit integer (up to 2^31 - 1).
+     * @param contentType The MIME type of the new `Blob`. If not provided, defaults to an empty string.
+     * @returns A new `Blob` object containing the data in the specified range of bytes of the source `Blob`.
+     */
+    slice(start?: number, end?: number, contentType?: string): Blob;
+    /**
+     * @returns Promise resolving to the `Blob`'s binary data as a `Uint8Array`.
+     */
+    bytes(): Promise<Uint8Array>;
+    /**
+     * @returns Promise that resolves with the entire contents of the `Blob` as a UTF-8 string.
+     */
+    text(): Promise<string>;
+    /**
+     * > **Note**: The current implementation loads the entire `Blob` into memory before streaming.
+     * @returns A `ReadableStream` of the `Blob`'s data.
+     */
+    stream(): ReadableStream;
+    /**
+     * @returns Promise resolving to the `Blob`'s binary data as an `ArrayBuffer`.
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+/**
+ * @hidden
+ * @private
+ */
+export declare class NativeBlob extends SharedObject {
+    readonly size: number;
+    readonly type: string;
+    constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);
+    slice(start?: number, end?: number, contentType?: string): Blob;
+    bytes(): Promise<Uint8Array>;
+    text(): Promise<string>;
+}
+/**
+ * @hidden
+ * @private
+ */
+export declare class ExpoBlobModule extends NativeModule {
+    Blob: typeof NativeBlob;
+}
+/**
+ * Represents a part of a `Blob`. Can be a `string`, `ArrayBuffer`, `ArrayBufferView`, or another `Blob`.
+ */
+export type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob;
+//# sourceMappingURL=ExpoBlob.types.d.ts.map

package/build/ExpoBlob.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBlob.types.d.ts","sourceRoot":"","sources":["../src/ExpoBlob.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAElD,MAAM,CAAC,OAAO,OAAO,IAAI;IACvB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;gBACS,SAAS,CAAC,EAAE,QAAQ,EAAE,EAAE,OAAO,CAAC,EAAE,eAAe;IAE7D;;;;;OAKG;IACH,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI;IAE/D;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC;IAE5B;;OAEG;IACH,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;IACvB;;;OAGG;IACH,MAAM,IAAI,cAAc;IAExB;;OAEG;IACH,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC;CACpC;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,YAAY;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,SAAS,CAAC,EAAE,QAAQ,EAAE,EAAE,OAAO,CAAC,EAAE,eAAe;IAE7D,KAAK,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI;IAC/D,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC;IAC5B,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,YAAY;IACtD,IAAI,EAAE,OAAO,UAAU,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,eAAe,GAAG,IAAI,CAAC"}

package/build/ExpoBlob.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ExpoBlob.types.js.map

package/build/ExpoBlob.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBlob.types.js","sourceRoot":"","sources":["../src/ExpoBlob.types.ts"],"names":[],"mappings":"","sourcesContent":["import { NativeModule, SharedObject } from 'expo';\n\nexport declare class Blob {\n  /**\n   * The size of the `Blob` in bytes.\n   */\n  readonly size: number;\n  /**\n   * The MIME type of the `Blob`, or the empty string if the type cannot be determined.\n   */\n  readonly type: string;\n\n  /**\n   * Creates a new `Blob` object from the given parts and options.\n   * @param blobParts An array of `BlobPart` to include in the `Blob`.\n   * @param options An optional `BlobPropertyBag` dictionary.\n   */\n  constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);\n\n  /**\n   * @param start The starting byte index (inclusive) represented as a signed 32 bit integer (up to 2^31 - 1).\n   * @param end The ending byte index (exclusive) represented as a signed 32 bit integer (up to 2^31 - 1).\n   * @param contentType The MIME type of the new `Blob`. If not provided, defaults to an empty string.\n   * @returns A new `Blob` object containing the data in the specified range of bytes of the source `Blob`.\n   */\n  slice(start?: number, end?: number, contentType?: string): Blob;\n\n  /**\n   * @returns Promise resolving to the `Blob`'s binary data as a `Uint8Array`.\n   */\n  bytes(): Promise<Uint8Array>;\n\n  /**\n   * @returns Promise that resolves with the entire contents of the `Blob` as a UTF-8 string.\n   */\n  text(): Promise<string>;\n  /**\n   * > **Note**: The current implementation loads the entire `Blob` into memory before streaming.\n   * @returns A `ReadableStream` of the `Blob`'s data.\n   */\n  stream(): ReadableStream;\n\n  /**\n   * @returns Promise resolving to the `Blob`'s binary data as an `ArrayBuffer`.\n   */\n  arrayBuffer(): Promise<ArrayBuffer>;\n}\n\n/**\n * @hidden\n * @private\n */\nexport declare class NativeBlob extends SharedObject {\n  readonly size: number;\n  readonly type: string;\n\n  constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);\n\n  slice(start?: number, end?: number, contentType?: string): Blob;\n  bytes(): Promise<Uint8Array>;\n  text(): Promise<string>;\n}\n\n/**\n * @hidden\n * @private\n */\nexport declare class ExpoBlobModule extends NativeModule {\n  Blob: typeof NativeBlob;\n}\n\n/**\n * Represents a part of a `Blob`. Can be a `string`, `ArrayBuffer`, `ArrayBufferView`, or another `Blob`.\n */\nexport type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob;\n"]}

package/build/ExpoBlob.web.d.ts

@@ -0,0 +1,5 @@
+export declare const ExpoBlob: {
+    new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+    prototype: Blob;
+};
+//# sourceMappingURL=ExpoBlob.web.d.ts.map

package/build/ExpoBlob.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBlob.web.d.ts","sourceRoot":"","sources":["../src/ExpoBlob.web.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,QAAQ;;;CAAO,CAAC"}

package/build/ExpoBlob.web.js

@@ -0,0 +1,2 @@
+export const ExpoBlob = Blob;
+//# sourceMappingURL=ExpoBlob.web.js.map

package/build/ExpoBlob.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBlob.web.js","sourceRoot":"","sources":["../src/ExpoBlob.web.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,QAAQ,GAAG,IAAI,CAAC","sourcesContent":["export const ExpoBlob = Blob;\n"]}

package/build/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ExpoBlob';
+export type { BlobPart } from './ExpoBlob.types';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,YAAY,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC"}

package/build/index.js

@@ -0,0 +1,2 @@
+export * from './ExpoBlob';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC","sourcesContent":["export * from './ExpoBlob';\nexport type { BlobPart } from './ExpoBlob.types';\n"]}