lint

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]
-        node: ["16", "15", "14", engines]
+        node: ["14", "12", engines]
         exclude:
           # On Windows, run tests with only the LTS environments.
           - os: windows-latest

.gitignore

@@ -63,4 +63,3 @@ typings/
 .env
 
 index.d.ts
-from.d.ts

CHANGELOG.md

@@ -1,35 +1,6 @@
 Changelog
 =========
 
-## v3.0.0-rc.0
-- Changed WeakMap for private field (require node 12)
-- Switch to ESM
-- blob.stream() return a subset of whatwg stream which is the async iterable
-  (it no longer return a node stream)
-- Reduced the dependency of Buffer by changing to global TextEncoder/Decoder (require node 11)
-- Disabled xo since it could understand private fields (#)
-- No longer transform the type to lowercase (https://github.com/w3c/FileAPI/issues/43)
-  This is more loose than strict, keys should be lowercased, but values should not.
-  It would require a more proper mime type parser - so we just made it loose.
-- index.js can now be imported by browser & deno since it no longer depends on any
-  core node features (but why would you? other environment can benefit from it)
-
-## v2.1.2
-- Fixed a bug where `start` in BlobDataItem was undefined (#85)
-
-## v2.1.1
-- Add nullish values checking in Symbol.hasInstance (#82)
-- Add generated typings for from.js file (#80)
-- Updated dev dependencies
-
-## v2.1.0
-- Fix: .slice has an implementation bug (#54).
-- Added blob backed up by filesystem (#55)
-
-## v2.0.1
-
-- Fix: remove upper bound for node engine semver (#49).
-
 ## v2.0.0
 
 > Note: This release was previously published as `1.0.7`, but as it contains breaking changes, we renamed it to `2.0.0`.

README.md

@@ -13,116 +13,18 @@ A Blob implementation in Node.js, originally from [node-fetch](https://github.co
 npm install fetch-blob
 ```
 
-<details>
-  <summary>Upgrading from 2x to 3x</summary>
-
-  Updating from 2 to 3 should be a breeze since there is not many changes to the blob specification.
-  The major cause of a major release is coding standards.
-    - internal WeakMaps was replaced with private fields
-    - internal Buffer.from was replaced with TextEncoder/Decoder
-    - internal buffers was replaced with Uint8Arrays
-    - CommonJS was replaced with ESM
-    - The node stream returned by calling `blob.stream()` was replaced with a simple generator function that yields Uint8Array (Breaking change)
-      (Read "Differences from other blobs" for more info.)
-
-    All of this changes have made it dependency free of any core node modules, so it would be possible to just import it using http-import from a CDN without any bundling
-
-</details>
-
-<details>
-  <summary>Differences from other Blobs</summary>
-
-  - Unlike NodeJS `buffer.Blob` (Added in: v15.7.0) and browser native Blob this polyfilled version can't be sent via PostMessage
-  - This blob version is more arbitrary, it can be constructed with blob parts that isn't a instance of itself
-  it has to look and behave as a blob to be accepted as a blob part.
-    - The benefit of this is that you can create other types of blobs that don't contain any internal data that has to be read in other ways, such as the `BlobDataItem` created in `from.js` that wraps a file path into a blob-like item and read lazily (nodejs plans to [implement this][fs-blobs] as well)
-  - The `blob.stream()` is the most noticeable differences. It returns a AsyncGeneratorFunction that yields Uint8Arrays
-
-  The reasoning behind `Blob.prototype.stream()` is that NodeJS readable stream
-  isn't spec compatible with whatwg streams and we didn't want to import the hole whatwg stream polyfill for node
-  or browserify NodeJS streams for the browsers and picking any flavor over the other. So we decided to opted out
-  of any stream and just implement the bear minium of what both streams have in common which is the asyncIterator
-  that both yields Uint8Array. this is the most isomorphic way with the use of `for-await-of` loops.
-  It would be redundant to convert anything to whatwg streams and than convert it back to
-  node streams since you work inside of Node.
-  It will probably stay like this until nodejs get native support for whatwg<sup>[1][https://github.com/nodejs/whatwg-stream]</sup> streams and whatwg stream add the node
-  equivalent for `Readable.from(iterable)`<sup>[2](https://github.com/whatwg/streams/issues/1018)</sup>
-
-  But for now if you really need a Node Stream then you can do so using this transformation
-  ```js
-    import {Readable} from 'stream'
-    const stream = Readable.from(blob.stream())
-  ```
-  But if you don't need it to be a stream then you can just use the asyncIterator part of it that is isomorphic.
-  ```js
-    for await (const chunk of blob.stream()) {
-      console.log(chunk) // uInt8Array
-    }
-  ```
-  If you need to make some feature detection to fix this different behavior
-  ```js
-  if (Blob.prototype.stream?.constructor?.name === 'AsyncGeneratorFunction') {
-    // not spec compatible, monkey patch it...
-    // (Alternative you could extend the Blob and use super.stream())
-    let orig = Blob.prototype.stream
-    Blob.prototype.stream = function () {
-      const iterator = orig.call(this)
-      return new ReadableStream({
-        async pull (ctrl) {
-          const next = await iterator.next()
-          return next.done ? ctrl.close() : ctrl.enqueue(next.value)
-        }
-      })
-    }
-  }
-  ```
-  Possible feature whatwg version: `ReadableStream.from(iterator)`
-  It's also possible to delete this method and instead use `.slice()` and `.arrayBuffer()` since it has both a public and private stream method
-</details>
-
 ## Usage
 
 ```js
-// Ways to import
-// (PS it's dependency free ESM package so regular http-import from CDN works too)
-import Blob from 'fetch-blob'
-import {Blob} from 'fetch-blob'
-const {Blob} = await import('fetch-blob')
+const Blob = require('fetch-blob');
+const fetch = require('node-fetch');
 
-
-// Ways to read the blob:
-const blob = new Blob(['hello, world'])
-
-await blob.text()
-await blob.arrayBuffer()
-for await (let chunk of  blob.stream()) { ... }
-
-// turn the async iterator into a node stream
-stream.Readable.from(blob.stream())
-
-// turn the async iterator into a whatwg stream (feature)
-globalThis.ReadableStream.from(blob.stream())
-```
-
-### Blob part backed up by filesystem
-To use, install [domexception](https://github.com/jsdom/domexception).
-
-```sh
-npm install fetch-blob domexception
-```
-
-```js
-// The default export is sync and use fs.stat to retrieve size & last modified
-import blobFromSync from 'fetch-blob/from.js'
-import {Blob, blobFrom, blobFromSync} from 'fetch-blob/from.js'
-
-const fsBlob1 = blobFromSync('./2-GiB-file.bin')
-const fsBlob2 = await blobFrom('./2-GiB-file.bin')
-
-// Not a 4 GiB memory snapshot, just holds 3 references
-// points to where data is located on the disk
-const blob = new Blob([fsBlob1, fsBlob2, 'memory'])
-console.log(blob.size) // 4 GiB
+fetch('https://httpbin.org/post', {
+    method: 'POST',
+    body: new Blob(['Hello World'], { type: 'text/plain' })
+})
+    .then(res => res.json());
+    .then(json => console.log(json));
 ```
 
 See the [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/API/Blob) and [tests](https://github.com/node-fetch/fetch-blob/blob/master/test.js) for more details.
@@ -135,4 +37,3 @@ See the [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/API/Blo
 [codecov-url]: https://codecov.io/gh/node-fetch/fetch-blob
 [install-size-image]: https://flat.badgen.net/packagephobia/install/fetch-blob
 [install-size-url]: https://packagephobia.now.sh/result?p=fetch-blob
-[fs-blobs]: https://github.com/nodejs/node/issues/37340

from.js

@@ -1,75 +0,0 @@
-import {statSync, createReadStream} from 'fs';
-import {stat} from 'fs/promises';
-import DOMException from 'domexception';
-import Blob from './index.js';
-
-/**
- * @param {string} path filepath on the disk
- * @returns {Blob}
- */
- const blobFromSync = path => from(statSync(path), path);
-
-/**
- * @param {string} path filepath on the disk
- * @returns {Promise<Blob>}
- */
- const blobFrom = path => stat(path).then(stat => from(stat, path));
-
-const from = (stat, path) => new Blob([new BlobDataItem({
-	path,
-	size: stat.size,
-	lastModified: stat.mtimeMs,
-	start: 0
-})]);
-
-/**
- * This is a blob backed up by a file on the disk
- * with minium requirement. Its wrapped around a Blob as a blobPart
- * so you have no direct access to this.
- *
- * @private
- */
-class BlobDataItem {
-	#path;
-	#start;
-
-	constructor(options) {
-		this.#path = options.path;
-		this.#start = options.start;
-		this.size = options.size;
-		this.lastModified = options.lastModified
-	}
-
-	/**
-	 * Slicing arguments is first validated and formatted
-	 * to not be out of range by Blob.prototype.slice
-	 */
-	slice(start, end) {
-		return new BlobDataItem({
-			path: this.#path,
-			lastModified: this.lastModified,
-			size: end - start,
-			start
-		});
-	}
-
-	async * stream() {
-		const {mtimeMs} = await stat(this.#path)
-		if (mtimeMs > this.lastModified) {
-			throw new DOMException('The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.', 'NotReadableError');
-		}
-		if (this.size) {
-			yield * createReadStream(this.#path, {
-				start: this.#start,
-				end: this.#start + this.size - 1
-			});
-		}
-	}
-
-	get [Symbol.toStringTag]() {
-		return 'Blob';
-	}
-}
-
-export default blobFromSync;
-export {Blob, blobFrom, blobFromSync};

index.js

@@ -1,76 +1,71 @@
-// 64 KiB (same size chrome slice theirs blob into Uint8array's)
-const POOL_SIZE = 65536;
+const {Readable} = require('stream');
 
-/** @param {(Blob | Uint8Array)[]} parts */
-async function * toIterator (parts, clone = true) {
-	for (let part of parts) {
+/**
+ * @type {WeakMap<Blob, {type: string, size: number, parts: (Blob | Buffer)[] }>}
+ */
+const wm = new WeakMap();
+
+async function * read(parts) {
+	for (const part of parts) {
 		if ('stream' in part) {
 			yield * part.stream();
-		} else if (ArrayBuffer.isView(part)) {
-			if (clone) {
-				let position = part.byteOffset;
-				let end = part.byteOffset + part.byteLength;
-				while (position !== end) {
-					const size = Math.min(end - position, POOL_SIZE);
-					const chunk = part.buffer.slice(position, position + size);
-					yield new Uint8Array(chunk);
-					position += chunk.byteLength;
-				}
-			} else {
-				yield part;
-			}
 		} else {
-			// For blobs that have arrayBuffer but no stream method (nodes buffer.Blob)
-			let position = 0;
-			while (position !== part.size) {
-				const chunk = part.slice(position, Math.min(part.size, position + POOL_SIZE));
-				const buffer = await chunk.arrayBuffer();
-				position += buffer.byteLength;
-				yield new Uint8Array(buffer);
-			}
+			yield part;
 		}
 	}
 }
 
-export default class Blob {
-
-	/** @type {Array.<(Blob|Uint8Array)>} */
-	#parts = [];
-	#type = '';
-	#size = 0;
+/**
+ * @template T
+ * @param {T} object
+ * @returns {T is Blob}
+ */
+const isBlob = object => {
+	return (
+		typeof object === 'object' &&
+		typeof object.stream === 'function' &&
+		typeof object.constructor === 'function' &&
+		/^(Blob|File)$/.test(object[Symbol.toStringTag])
+	);
+};
 
+class Blob {
 	/**
 	 * The Blob() constructor returns a new Blob object. The content
 	 * of the blob consists of the concatenation of the values given
 	 * in the parameter array.
 	 *
-	 * @param {*} blobParts
+	 * @param {(ArrayBufferLike | ArrayBufferView | Blob | Buffer | string)[]} blobParts
 	 * @param {{ type?: string }} [options]
 	 */
-	constructor(blobParts = [], options = {}) {
+	constructor(blobParts = [], options = {type: ''}) {
 		let size = 0;
 
 		const parts = blobParts.map(element => {
-			let part;
-			if (ArrayBuffer.isView(element)) {
-				part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
+			let buffer;
+			if (Buffer.isBuffer(element)) {
+				buffer = element;
+			} else if (ArrayBuffer.isView(element)) {
+				buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
 			} else if (element instanceof ArrayBuffer) {
-				part = new Uint8Array(element.slice(0));
-			} else if (element instanceof Blob) {
-				part = element;
+				buffer = Buffer.from(element);
+			} else if (isBlob(element)) {
+				buffer = element;
 			} else {
-				part = new TextEncoder().encode(String(element));
+				buffer = Buffer.from(typeof element === 'string' ? element : String(element));
 			}
 
-			size += ArrayBuffer.isView(part) ? part.byteLength : part.size;
-			return part;
+			size += buffer.length || buffer.size || 0;
+			return buffer;
 		});
 
-		const type = options.type === undefined ? '' : String(options.type);
+		const type = options.type === undefined ? '' : String(options.type).toLowerCase();
 
-		this.#type = /[^\u0020-\u007E]/.test(type) ? '' : type;
-		this.#size = size;
-		this.#parts = parts;
+		wm.set(this, {
+			type: /[^\u0020-\u007E]/.test(type) ? '' : type,
+			size,
+			parts
+		});
 	}
 
 	/**
@@ -78,14 +73,14 @@ export default class Blob {
 	 * size of the Blob in bytes.
 	 */
 	get size() {
-		return this.#size;
+		return wm.get(this).size;
 	}
 
 	/**
 	 * The type property of a Blob object returns the MIME type of the file.
 	 */
 	get type() {
-		return this.#type;
+		return wm.get(this).type;
 	}
 
 	/**
@@ -96,16 +91,7 @@ export default class Blob {
 	 * @return {Promise<string>}
 	 */
 	async text() {
-		// More optimized than using this.arrayBuffer()
-		// that requires twice as much ram
-		const decoder = new TextDecoder();
-		let str = '';
-		for await (let part of toIterator(this.#parts, false)) {
-			str += decoder.decode(part, { stream: true });
-		}
-		// Remaining
-		str += decoder.decode();
-		return str;
+		return Buffer.from(await this.arrayBuffer()).toString();
 	}
 
 	/**
@@ -118,7 +104,7 @@ export default class Blob {
 	async arrayBuffer() {
 		const data = new Uint8Array(this.size);
 		let offset = 0;
-		for await (const chunk of toIterator(this.#parts, false)) {
+		for await (const chunk of this.stream()) {
 			data.set(chunk, offset);
 			offset += chunk.length;
 		}
@@ -127,13 +113,13 @@ export default class Blob {
 	}
 
 	/**
-	 * The Blob stream() implements partial support of the whatwg stream
-	 * by only being async iterable.
+	 * The Blob interface's stream() method is difference from native
+	 * and uses node streams instead of whatwg streams.
 	 *
-	 * @returns {AsyncGenerator<Uint8Array>}
+	 * @returns {Readable} Node readable stream
 	 */
-	async * stream() {
-		yield * toIterator(this.#parts, true);
+	stream() {
+		return Readable.from(read(wm.get(this).parts));
 	}
 
 	/**
@@ -152,7 +138,7 @@ export default class Blob {
 		let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
 
 		const span = Math.max(relativeEnd - relativeStart, 0);
-		const parts = this.#parts;
+		const parts = wm.get(this).parts.values();
 		const blobParts = [];
 		let added = 0;
 
@@ -164,15 +150,9 @@ export default class Blob {
 				relativeStart -= size;
 				relativeEnd -= size;
 			} else {
-				let chunk
-				if (ArrayBuffer.isView(part)) {
-					chunk = part.subarray(relativeStart, Math.min(size, relativeEnd));
-					added += chunk.byteLength
-				} else {
-					chunk = part.slice(relativeStart, Math.min(size, relativeEnd));
-					added += chunk.size
-				}
+				const chunk = part.slice(relativeStart, Math.min(size, relativeEnd));
 				blobParts.push(chunk);
+				added += size;
 				relativeStart = 0; // All next sequental parts should start at 0
 
 				// don't add the overflow to new blobParts
@@ -182,29 +162,11 @@ export default class Blob {
 			}
 		}
 
-		const blob = new Blob([], {type: String(type).toLowerCase()});
-		blob.#size = span;
-		blob.#parts = blobParts;
+		const blob = new Blob([], {type});
+		Object.assign(wm.get(blob), {size: span, parts: blobParts});
 
 		return blob;
 	}
-
-	get [Symbol.toStringTag]() {
-		return 'Blob';
-	}
-
-	static [Symbol.hasInstance](object) {
-		return (
-			object &&
-			typeof object === 'object' &&
-			typeof object.constructor === 'function' &&
-			(
-				typeof object.stream === 'function' ||
-				typeof object.arrayBuffer === 'function'
-			) &&
-			/^(Blob|File)$/.test(object[Symbol.toStringTag])
-		);
-	}
 }
 
 Object.defineProperties(Blob.prototype, {
@@ -213,4 +175,11 @@ Object.defineProperties(Blob.prototype, {
 	slice: {enumerable: true}
 });
 
-export { Blob };
+Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
+	value: 'Blob',
+	writable: false,
+	enumerable: false,
+	configurable: true
+});
+
+module.exports = Blob;

package.json

@@ -1,21 +1,18 @@
 {
     "name": "fetch-blob",
-    "version": "3.0.0-rc.0",
+    "version": "2.0.0",
     "description": "A Blob implementation in Node.js, originally from node-fetch.",
     "main": "index.js",
-    "type": "module",
     "files": [
-        "from.js",
         "index.js",
-        "index.d.ts",
-        "from.d.ts"
+        "index.d.ts"
     ],
     "scripts": {
-        "lint": "xo test.js",
-        "test": "npm run lint && ava",
+        "lint": "xo",
+        "test": "xo && ava",
         "report": "c8 --reporter json --reporter text ava",
         "coverage": "c8 --reporter json --reporter text ava && codecov -f coverage/coverage-final.json",
-        "prepublishOnly": "tsc --declaration --emitDeclarationOnly --allowJs index.js from.js"
+        "prepublishOnly": "tsc --declaration --emitDeclarationOnly --allowJs index.js"
     },
     "repository": "https://github.com/node-fetch/fetch-blob.git",
     "keywords": [
@@ -23,7 +20,7 @@
         "node-fetch"
     ],
     "engines": {
-        "node": ">=14.0.0"
+        "node": "^10.17.0"
     },
     "author": "David Frank",
     "license": "MIT",
@@ -31,17 +28,16 @@
         "url": "https://github.com/node-fetch/fetch-blob/issues"
     },
     "homepage": "https://github.com/node-fetch/fetch-blob#readme",
+    "devDependencies": {
+        "ava": "^3.8.2",
+        "c8": "^7.2.0",
+        "codecov": "^3.7.0",
+        "get-stream": "^5.1.0",
+        "node-fetch": "^2.6.0",
+        "typescript": "^3.9.5",
+        "xo": "^0.32.0"
+    },
     "xo": {
-        "rules": {
-            "unicorn/import-index": "off",
-            "import/extensions": [
-                "error",
-                "always",
-                {
-                    "ignorePackages": true
-                }
-            ]
-        },
         "overrides": [
             {
                 "files": "test.js",
@@ -52,18 +48,5 @@
             }
         ]
     },
-    "peerDependenciesMeta": {
-        "domexception": {
-            "optional": true
-        }
-    },
-    "devDependencies": {
-        "ava": "^3.15.0",
-        "c8": "^7.7.1",
-        "codecov": "^3.8.1",
-        "domexception": "^2.0.1",
-        "node-fetch": "^3.0.0-beta.9",
-        "typescript": "^4.2.4",
-        "xo": "^0.38.2"
-    }
+    "dependencies": {}
 }

test.js

@@ -1,12 +1,8 @@
-import fs from 'fs';
-import test from 'ava';
-import {Response} from 'node-fetch';
-import {Readable} from 'stream';
-import buffer from 'buffer';
-import Blob from './index.js';
-import syncBlob, {blobFromSync, blobFrom} from './from.js';
-
-const license = fs.readFileSync('./LICENSE', 'utf-8');
+const test = require('ava');
+const Blob = require('.');
+const getStream = require('get-stream');
+const {Response} = require('node-fetch');
+const {TextDecoder} = require('util');
 
 test('new Blob()', t => {
 	const blob = new Blob(); // eslint-disable-line no-unused-vars
@@ -27,12 +23,11 @@ test('Blob ctor parts', async t => {
 		new Uint8Array([101]).buffer,
 		Buffer.from('f'),
 		new Blob(['g']),
-		{},
-		new URLSearchParams('foo')
+		{}
 	];
 
 	const blob = new Blob(parts);
-	t.is(await blob.text(), 'abcdefg[object Object]foo=');
+	t.is(await blob.text(), 'abcdefg[object Object]');
 });
 
 test('Blob size', t => {
@@ -84,10 +79,8 @@ test('Blob stream()', async t => {
 	const data = 'a=1';
 	const type = 'text/plain';
 	const blob = new Blob([data], {type});
-
-	for await (const chunk of blob.stream()) {
-		t.is(chunk.join(), [97, 61, 49].join());
-	}
+	const result = await getStream(blob.stream());
+	t.is(result, data);
 });
 
 test('Blob toString()', t => {
@@ -121,12 +114,6 @@ test('Blob slice(0, -1)', async t => {
 	t.is(await blob.text(), 'abcdefg');
 });
 
-test('Blob(["hello ", "world"]).slice(5)', async t => {
-	const parts = ['hello ', 'world'];
-	const blob = new Blob(parts);
-	t.is(await blob.slice(5).text(), ' world');
-});
-
 test('throw away unwanted parts', async t => {
 	const blob = new Blob(['a', 'b', 'c']).slice(1, 2);
 	t.is(await blob.text(), 'b');
@@ -136,7 +123,7 @@ test('Blob works with node-fetch Response.blob()', async t => {
 	const data = 'a=1';
 	const type = 'text/plain';
 	const blob = new Blob([data], {type});
-	const response = new Response(Readable.from(blob.stream()));
+	const response = new Response(blob);
 	const blob2 = await response.blob();
 	t.is(await blob2.text(), data);
 });
@@ -145,112 +132,7 @@ test('Blob works with node-fetch Response.text()', async t => {
 	const data = 'a=1';
 	const type = 'text/plain';
 	const blob = new Blob([data], {type});
-	const response = new Response(Readable.from(blob.stream()));
+	const response = new Response(blob);
 	const text = await response.text();
 	t.is(text, data);
 });
-
-test('blob part backed up by filesystem', async t => {
-	const blob = blobFromSync('./LICENSE');
-	t.is(await blob.slice(0, 3).text(), license.slice(0, 3));
-	t.is(await blob.slice(4, 11).text(), license.slice(4, 11));
-});
-
-test('Reading after modified should fail', async t => {
-	const blob = blobFromSync('./LICENSE');
-	await new Promise(resolve => {
-		setTimeout(resolve, 100);
-	});
-	const now = new Date();
-	// Change modified time
-	fs.utimesSync('./LICENSE', now, now);
-	const error = await blob.text().catch(error => error);
-	t.is(error instanceof Error, true);
-	t.is(error.name, 'NotReadableError');
-});
-
-test('Reading from the stream created by blobFrom', async t => {
-	const blob = blobFromSync('./LICENSE');
-	const actual = await blob.text();
-	t.is(actual, license);
-});
-
-test('create a blob from path asynchronous', async t => {
-	const blob = await blobFrom('./LICENSE');
-	const actual = await blob.text();
-	t.is(actual, license);
-});
-
-test('Reading empty blobs', async t => {
-	const blob = blobFromSync('./LICENSE').slice(0, 0);
-	const actual = await blob.text();
-	t.is(actual, '');
-});
-
-test('Blob-ish class is an instance of Blob', t => {
-	class File {
-		stream() {}
-
-		get [Symbol.toStringTag]() {
-			return 'File';
-		}
-	}
-
-	t.true(new File() instanceof Blob);
-});
-
-test('Instanceof check returns false for nullish values', t => {
-	t.false(null instanceof Blob);
-});
-
-/** @see https://github.com/w3c/FileAPI/issues/43 - important to keep boundary value */
-test('Dose not lowercase the blob values', t => {
-	const type = 'multipart/form-data; boundary=----WebKitFormBoundaryTKqdrVt01qOBltBd';
-	t.is(new Blob([], {type}).type, type);
-});
-
-test('Parts are immutable', async t => {
-	const buf = new Uint8Array([97]);
-	const blob = new Blob([buf]);
-	buf[0] = 98;
-	t.is(await blob.text(), 'a');
-});
-
-test('Blobs are immutable', async t => {
-	const buf = new Uint8Array([97]);
-	const blob = new Blob([buf]);
-	const chunk = await blob.stream().next();
-	t.is(chunk.value[0], 97);
-	chunk.value[0] = 98;
-	t.is(await blob.text(), 'a');
-});
-
-// This was necessary to avoid large ArrayBuffer clones (slice)
-test('Large chunks are divided into smaller chunks', async t => {
-	const buf = new Uint8Array(65590);
-	const blob = new Blob([buf]);
-	let i = 0;
-	// eslint-disable-next-line no-unused-vars
-	for await (const chunk of blob.stream()) {
-		i++;
-	}
-
-	t.is(i === 2, true);
-});
-
-test('Can use named import - as well as default', async t => {
-	const {Blob, default: def} = await import('./index.js');
-	t.is(Blob, def);
-});
-
-test('default from.js exports blobFromSync', t => {
-	t.is(blobFromSync, syncBlob);
-});
-
-if (buffer.Blob) {
-	test('Can wrap buffer.Blob to a fetch-blob', async t => {
-		const blob1 = new buffer.Blob(['blob part']);
-		const blob2 = new Blob([blob1]);
-		t.is(await blob2.text(), 'blob part');
-	});
-}