commit

node_modules/fetch-blob/CHANGELOG.md

@@ -0,0 +1,55 @@
+Changelog
+=========
+
+## 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`.
+
+- **Breaking:** minimum supported Node.js version is now 10.17.
+- **Breaking:** `buffer` option has been removed.
+- Enhance: create TypeScript declarations from JSDoc (#45).
+- Enhance: operate on blob parts (byte sequence) (#44).
+- Enhance: use a `WeakMap` for private properties (#42) .
+- Other: update formatting.
+
+## v1.0.6
+
+- Enhance: use upstream Blob directly in typings (#38)
+- Other: update dependencies
+
+## v1.0.5
+
+- Other: no change to code, update dev dependency to address vulnerability reports
+
+## v1.0.4
+
+- Other: general code rewrite to pass linting, prepare for `node-fetch` release v3
+
+## v1.0.3
+
+- Fix: package.json export `blob.js` properly now
+
+## v1.0.2
+
+- Other: fix test integration
+
+## v1.0.1
+
+- Other: readme update
+
+## v1.0.0
+
+- Major: initial release

node_modules/fetch-blob/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 David Frank
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/fetch-blob/README.md

@@ -0,0 +1,57 @@
+# fetch-blob
+
+[![npm version][npm-image]][npm-url]
+[![build status][ci-image]][ci-url]
+[![coverage status][codecov-image]][codecov-url]
+[![install size][install-size-image]][install-size-url]
+
+A Blob implementation in Node.js, originally from [node-fetch](https://github.com/node-fetch/node-fetch).
+
+## Installation
+
+```sh
+npm install fetch-blob
+```
+
+## Usage
+
+```js
+const Blob = require('fetch-blob');
+const fetch = require('node-fetch');
+
+fetch('https://httpbin.org/post', {
+    method: 'POST',
+    body: new Blob(['Hello World'], { type: 'text/plain' })
+})
+    .then(res => res.json());
+    .then(json => console.log(json));
+```
+
+### Blob part backed up by filesystem
+To use, install [domexception](https://github.com/jsdom/domexception).
+
+```sh
+npm install fetch-blob domexception
+```
+
+```js
+const blobFrom = require('fetch-blob/from.js');
+const blob1 = blobFrom('./2-GiB-file.bin');
+const blob2 = 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([blob1, blob2]);
+console.log(blob.size) // 4 GiB
+```
+
+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.
+
+[npm-image]: https://flat.badgen.net/npm/v/fetch-blob
+[npm-url]: https://www.npmjs.com/package/fetch-blob
+[ci-image]: https://github.com/node-fetch/fetch-blob/workflows/CI/badge.svg
+[ci-url]: https://github.com/node-fetch/fetch-blob/actions
+[codecov-image]: https://flat.badgen.net/codecov/c/github/node-fetch/fetch-blob/master
+[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

node_modules/fetch-blob/from.d.ts

@@ -0,0 +1,7 @@
+export = blobFrom;
+/**
+ * @param {string} path filepath on the disk
+ * @returns {Blob}
+ */
+declare function blobFrom(path: string): Blob;
+import Blob = require("./index.js");

node_modules/fetch-blob/from.js

@@ -0,0 +1,57 @@
+const {statSync, createReadStream} = require('fs');
+const Blob = require('./index.js');
+const DOMException = require('domexception');
+
+/**
+ * @param {string} path filepath on the disk
+ * @returns {Blob}
+ */
+function blobFrom(path) {
+	const {size, mtime} = statSync(path);
+	const blob = new BlobDataItem({path, size, mtime});
+
+	return new Blob([blob]);
+}
+
+/**
+ * This is a blob backed up by a file on the disk
+ * with minium requirement
+ *
+ * @private
+ */
+class BlobDataItem {
+	constructor(options) {
+		this.size = options.size;
+		this.path = options.path;
+		this.start = options.start;
+		this.mtime = options.mtime;
+	}
+
+	// Slicing arguments is first validated and formated
+	// to not be out of range by Blob.prototype.slice
+	slice(start, end) {
+		return new BlobDataItem({
+			path: this.path,
+			start,
+			mtime: this.mtime,
+			size: end - start
+		});
+	}
+
+	stream() {
+		if (statSync(this.path).mtime > this.mtime) {
+			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');
+		}
+
+		return createReadStream(this.path, {
+			start: this.start,
+			end: this.start + this.size - 1
+		});
+	}
+
+	get [Symbol.toStringTag]() {
+		return 'Blob';
+	}
+}
+
+module.exports = blobFrom;

node_modules/fetch-blob/index.d.ts

@@ -0,0 +1,59 @@
+export = Blob;
+declare class Blob {
+    static [Symbol.hasInstance](object: any): boolean;
+    /**
+     * 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 {(ArrayBufferLike | ArrayBufferView | Blob | Buffer | string)[]} blobParts
+     * @param {{ type?: string }} [options]
+     */
+    constructor(blobParts?: (ArrayBufferLike | ArrayBufferView | Blob | Buffer | string)[], options?: {
+        type?: string;
+    });
+    /**
+     * The Blob interface's size property returns the
+     * size of the Blob in bytes.
+     */
+    get size(): number;
+    /**
+     * The type property of a Blob object returns the MIME type of the file.
+     */
+    get type(): string;
+    /**
+     * The text() method in the Blob interface returns a Promise
+     * that resolves with a string containing the contents of
+     * the blob, interpreted as UTF-8.
+     *
+     * @return {Promise<string>}
+     */
+    text(): Promise<string>;
+    /**
+     * The arrayBuffer() method in the Blob interface returns a
+     * Promise that resolves with the contents of the blob as
+     * binary data contained in an ArrayBuffer.
+     *
+     * @return {Promise<ArrayBuffer>}
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * The Blob interface's stream() method is difference from native
+     * and uses node streams instead of whatwg streams.
+     *
+     * @returns {Readable} Node readable stream
+     */
+    stream(): Readable;
+    /**
+     * The Blob interface's slice() method creates and returns a
+     * new Blob object which contains data from a subset of the
+     * blob on which it's called.
+     *
+     * @param {number} [start]
+     * @param {number} [end]
+     * @param {string} [type]
+     */
+    slice(start?: number, end?: number, type?: string): Blob;
+    get [Symbol.toStringTag](): string;
+}
+import { Readable } from "stream";

node_modules/fetch-blob/index.js

@@ -0,0 +1,180 @@
+const {Readable} = require('stream');
+
+/**
+ * @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 {
+			yield part;
+		}
+	}
+}
+
+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 {(ArrayBufferLike | ArrayBufferView | Blob | Buffer | string)[]} blobParts
+	 * @param {{ type?: string }} [options]
+	 */
+	constructor(blobParts = [], options = {}) {
+		let size = 0;
+
+		const parts = blobParts.map(element => {
+			let buffer;
+			if (element instanceof Buffer) {
+				buffer = element;
+			} else if (ArrayBuffer.isView(element)) {
+				buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
+			} else if (element instanceof ArrayBuffer) {
+				buffer = Buffer.from(element);
+			} else if (element instanceof Blob) {
+				buffer = element;
+			} else {
+				buffer = Buffer.from(typeof element === 'string' ? element : String(element));
+			}
+
+			// eslint-disable-next-line unicorn/explicit-length-check
+			size += buffer.length || buffer.size || 0;
+			return buffer;
+		});
+
+		const type = options.type === undefined ? '' : String(options.type).toLowerCase();
+
+		wm.set(this, {
+			type: /[^\u0020-\u007E]/.test(type) ? '' : type,
+			size,
+			parts
+		});
+	}
+
+	/**
+	 * The Blob interface's size property returns the
+	 * size of the Blob in bytes.
+	 */
+	get size() {
+		return wm.get(this).size;
+	}
+
+	/**
+	 * The type property of a Blob object returns the MIME type of the file.
+	 */
+	get type() {
+		return wm.get(this).type;
+	}
+
+	/**
+	 * The text() method in the Blob interface returns a Promise
+	 * that resolves with a string containing the contents of
+	 * the blob, interpreted as UTF-8.
+	 *
+	 * @return {Promise<string>}
+	 */
+	async text() {
+		return Buffer.from(await this.arrayBuffer()).toString();
+	}
+
+	/**
+	 * The arrayBuffer() method in the Blob interface returns a
+	 * Promise that resolves with the contents of the blob as
+	 * binary data contained in an ArrayBuffer.
+	 *
+	 * @return {Promise<ArrayBuffer>}
+	 */
+	async arrayBuffer() {
+		const data = new Uint8Array(this.size);
+		let offset = 0;
+		for await (const chunk of this.stream()) {
+			data.set(chunk, offset);
+			offset += chunk.length;
+		}
+
+		return data.buffer;
+	}
+
+	/**
+	 * The Blob interface's stream() method is difference from native
+	 * and uses node streams instead of whatwg streams.
+	 *
+	 * @returns {Readable} Node readable stream
+	 */
+	stream() {
+		return Readable.from(read(wm.get(this).parts));
+	}
+
+	/**
+	 * The Blob interface's slice() method creates and returns a
+	 * new Blob object which contains data from a subset of the
+	 * blob on which it's called.
+	 *
+	 * @param {number} [start]
+	 * @param {number} [end]
+	 * @param {string} [type]
+	 */
+	slice(start = 0, end = this.size, type = '') {
+		const {size} = this;
+
+		let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+		let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+
+		const span = Math.max(relativeEnd - relativeStart, 0);
+		const parts = wm.get(this).parts.values();
+		const blobParts = [];
+		let added = 0;
+
+		for (const part of parts) {
+			const size = ArrayBuffer.isView(part) ? part.byteLength : part.size;
+			if (relativeStart && size <= relativeStart) {
+				// Skip the beginning and change the relative
+				// start & end position as we skip the unwanted parts
+				relativeStart -= size;
+				relativeEnd -= size;
+			} else {
+				const chunk = part.slice(relativeStart, Math.min(size, relativeEnd));
+				blobParts.push(chunk);
+				added += ArrayBuffer.isView(chunk) ? chunk.byteLength : chunk.size;
+				relativeStart = 0; // All next sequental parts should start at 0
+
+				// don't add the overflow to new blobParts
+				if (added >= span) {
+					break;
+				}
+			}
+		}
+
+		const blob = new Blob([], {type: String(type).toLowerCase()});
+		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.stream === 'function' &&
+			object.stream.length === 0 &&
+			typeof object.constructor === 'function' &&
+			/^(Blob|File)$/.test(object[Symbol.toStringTag])
+		);
+	}
+}
+
+Object.defineProperties(Blob.prototype, {
+	size: {enumerable: true},
+	type: {enumerable: true},
+	slice: {enumerable: true}
+});
+
+module.exports = Blob;

node_modules/fetch-blob/package.json

@@ -0,0 +1,69 @@
+{
+    "name": "fetch-blob",
+    "version": "2.1.2",
+    "description": "A Blob implementation in Node.js, originally from node-fetch.",
+    "main": "index.js",
+    "files": [
+        "from.js",
+        "index.js",
+        "index.d.ts",
+        "from.d.ts"
+    ],
+    "scripts": {
+        "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"
+    },
+    "repository": "https://github.com/node-fetch/fetch-blob.git",
+    "keywords": [
+        "blob",
+        "node-fetch"
+    ],
+    "engines": {
+        "node": "^10.17.0 || >=12.3.0"
+    },
+    "author": "David Frank",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/node-fetch/fetch-blob/issues"
+    },
+    "homepage": "https://github.com/node-fetch/fetch-blob#readme",
+    "xo": {
+        "rules": {
+            "unicorn/import-index": "off",
+            "import/extensions": [
+                "error",
+                "always",
+                {
+                    "ignorePackages": true
+                }
+            ]
+        },
+        "overrides": [
+            {
+                "files": "test.js",
+                "rules": {
+                    "node/no-unsupported-features/es-syntax": 0,
+                    "node/no-unsupported-features/node-builtins": 0
+                }
+            }
+        ]
+    },
+    "peerDependenciesMeta": {
+        "domexception": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "ava": "^3.15.0",
+        "c8": "^7.7.1",
+        "codecov": "^3.8.1",
+        "domexception": "^2.0.1",
+        "get-stream": "^6.0.1",
+        "node-fetch": "^2.6.1",
+        "typescript": "^4.2.4",
+        "xo": "^0.38.2"
+    }
+}