mphttpx 2.3.0 → 2.4.0

package/dist/esm/fetch-api/RequestP.js

@@ -1,160 +0,0 @@
-import { HeadersP } from './HeadersP.js';
-import { BodyImpl, Body_init } from './BodyImpl.js';
-import { Payload } from '../helpers/Payload.js';
-import { isEventTarget } from '../helpers/isEventTarget.js';
-import { normalizeMethod } from '../helpers/normalizeMethod.js';
-import { createAbortSignal } from '../event-system/AbortSignalP.js';
-import { checkArgsLength, setState, SymbolP, isPolyfillType } from '../utils.js';
-
-class RequestP extends BodyImpl {
-    constructor(input, init) {
-        checkArgsLength(arguments.length, 1, "Request");
-        super();
-        setState(this, "__Request__", new RequestState());
-        const s = state(this);
-        let _init = init !== null && init !== void 0 ? init : {};
-        if (typeof _init !== "object") {
-            throw new TypeError("Failed to construct 'Request': The provided value is not of type 'RequestInit'.");
-        }
-        let body = _init.body;
-        let bodyInited = false;
-        if (isRequest(input)) {
-            if (input.bodyUsed) {
-                throw new TypeError("Failed to construct 'Request': Cannot construct a Request with a Request object that has already been used.");
-            }
-            s.cache = input.cache;
-            s.credentials = input.credentials;
-            if (_init.headers === undefined) {
-                state(this).headers = new HeadersP(input.headers);
-            }
-            s.method = input.method;
-            s.mode = input.mode;
-            s.signal = input.signal;
-            s.url = input.url;
-            if (!body) {
-                this.__Body__.payload = createPhonyPayload(input.arrayBuffer());
-                bodyInited = true;
-            }
-        }
-        else {
-            s.url = "" + input;
-        }
-        if (_init.cache) {
-            s.cache = _init.cache;
-        }
-        if (_init.credentials) {
-            s.credentials = _init.credentials;
-        }
-        if (_init.headers !== undefined) {
-            state(this).headers = new HeadersP(_init.headers);
-        }
-        if (_init.method) {
-            s.method = normalizeMethod(_init.method);
-        }
-        if (_init.mode) {
-            s.mode = _init.mode;
-        }
-        if (_init.signal !== null && _init.signal !== undefined) {
-            if (isEventTarget(_init.signal))
-                s.signal = _init.signal;
-            else
-                throw new TypeError("Failed to construct 'Request': Failed to read the 'signal' property from 'RequestInit': Failed to convert value to 'AbortSignal'.");
-        }
-        if (this.method === "GET" || this.method === "HEAD") {
-            if (body !== null && body !== undefined) {
-                throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
-            }
-        }
-        Body_init(this, bodyInited ? null : body);
-        let payload = this.__Body__.payload;
-        if (!this.headers.has("Content-Type") && payload && payload.type) {
-            this.headers.set("Content-Type", payload.type);
-        }
-        if (this.method === "GET" || this.method === "HEAD") {
-            if (this.cache === "no-cache" || this.cache === "no-store") {
-                clearCache(this);
-            }
-        }
-    }
-    get cache() { return state(this).cache; }
-    get credentials() { return state(this).credentials; }
-    get destination() { return ""; }
-    get headers() {
-        if (!state(this).headers) {
-            state(this).headers = new HeadersP();
-        }
-        return state(this).headers;
-    }
-    get integrity() { return ""; }
-    get keepalive() { return false; }
-    get method() { return state(this).method; }
-    get mode() { return state(this).mode; }
-    get redirect() { return "follow"; }
-    get referrer() { return state(this).referrer; }
-    get referrerPolicy() { return ""; }
-    get signal() {
-        if (!state(this).signal) {
-            state(this).signal = createAbortSignal();
-        }
-        return state(this).signal;
-    }
-    get url() { return state(this).url; }
-    clone() {
-        if (!this.bodyUsed) {
-            let req = new RequestP(this);
-            this.__Body__.bodyUsed = false;
-            return req;
-        }
-        else {
-            throw new TypeError("Failed to execute 'clone' on 'Request': Request body is already used");
-        }
-    }
-    /** @internal */ toString() { return "[object Request]"; }
-    /** @internal */ get [SymbolP.toStringTag]() { return "Request"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["Request", "Body"] }; }
-}
-/** @internal */
-class RequestState {
-    constructor() {
-        this.cache = "default";
-        this.credentials = "same-origin";
-        this.method = "GET";
-        this.mode = "cors";
-        this.referrer = "about:client";
-        this.url = "";
-    }
-}
-function state(target) {
-    return target.__Request__;
-}
-function isRequest(value) {
-    return isPolyfillType("Request", value) || isExternalRequest(value);
-}
-function isExternalRequest(value) {
-    let expect = "[object Request]";
-    return (Object.prototype.toString.call(value) === expect || String(value) === expect)
-        && "arrayBuffer" in value
-        && typeof value.arrayBuffer === "function";
-}
-function createPhonyPayload(promise) {
-    let payload = Object.create(Payload.prototype);
-    payload.promise = promise;
-    payload.type = "";
-    return payload;
-}
-function clearCache(req) {
-    // Search for a '_' parameter in the query string
-    let reParamSearch = /([?&])_=[^&]*/;
-    if (reParamSearch.test(req.url)) {
-        // If it already exists then set the value with the current time
-        state(req).url = req.url.replace(reParamSearch, "$1_=" + (new Date()).getTime());
-    }
-    else {
-        // Otherwise add a new '_' parameter to the end with the current time
-        let reQueryString = /\?/;
-        state(req).url += (reQueryString.test(req.url) ? "&" : "?") + "_=" + (new Date()).getTime();
-    }
-}
-const RequestE = (typeof Request !== "undefined" && Request) || RequestP;
-
-export { RequestE as Request, RequestP };

package/dist/esm/fetch-api/ResponseP.js

@@ -1,90 +0,0 @@
-import { HeadersP } from './HeadersP.js';
-import { BodyImpl, Body_init } from './BodyImpl.js';
-import { checkArgsLength, setState, SymbolP } from '../utils.js';
-
-class ResponseP extends BodyImpl {
-    static json(data, init) {
-        checkArgsLength(arguments.length, 1, "Response", "json");
-        let response = new ResponseP(typeof data === "string" ? data : JSON.stringify(data), init);
-        response.headers.set("Content-Type", "application/json");
-        return response;
-    }
-    static error() {
-        let response = new ResponseP(null, { status: 200, statusText: "" });
-        state(response).status = 0;
-        state(response).type = "error";
-        return response;
-    }
-    static redirect(url, status = 302) {
-        checkArgsLength(arguments.length, 1, "Response", "redirect");
-        if ([301, 302, 303, 307, 308].indexOf(status) === -1) {
-            throw new RangeError("Failed to execute 'redirect' on 'Response': Invalid status code");
-        }
-        return new ResponseP(null, { status, headers: { location: "" + url } });
-    }
-    constructor(body, init) {
-        super();
-        setState(this, "__Response__", new ResponseState());
-        const s = state(this);
-        let _init = init !== null && init !== void 0 ? init : {};
-        if (typeof _init !== "object") {
-            throw new TypeError("Failed to construct 'Response': The provided value is not of type 'ResponseInit'.");
-        }
-        if (_init.headers !== undefined) {
-            state(this).headers = new HeadersP(_init.headers);
-        }
-        let status = _init.status === undefined ? 200 : _init.status;
-        if (status < 200 || status > 599)
-            throw new RangeError(`Failed to construct 'Response': The status provided (${+status}) is outside the range [200, 599].`);
-        s.status = status;
-        s.statusText = _init.statusText === undefined ? "" : "" + _init.statusText;
-        Body_init(this, body);
-        let payload = this.__Body__.payload;
-        if (!this.headers.has("Content-Type") && payload && payload.type) {
-            this.headers.set("Content-Type", payload.type);
-        }
-    }
-    get headers() {
-        if (!state(this).headers) {
-            state(this).headers = new HeadersP();
-        }
-        return state(this).headers;
-    }
-    get ok() { return this.status >= 200 && this.status < 300; }
-    get redirected() { return false; }
-    get status() { return state(this).status; }
-    get statusText() { return state(this).statusText; }
-    get type() { return state(this).type; }
-    get url() { return state(this).url; }
-    clone() {
-        if (this.bodyUsed) {
-            throw new TypeError("Failed to execute 'clone' on 'Response': Response body is already used");
-        }
-        let response = new ResponseP(null, {
-            headers: new HeadersP(this.headers),
-            status: this.status,
-            statusText: this.statusText,
-        });
-        state(response).url = this.url;
-        response.__Body__.payload = this.__Body__.payload;
-        return response;
-    }
-    /** @internal */ toString() { return "[object Response]"; }
-    /** @internal */ get [SymbolP.toStringTag]() { return "Response"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["Response", "Body"] }; }
-}
-/** @internal */
-class ResponseState {
-    constructor() {
-        this.status = 200;
-        this.statusText = "";
-        this.type = "default";
-        this.url = "";
-    }
-}
-function state(target) {
-    return target.__Response__;
-}
-const ResponseE = (typeof Response !== "undefined" && Response) || ResponseP;
-
-export { ResponseE as Response, ResponseP };

package/dist/esm/fetch-api/fetchP.js

@@ -1,121 +0,0 @@
-import { RequestP } from './RequestP.js';
-import { ResponseP } from './ResponseP.js';
-import { checkArgsLength, DOMExceptionP } from '../utils.js';
-import { XMLHttpRequest as XMLHttpRequestE } from '../mini-program/XMLHttpRequestImpl.js';
-import { isHeaders, normalizeName, normalizeValue, HeadersP } from './HeadersP.js';
-
-const mp = { XMLHttpRequest: XMLHttpRequestE };
-function setXMLHttpRequest(XHR) { mp.XMLHttpRequest = XHR; }
-function fetchP(input, init) {
-    checkArgsLength(arguments.length, 1, "Window", "fetch");
-    if (new.target === fetchP) {
-        throw new TypeError("fetch is not a constructor");
-    }
-    return new Promise((resolve, reject) => {
-        const request = new RequestP(input, init);
-        const signal = request.__Request__.signal;
-        if (signal && signal.aborted) {
-            return reject(signal.reason);
-        }
-        let xhr = new mp.XMLHttpRequest();
-        let aborted = false;
-        let payload = request.__Body__.payload;
-        xhr.onload = () => {
-            let options = {
-                headers: parseHeaders(xhr.getAllResponseHeaders() || ""),
-                status: xhr.status,
-                statusText: xhr.statusText,
-            };
-            // This check if specifically for when a user fetches a file locally from the file system
-            // Only if the status is out of a normal range
-            if (request.url.indexOf("file://") === 0 && (xhr.status < 200 || xhr.status > 599)) {
-                options.status = 200;
-            }
-            setTimeout(() => {
-                const response = new ResponseP("response" in xhr ? xhr.response : xhr.responseText, options);
-                response.__Response__.url = "responseURL" in xhr ? xhr.responseURL : (options.headers.get("X-Request-URL") || "");
-                const _payload = response.__Body__.payload;
-                const _contentType = response.headers.get("Content-Type") || "";
-                if (_payload && _contentType) {
-                    _payload.type = _contentType;
-                }
-                resolve(response);
-            });
-        };
-        xhr.onerror = () => { setTimeout(() => { reject(new TypeError("Failed to fetch")); }); };
-        xhr.ontimeout = () => { setTimeout(() => { reject(new DOMExceptionP("request:fail timeout", "TimeoutError")); }); };
-        xhr.onabort = () => { setTimeout(() => { reject(new DOMExceptionP("The user aborted a request.", "AbortError")); }); };
-        xhr.open(request.method, request.url, true);
-        if (request.credentials === "include") {
-            xhr.withCredentials = true;
-        }
-        else if (request.credentials === "omit") {
-            xhr.withCredentials = false;
-        }
-        if ("responseType" in xhr) {
-            xhr.responseType = "arraybuffer";
-        }
-        if (init && typeof init === "object" && init.headers && typeof init.headers === "object" && !isHeaders(init.headers)) {
-            let headers = init.headers;
-            let names = [];
-            Object.getOwnPropertyNames(headers).forEach(name => {
-                names.push(normalizeName(name));
-                xhr.setRequestHeader(name, normalizeValue(headers[name]));
-            });
-            request.headers.forEach((value, name) => {
-                if (names.indexOf(name) === -1) {
-                    xhr.setRequestHeader(name, value);
-                }
-            });
-        }
-        else {
-            request.headers.forEach((value, name) => {
-                xhr.setRequestHeader(name, value);
-            });
-        }
-        if (signal) {
-            const abortFn = () => { aborted = true; xhr.abort(); removeFn(); };
-            const removeFn = () => { signal.removeEventListener("abort", abortFn); };
-            signal.addEventListener("abort", abortFn);
-            xhr.onreadystatechange = () => { if (xhr.readyState === 4)
-                removeFn(); };
-        }
-        if (!payload)
-            xhr.send();
-        else
-            payload.promise.then(body => {
-                if (!aborted)
-                    xhr.send(body !== "" ? body : undefined);
-                else
-                    reject(new DOMExceptionP("The user aborted a request.", "AbortError"));
-            })
-                .catch(e => {
-                console.error(e);
-                reject(new TypeError("Failed to fetch"));
-            });
-    });
-}
-function parseHeaders(rawHeaders) {
-    let headers = new HeadersP();
-    let preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
-    preProcessedHeaders
-        .split("\r")
-        .map(header => header.indexOf("\n") === 0 ? header.substring(1, header.length) : header)
-        .forEach(line => {
-        let parts = line.split(":");
-        let name = parts.shift().trim();
-        if (name) {
-            let value = parts.join(":").trim();
-            try {
-                headers.append(name, value);
-            }
-            catch (e) {
-                console.warn(`SyntaxError: Response.headers: '${name}' is not a valid HTTP header field name.`);
-            }
-        }
-    });
-    return headers;
-}
-const fetchE = (typeof fetch !== "undefined" && fetch) || fetchP;
-
-export { fetchE as fetch, fetchP, setXMLHttpRequest };

package/dist/esm/file-system/BlobP.js

@@ -1,108 +0,0 @@
-import { encode } from '../helpers/encode.js';
-import { decode } from '../helpers/decode.js';
-import { setState, className, SymbolP } from '../utils.js';
-import { isBlob } from '../helpers/isBlob.js';
-import { isSequence } from '../helpers/isSequence.js';
-import { isArrayBuffer } from '../helpers/isArrayBuffer.js';
-
-class BlobP {
-    constructor(blobParts = [], options) {
-        if (!isSequence(blobParts)) {
-            throw new TypeError(`Failed to construct 'Blob/File': The provided value cannot be converted to a sequence.`);
-        }
-        let _blobParts = Array.isArray(blobParts) ? blobParts : Array.from(blobParts);
-        let tasks = [];
-        let size = 0;
-        for (let i = 0; i < _blobParts.length; ++i) {
-            let chunk = _blobParts[i];
-            if (isBlob(chunk)) {
-                size += chunk.size;
-                tasks.push(chunk.arrayBuffer().then(r => new Uint8Array(r)));
-            }
-            else {
-                let bytes = (isArrayBuffer(chunk) || ArrayBuffer.isView(chunk))
-                    ? BufferSource_toUint8Array(chunk)
-                    : encode(chunk);
-                size += bytes.length;
-                tasks.push(Promise.resolve(bytes));
-            }
-        }
-        setState(this, "__Blob__", new BlobState(Promise.all(tasks).then(chunks => concat(chunks))));
-        state(this).size = size;
-        state(this).type = normalizeType(options === null || options === void 0 ? void 0 : options.type);
-    }
-    get size() { return state(this).size; }
-    get type() { return state(this).type; }
-    arrayBuffer() {
-        return state(this).promise.then(r => clone(r.buffer).buffer);
-    }
-    bytes() {
-        return state(this).promise.then(r => clone(r.buffer));
-    }
-    slice(start, end, contentType) {
-        let _start = start !== null && start !== void 0 ? start : 0, _end = end !== null && end !== void 0 ? end : this.size;
-        let blob = Object.create(BlobP.prototype);
-        setState(blob, "__Blob__", new BlobState(state(this).promise.then(r => clone(r.slice(_start, _end)))));
-        state(blob).size = calcSlicedSize(this.size, _start, _end);
-        state(blob).type = normalizeType(contentType);
-        return blob;
-    }
-    stream() {
-        throw new TypeError(`Failed to execute 'stream' on '${className(this)}': method not implemented.`);
-    }
-    text() {
-        return state(this).promise.then(r => decode(r));
-    }
-    /** @internal */ toString() { return "[object Blob]"; }
-    /** @internal */ get [SymbolP.toStringTag]() { return "Blob"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["Blob"] }; }
-}
-class BlobState {
-    constructor(promise) {
-        this.size = 0;
-        this.type = "";
-        this.promise = promise;
-    }
-}
-function state(target) {
-    return target.__Blob__;
-}
-function BufferSource_toUint8Array(buf) {
-    return isArrayBuffer(buf)
-        ? new Uint8Array(buf)
-        : new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-}
-function normalizeType(type) {
-    let rawType = "" + (type !== undefined ? type : "");
-    return /[^\u0020-\u007E]/.test(rawType) ? "" : rawType.toLowerCase();
-}
-function clone(buf) {
-    let sourceArray = BufferSource_toUint8Array(buf);
-    let cloneArray = new Uint8Array(new ArrayBuffer(sourceArray.byteLength));
-    cloneArray.set(sourceArray);
-    return cloneArray;
-}
-function concat(chunks) {
-    let totalByteLength = chunks.reduce((acc, cur) => acc + cur.byteLength, 0);
-    let result = new Uint8Array(totalByteLength);
-    chunks.reduce((offset, chunk) => { result.set(chunk, offset); return offset + chunk.byteLength; }, 0);
-    return result;
-}
-function calcSlicedSize(size, start, end) {
-    const normalizeNumer = (n) => {
-        let num = Number(n);
-        if (isNaN(num))
-            num = 0;
-        if (num >= 0) {
-            num = Math.min(num, size);
-        }
-        else {
-            num = Math.max(0, num + size);
-        }
-        return num;
-    };
-    return Math.max(0, normalizeNumer(end) - normalizeNumer(start));
-}
-const BlobE = (typeof Blob !== "undefined" && Blob) || BlobP;
-
-export { BlobE as Blob, BlobP };

package/dist/esm/file-system/FileP.js

@@ -1,31 +0,0 @@
-import { BlobP } from './BlobP.js';
-import { checkArgsLength, setState, SymbolP } from '../utils.js';
-
-class FileP extends BlobP {
-    constructor(fileBits, fileName, options) {
-        checkArgsLength(arguments.length, 2, "File");
-        super(fileBits, options);
-        setState(this, "__File__", new FileState());
-        state(this).lastModified = +((options === null || options === void 0 ? void 0 : options.lastModified) ? new Date(options.lastModified) : new Date()) || 0;
-        state(this).name = "" + fileName;
-    }
-    get lastModified() { return state(this).lastModified; }
-    get name() { return state(this).name; }
-    get webkitRelativePath() { return ""; }
-    /** @internal */ toString() { return "[object File]"; }
-    /** @internal */ get [SymbolP.toStringTag]() { return "File"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["File", "Blob"] }; }
-}
-/** @internal */
-class FileState {
-    constructor() {
-        this.lastModified = 0;
-        this.name = "";
-    }
-}
-function state(target) {
-    return target.__File__;
-}
-const FileE = (typeof File !== "undefined" && File) || FileP;
-
-export { FileE as File, FileP };

package/dist/esm/file-system/FileReaderP.js

@@ -1,170 +0,0 @@
-import { isBlob } from '../helpers/isBlob.js';
-import { attachFn, executeFn } from '../helpers/handlers.js';
-import { Uint8Array_toBase64 } from '../helpers/toBase64.js';
-import { EventTargetP } from '../event-system/EventTargetP.js';
-import { emitProgressEvent } from '../helpers/emitProgressEvent.js';
-import { setState, SymbolP, DOMExceptionP, checkArgsLength } from '../utils.js';
-
-class FileReaderP extends EventTargetP {
-    static get EMPTY() { return 0; }
-    static get LOADING() { return 1; }
-    static get DONE() { return 2; }
-    constructor() {
-        super();
-        setState(this, "__FileReader__", new FileReaderState(this));
-    }
-    get EMPTY() { return 0; }
-    get LOADING() { return 1; }
-    get DONE() { return 2; }
-    get error() { return state(this).error; }
-    get readyState() { return state(this).readyState; }
-    get result() { return state(this).result; }
-    abort() {
-        if (state(this).pos === 2 /* FRCycle.LOADING */)
-            execAbort(this);
-    }
-    readAsArrayBuffer(blob) {
-        check(this, "readAsArrayBuffer", arguments.length, blob);
-        read(this, blob.size, () => blob.arrayBuffer());
-    }
-    readAsBinaryString(blob) {
-        check(this, "readAsBinaryString", arguments.length, blob);
-        read(this, blob.size, () => blob.arrayBuffer().then(res => {
-            let str = [];
-            let buf = new Uint8Array(res);
-            for (let i = 0; i < buf.length; ++i) {
-                str.push(String.fromCharCode(buf[i]));
-            }
-            return str.join("");
-        }));
-    }
-    readAsDataURL(blob) {
-        check(this, "readAsDataURL", arguments.length, blob);
-        read(this, blob.size, () => blob.arrayBuffer().then(res => {
-            return "data:" + (blob.type || "application/octet-stream") + ";base64," + Uint8Array_toBase64(new Uint8Array(res));
-        }));
-    }
-    readAsText(blob, encoding) {
-        check(this, "readAsText", arguments.length, blob);
-        if (encoding !== undefined) {
-            let _encoding = "" + encoding;
-            if (["utf-8", "utf8", "unicode-1-1-utf-8"].indexOf(_encoding.toLowerCase()) === -1) {
-                console.warn(`Ignoring the execution of 'readAsText' on 'FileReader': encoding ('${_encoding}') not implemented.`);
-            }
-        }
-        read(this, blob.size, () => blob.text());
-    }
-    get onabort() { return state(this).onabort; }
-    set onabort(value) { state(this).onabort = value; state(this).attach("abort"); }
-    get onerror() { return state(this).onerror; }
-    set onerror(value) { state(this).onerror = value; state(this).attach("error"); }
-    get onload() { return state(this).onload; }
-    set onload(value) { state(this).onload = value; state(this).attach("load"); }
-    get onloadend() { return state(this).onloadend; }
-    set onloadend(value) { state(this).onloadend = value; state(this).attach("loadend"); }
-    get onloadstart() { return state(this).onloadstart; }
-    set onloadstart(value) { state(this).onloadstart = value; state(this).attach("loadstart"); }
-    get onprogress() { return state(this).onprogress; }
-    set onprogress(value) { state(this).onprogress = value; state(this).attach("progress"); }
-    /** @internal */ toString() { return "[object FileReader]"; }
-    /** @internal */ get [SymbolP.toStringTag]() { return "FileReader"; }
-    /** @internal */ get __MPHTTPX__() { return { chain: ["FileReader", "EventTarget"] }; }
-}
-/** @internal */
-class FileReaderState {
-    constructor(target) {
-        this.pos = 0 /* FRCycle.EMPTY */;
-        this.readyState = 0 /* EMPTY */;
-        this.result = null;
-        this.error = null;
-        this.onabort = null;
-        this.onerror = null;
-        this.onload = null;
-        this.onloadend = null;
-        this.onloadstart = null;
-        this.onprogress = null;
-        this.attach = attachFn(target, getHandlers(target));
-    }
-}
-function getHandlers(t) {
-    return {
-        onabort: (ev) => { executeFn(t, t.onabort, ev); },
-        onerror: (ev) => { executeFn(t, t.onerror, ev); },
-        onload: (ev) => { executeFn(t, t.onload, ev); },
-        onloadend: (ev) => { executeFn(t, t.onloadend, ev); },
-        onloadstart: (ev) => { executeFn(t, t.onloadstart, ev); },
-        onprogress: (ev) => { executeFn(t, t.onprogress, ev); },
-    };
-}
-function state(target) {
-    return target.__FileReader__;
-}
-function check(reader, kind, actual, blob) {
-    checkArgsLength(actual, 1, "FileReader", kind);
-    if (!isBlob(blob))
-        throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
-    if (reader.readyState === 1 /* LOADING */)
-        throw new DOMExceptionP(`Failed to execute '${kind}' on 'FileReader': The object is already busy reading Blobs.`, "InvalidStateError");
-}
-function read(reader, size, launch) {
-    execLoadstart(reader, size, launch);
-}
-function execLoadstart(reader, size, launch) {
-    let s = state(reader);
-    s.pos = 1 /* FRCycle.LOADSTART */;
-    s.error = null;
-    s.result = null;
-    const callback = () => { emitProgressEvent(reader, "loadstart", 0, size); return launch(); };
-    return execLoading(reader, size, callback);
-}
-function execLoading(reader, size, launch) {
-    let s = state(reader);
-    s.pos = 2 /* FRCycle.LOADING */;
-    s.readyState = 1 /* LOADING */;
-    return Promise.resolve().then(() => {
-        if (s.pos !== 2 /* FRCycle.LOADING */)
-            return;
-        return launch().then(r => execDone(reader, size, r)).catch(err => execError(reader, err));
-    });
-}
-function execDone(reader, size, result) {
-    let s = state(reader);
-    if (s.pos !== 2 /* FRCycle.LOADING */)
-        return;
-    s.pos = 3 /* FRCycle.DONE */;
-    s.result = result;
-    s.readyState = 2; /* DONE */
-    execLoad(reader, size);
-}
-function execLoad(reader, size) {
-    state(reader).pos = 4 /* FRCycle.LOAD */;
-    emitProgressEvent(reader, "load", size, size);
-    execLoadend(reader, size);
-}
-function execAbort(reader) {
-    let s = state(reader);
-    s.pos = 5 /* FRCycle.ABORT */;
-    s.error = new DOMExceptionP("An ongoing operation was aborted, typically with a call to abort().", "AbortError");
-    s.result = null;
-    s.readyState = 2 /* DONE */;
-    emitProgressEvent(reader, "abort");
-    execLoadend(reader);
-}
-function execError(reader, err) {
-    let s = state(reader);
-    if (s.pos !== 2 /* FRCycle.LOADING */)
-        return;
-    s.pos = 6 /* FRCycle.ERROR */;
-    s.error = err;
-    s.result = null;
-    s.readyState = 2 /* DONE */;
-    emitProgressEvent(reader, "error");
-    execLoadend(reader);
-}
-function execLoadend(reader, size = 0) {
-    state(reader).pos = 7 /* FRCycle.LOADEND */;
-    emitProgressEvent(reader, "loadend", size, size);
-}
-const FileReaderE = (typeof FileReader !== "undefined" && FileReader) || FileReaderP;
-
-export { FileReaderE as FileReader, FileReaderP };