buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/file/Blob.ts

@@ -0,0 +1,163 @@
+import { Buffer } from 'buffer';
+import { ReadableStream } from 'stream/web';
+import * as PropertySymbol from '../PropertySymbol.js';
+
+/**
+ * Reference:
+ * https://developer.mozilla.org/en-US/docs/Web/API/Blob.
+ *
+ * Based on:
+ * https://github.com/jsdom/jsdom/blob/master/lib/jsdom/living/file-api/Blob-impl.js (MIT licensed).
+ */
+export default class Blob {
+	public readonly type: string = '';
+	public [PropertySymbol.buffer]: Buffer;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param [bits] Bits.
+	 * @param [options] Options.
+	 * @param [options.type] MIME type.
+	 */
+	constructor(
+		bits?: (ArrayBuffer | ArrayBufferView | Blob | Buffer | string)[],
+		options?: { type?: string }
+	) {
+		const buffers = [];
+
+		if (bits) {
+			for (const bit of bits) {
+				let buffer: Buffer;
+
+				if (bit instanceof ArrayBuffer) {
+					buffer = Buffer.from(new Uint8Array(bit));
+				} else if (bit instanceof Blob) {
+					buffer = bit[PropertySymbol.buffer];
+				} else if (bit instanceof Buffer) {
+					buffer = bit;
+				} else if (ArrayBuffer.isView(bit)) {
+					buffer = Buffer.from(new Uint8Array(bit.buffer, bit.byteOffset, bit.byteLength));
+				} else {
+					buffer = Buffer.from(typeof bit === 'string' ? bit : String(bit));
+				}
+
+				buffers.push(buffer);
+			}
+		}
+
+		this[PropertySymbol.buffer] = Buffer.concat(buffers);
+
+		if (options && options.type && options.type.match(/^[\u0020-\u007E]*$/)) {
+			this.type = String(options.type).toLowerCase();
+		}
+	}
+
+	/**
+	 * Returns size.
+	 *
+	 * @returns Size.
+	 */
+	public get size(): number {
+		return this[PropertySymbol.buffer].length;
+	}
+
+	/**
+	 * Slices the blob.
+	 *
+	 * @param start Start.
+	 * @param end End.
+	 * @param contentType Content type.
+	 * @returns New Blob.
+	 */
+	public slice(start = 0, end: number | null = null, contentType = ''): Blob {
+		const size = this.size;
+
+		let relativeStart;
+		let relativeEnd;
+		let relativeContentType;
+
+		if (start === undefined) {
+			relativeStart = 0;
+		} else if (start < 0) {
+			relativeStart = Math.max(size + start, 0);
+		} else {
+			relativeStart = Math.min(start, size);
+		}
+		if (end === null) {
+			relativeEnd = size;
+		} else if (end < 0) {
+			relativeEnd = Math.max(size + end, 0);
+		} else {
+			relativeEnd = Math.min(end, size);
+		}
+
+		if (contentType === undefined) {
+			relativeContentType = '';
+		} else {
+			// Sanitization (lower case and invalid char check) is done in the
+			// Constructor
+			relativeContentType = contentType;
+		}
+
+		const span = Math.max(relativeEnd - relativeStart, 0);
+
+		const buffer = this[PropertySymbol.buffer];
+		const slicedBuffer = buffer.slice(relativeStart, relativeStart + span);
+
+		const blob = new Blob([], { type: relativeContentType });
+
+		(<Buffer>blob[PropertySymbol.buffer]) = slicedBuffer;
+
+		return blob;
+	}
+
+	/**
+	 * Returns a Promise that resolves to a ArrayBuffer.
+	 *
+	 * @returns ArrayBuffer.
+	 */
+
+	// Reference:
+	// https://github.com/web-std/io/blob/c88170bf24f064adfbb3586a21fb76650ca5a9ab/packages/blob/src/blob.js#L139-L148
+	// https://stackoverflow.com/questions/8609289/convert-a-binary-nodejs-buffer-to-javascript-arraybuffer
+	/**
+	 *
+	 */
+	public async arrayBuffer(): Promise<ArrayBuffer> {
+		return new Uint8Array(this[PropertySymbol.buffer]).buffer;
+	}
+
+	/**
+	 * Returns a Promise that resolves to a text.
+	 *
+	 * @returns Text.
+	 */
+	public async text(): Promise<string> {
+		return this[PropertySymbol.buffer].toString();
+	}
+
+	/**
+	 * Returns returns a ReadableStream which upon reading returns the data contained within the Blob.
+	 *
+	 * @returns ReadableStream
+	 */
+	public stream(): ReadableStream {
+		const buffer = this[PropertySymbol.buffer];
+		return new ReadableStream({
+			start(controller) {
+				controller.enqueue(buffer);
+				controller.close();
+			}
+		});
+	}
+
+	/**
+	 * Returns the object converted to string.
+	 *
+	 * @returns String.
+	 */
+	public toString(): string {
+		return '[object Blob]';
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/file/File.ts

@@ -0,0 +1,43 @@
+import Blob from './Blob.js';
+import type { Buffer } from 'buffer';
+
+/**
+ * Reference:
+ * https://developer.mozilla.org/en-US/docs/Web/API/File.
+ *
+ * Based on:
+ * https://github.com/jsdom/jsdom/blob/master/lib/jsdom/living/file-api/File-impl.js (MIT licensed).
+ */
+export default class File extends Blob {
+	public readonly lastModified: number;
+	public readonly name: string;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param bits File bits.
+	 * @param name File name.
+	 * @param [options] Options.
+	 * @param [options.type] MIME type.
+	 * @param [options.lastModifier] Last modified. Defaults to Date.now().
+	 * @param options.lastModified
+	 */
+	constructor(
+		bits: (ArrayBuffer | ArrayBufferView | Blob | Buffer | string)[],
+		name: string,
+		options?: { type?: string; lastModified?: number }
+	) {
+		if (arguments.length < 2) {
+			throw new TypeError(
+				"Failed to construct 'File': 2 arguments required, but only " +
+					arguments.length +
+					' present.'
+			);
+		}
+
+		super(bits, options);
+
+		this.name = name;
+		this.lastModified = options && options.lastModified ? options.lastModified : Date.now();
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/file/FileReader.ts

@@ -0,0 +1,211 @@
+import WhatwgMIMEType from '../../../../../../lib/happy-dom/mime-type-adapter.js';
+import * as PropertySymbol from '../PropertySymbol.js';
+import ProgressEvent from '../event/events/ProgressEvent.js';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum.js';
+import Blob from './Blob.js';
+import FileReaderReadyStateEnum from './FileReaderReadyStateEnum.js';
+import FileReaderFormatEnum from './FileReaderFormatEnum.js';
+import EventTarget from '../event/EventTarget.js';
+import FileReaderEventTypeEnum from './FileReaderEventTypeEnum.js';
+import { Buffer } from 'buffer';
+
+/**
+ * Reference:
+ * https://developer.mozilla.org/sv-SE/docs/Web/API/FileReader.
+ *
+ * Based on:
+ * https://github.com/jsdom/jsdom/blob/master/lib/jsdom/living/file-api/FileReader-impl.js (MIT licensed).
+ */
+export default class FileReader extends EventTarget {
+	public readonly error: Error | null = null;
+	public readonly result: Buffer | ArrayBuffer | string | null = null;
+	public readonly readyState: number = FileReaderReadyStateEnum.empty;
+	public readonly onabort: ((event: ProgressEvent) => void) | null = null;
+	public readonly onerror: ((event: ProgressEvent) => void) | null = null;
+	public readonly onload: ((event: ProgressEvent) => void) | null = null;
+	public readonly onloadstart: ((event: ProgressEvent) => void) | null = null;
+	public readonly onloadend: ((event: ProgressEvent) => void) | null = null;
+	public readonly onprogress: ((event: ProgressEvent) => void) | null = null;
+	#isTerminated = false;
+	#loadTimeout: NodeJS.Timeout | null = null;
+	#parseTimeout: NodeJS.Timeout | null = null;
+
+	/**
+	 * Constructor.
+	 */
+	constructor() {
+		super();
+
+		if (!this[PropertySymbol.window]) {
+			throw new TypeError(
+				`Failed to construct '${this.constructor.name}': '${this.constructor.name}' was constructed outside a Window context.`
+			);
+		}
+	}
+
+	/**
+	 * Reads as ArrayBuffer.
+	 *
+	 * @param blob Blob.
+	 */
+	public readAsArrayBuffer(blob: Blob): void {
+		if (!(blob instanceof Blob)) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to execute 'readAsArrayBuffer' on 'FileReader': parameter 1 is not of type 'Blob'.`
+			);
+		}
+		this.#readFile(blob, FileReaderFormatEnum.buffer);
+	}
+
+	/**
+	 * Reads as binary string.
+	 *
+	 * @param blob Blob.
+	 */
+	public readAsBinaryString(blob: Blob): void {
+		if (!(blob instanceof Blob)) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to execute 'readAsBinaryString' on 'FileReader': parameter 1 is not of type 'Blob'.`
+			);
+		}
+		this.#readFile(blob, FileReaderFormatEnum.binaryString);
+	}
+
+	/**
+	 * Reads as data URL.
+	 *
+	 * @param blob Blob.
+	 */
+	public readAsDataURL(blob: Blob): void {
+		if (!(blob instanceof Blob)) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to execute 'readAsDataURL' on 'FileReader': parameter 1 is not of type 'Blob'.`
+			);
+		}
+		this.#readFile(blob, FileReaderFormatEnum.dataURL);
+	}
+
+	/**
+	 * Reads as text.
+	 *
+	 * @param blob Blob.
+	 * @param [encoding] Encoding.
+	 */
+	public readAsText(blob: Blob, encoding: string | null = null): void {
+		if (!(blob instanceof Blob)) {
+			throw new this[PropertySymbol.window].TypeError(
+				`Failed to execute 'readAsText' on 'FileReader': parameter 1 is not of type 'Blob'.`
+			);
+		}
+		this.#readFile(blob, FileReaderFormatEnum.text, encoding || 'UTF-8');
+	}
+
+	/**
+	 * Aborts the file reader.
+	 */
+	public abort(): void {
+		const window = this[PropertySymbol.window];
+
+		if (this.#loadTimeout) {
+			window.clearTimeout(this.#loadTimeout);
+		}
+
+		if (this.#parseTimeout) {
+			window.clearTimeout(this.#parseTimeout);
+		}
+
+		if (
+			this.readyState === FileReaderReadyStateEnum.empty ||
+			this.readyState === FileReaderReadyStateEnum.done
+		) {
+			(<Buffer | ArrayBuffer | string | null>this.result) = null;
+			return;
+		}
+
+		if (this.readyState === FileReaderReadyStateEnum.loading) {
+			(<number>this.readyState) = FileReaderReadyStateEnum.done;
+			(<Buffer | ArrayBuffer | string | null>this.result) = null;
+		}
+
+		this.#isTerminated = true;
+		this.dispatchEvent(new ProgressEvent(FileReaderEventTypeEnum.abort));
+		this.dispatchEvent(new ProgressEvent(FileReaderEventTypeEnum.loadend));
+	}
+
+	/**
+	 * Reads a file.
+	 *
+	 * @param blob Blob.
+	 * @param format Format.
+	 * @param [encoding] Encoding.
+	 */
+	#readFile(blob: Blob, format: FileReaderFormatEnum, encoding: string | null = null): void {
+		const window = this[PropertySymbol.window];
+
+		if (this.readyState === FileReaderReadyStateEnum.loading) {
+			throw new window.DOMException(
+				'The object is in an invalid state.',
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+
+		(<number>this.readyState) = FileReaderReadyStateEnum.loading;
+
+		this.#loadTimeout = window.setTimeout(() => {
+			if (this.#isTerminated) {
+				this.#isTerminated = false;
+				return;
+			}
+
+			this.dispatchEvent(new ProgressEvent(FileReaderEventTypeEnum.loadstart));
+
+			let data = blob[PropertySymbol.buffer];
+			if (!data) {
+				data = Buffer.alloc(0);
+			}
+
+			this.dispatchEvent(
+				new ProgressEvent(FileReaderEventTypeEnum.loadstart, {
+					lengthComputable: !isNaN(blob.size),
+					total: blob.size,
+					loaded: data.length
+				})
+			);
+
+			this.#parseTimeout = window.setTimeout(() => {
+				if (this.#isTerminated) {
+					this.#isTerminated = false;
+					return;
+				}
+
+				switch (format) {
+					default:
+					case FileReaderFormatEnum.buffer: {
+						(<Buffer | ArrayBuffer | string>this.result) = new Uint8Array(data).buffer;
+						break;
+					}
+					case FileReaderFormatEnum.binaryString: {
+						(<Buffer | ArrayBuffer | string>this.result) = data.toString('binary');
+						break;
+					}
+					case FileReaderFormatEnum.dataURL: {
+						// Spec seems very unclear here; see https://github.com/w3c/FileAPI/issues/104.
+						const contentType = WhatwgMIMEType.parse(blob.type) || 'application/octet-stream';
+						(<Buffer | ArrayBuffer | string>this.result) =
+							`data:${contentType};base64,${data.toString('base64')}`;
+						break;
+					}
+					case FileReaderFormatEnum.text: {
+						(<Buffer | ArrayBuffer | string>this.result) = new TextDecoder(
+							encoding || 'UTF-8'
+						).decode(data);
+						break;
+					}
+				}
+				(<number>this.readyState) = FileReaderReadyStateEnum.done;
+				this.dispatchEvent(new ProgressEvent(FileReaderEventTypeEnum.load));
+				this.dispatchEvent(new ProgressEvent(FileReaderEventTypeEnum.loadend));
+			});
+		});
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/file/FileReaderEventTypeEnum.ts

@@ -0,0 +1,9 @@
+enum FileReaderEventTypeEnum {
+	abort = 'abort',
+	error = 'error',
+	load = 'load',
+	loadstart = 'loadstart',
+	loadend = 'loadend',
+	progress = 'progress'
+}
+export default FileReaderEventTypeEnum;

package/vendor/happy-dom/packages/happy-dom/src/file/FileReaderFormatEnum.ts

@@ -0,0 +1,7 @@
+enum FileReaderFormatEnum {
+	buffer = 'buffer',
+	binaryString = 'binaryString',
+	dataURL = 'dataURL',
+	text = 'text'
+}
+export default FileReaderFormatEnum;

package/vendor/happy-dom/packages/happy-dom/src/file/FileReaderReadyStateEnum.ts

@@ -0,0 +1,6 @@
+enum FileReaderReadyStateEnum {
+	empty = 0,
+	loading = 1,
+	done = 2
+}
+export default FileReaderReadyStateEnum;