mphttpx 1.1.0 → 1.2.0-beta.2

package/dist/esm/FileReaderP.js

@@ -0,0 +1,148 @@
+import { EventTargetP, attachFn, executeFn } from './EventTargetP.js';
+import { emitProcessEvent } from './ProgressEventP.js';
+import { Blob_toUint8Array, Uint8Array_toBase64, decode } from './BlobP.js';
+import { g, MPException, polyfill, checkArgsLength, isPolyfillType } from './isPolyfill.js';
+import './EventP.js';
+import './TextEncoderP.js';
+import './TextDecoderP.js';
+
+var _a;
+/** @internal */
+const state = Symbol( /* "FileReaderState" */);
+class FileReaderP extends EventTargetP {
+    static get EMPTY() { return 0; }
+    static get LOADING() { return 1; }
+    static get DONE() { return 2; }
+    constructor() {
+        super();
+        this[state] = new FileReaderState(this);
+    }
+    get readyState() { return this[state].readyState; }
+    get result() { return this[state].result; }
+    get EMPTY() { return 0; }
+    get LOADING() { return 1; }
+    get DONE() { return 2; }
+    get error() { return this[state].error; }
+    abort() {
+        if (this.readyState === 1 /* LOADING */) {
+            const s = this[state];
+            s.readyState = 2 /* DONE */;
+            s.result = null;
+            s.error = new MPException("An ongoing operation was aborted, typically with a call to abort().", "AbortError");
+            emitProcessEvent(this, "abort");
+        }
+    }
+    readAsArrayBuffer(...args) {
+        read(this, "readAsArrayBuffer", args, blob => {
+            this[state].result = Blob_toUint8Array(blob).buffer.slice(0);
+        });
+    }
+    readAsBinaryString(...args) {
+        read(this, "readAsBinaryString", args, blob => {
+            let str = [];
+            let buf = Blob_toUint8Array(blob);
+            for (let i = 0; i < buf.length; ++i) {
+                let char = buf[i];
+                str.push(String.fromCharCode(char));
+            }
+            this[state].result = str.join("");
+        });
+    }
+    readAsDataURL(...args) {
+        read(this, "readAsDataURL", args, blob => {
+            this[state].result = "data:" + (blob.type || "application/octet-stream") + ";base64," + Uint8Array_toBase64(Blob_toUint8Array(blob));
+        });
+    }
+    readAsText(...args) {
+        const encoding = args.length > 1 ? args[1] : undefined;
+        read(this, "readAsText", args, blob => {
+            if (encoding !== undefined) {
+                let _encoding = "" + encoding;
+                if (["utf-8", "utf8", "unicode-1-1-utf-8"].indexOf(_encoding.toLowerCase()) === -1) {
+                    console.error(`TypeError: Failed to execute 'readAsText' on 'FileReader': encoding ('${_encoding}') not implemented.`);
+                }
+            }
+            this[state].result = decode(Blob_toUint8Array(blob));
+        });
+    }
+    get onabort() { return this[state].onabort; }
+    set onabort(value) { this[state].onabort = value; attach(this, "abort"); }
+    get onerror() { return this[state].onerror; }
+    set onerror(value) { this[state].onerror = value; attach(this, "error"); }
+    get onload() { return this[state].onload; }
+    set onload(value) { this[state].onload = value; attach(this, "load"); }
+    get onloadend() { return this[state].onloadend; }
+    set onloadend(value) { this[state].onloadend = value; attach(this, "loadend"); }
+    get onloadstart() { return this[state].onloadstart; }
+    set onloadstart(value) { this[state].onloadstart = value; attach(this, "loadstart"); }
+    get onprogress() { return this[state].onprogress; }
+    set onprogress(value) { this[state].onprogress = value; attach(this, "progress"); }
+    /** @internal */ toString() { return "[object FileReader]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "FileReader"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["FileReader", "EventTarget"] }; }
+}
+/** @internal */
+const _handlers = Symbol();
+/** @internal */
+class FileReaderState {
+    constructor(target) {
+        this.readyState = 0 /* EMPTY */;
+        this.result = null;
+        this.error = null;
+        this[_a] = getHandlers(this);
+        this.onabort = null;
+        this.onerror = null;
+        this.onload = null;
+        this.onloadend = null;
+        this.onloadstart = null;
+        this.onprogress = null;
+        this.target = target;
+    }
+}
+_a = _handlers;
+function read(reader, kind, args, setResult) {
+    const [blob] = args;
+    checkArgsLength(args, 1, "FileReader", kind);
+    if (!isPolyfillType("Blob", blob)) {
+        throw new TypeError("Failed to execute '" + kind + "' on 'FileReader': parameter 1 is not of type 'Blob'.");
+    }
+    const s = reader[state];
+    s.error = null;
+    s.readyState = 1 /* LOADING */;
+    emitProcessEvent(s.target, "loadstart", 0, blob.size);
+    setTimeout(() => {
+        if (s.readyState === 1 /* LOADING */) {
+            s.readyState = 2 /* DONE */;
+            try {
+                setResult(blob);
+                emitProcessEvent(s.target, "load", blob.size, blob.size);
+            }
+            catch (e) {
+                s.result = null;
+                s.error = e;
+                emitProcessEvent(s.target, "error", 0, blob.size);
+            }
+        }
+        emitProcessEvent(s.target, "loadend", !!s.result ? blob.size : 0, blob.size);
+    });
+}
+function attach(reader, type) {
+    const s = reader[state];
+    const fnName = ("on" + type);
+    const cb = s[fnName];
+    const listener = s[_handlers][fnName];
+    attachFn(reader, type, cb, listener);
+}
+function getHandlers(s) {
+    return {
+        onabort: (ev) => { executeFn(s.target, s.onabort, ev); },
+        onerror: (ev) => { executeFn(s.target, s.onerror, ev); },
+        onload: (ev) => { executeFn(s.target, s.onload, ev); },
+        onloadend: (ev) => { executeFn(s.target, s.onloadend, ev); },
+        onloadstart: (ev) => { executeFn(s.target, s.onloadstart, ev); },
+        onprogress: (ev) => { executeFn(s.target, s.onprogress, ev); },
+    };
+}
+const FileReaderE = g["Blob"] ? g["FileReader"] : FileReaderP;
+
+export { FileReaderE as FileReader, FileReaderP };

package/dist/esm/FormDataP.js

@@ -0,0 +1,245 @@
+import { BlobP } from './BlobP.js';
+import { FileP } from './FileP.js';
+import { g, polyfill, checkArgsLength, isPolyfillType, isObjectType } from './isPolyfill.js';
+import './TextEncoderP.js';
+import './TextDecoderP.js';
+
+var _a;
+/** @internal */ const state = Symbol( /* "FormDataState" */);
+const checkArgsFn = (args, required, funcName) => { checkArgsLength(args, required, "FormData", funcName); };
+class FormDataP {
+    constructor(form, submitter) {
+        if (submitter === undefined) {
+            if (form !== undefined) {
+                console.error("TypeError: Failed to construct 'FormData': parameter 1 not implemented.");
+            }
+        }
+        else {
+            if (submitter !== null) {
+                console.error("TypeError: Failed to construct 'FormData': parameter 1 and parameter 2 not implemented.");
+            }
+        }
+        this[state] = new FormDataState();
+    }
+    append(...args) {
+        const [name, value, filename] = args;
+        checkArgsFn(args, 2, "append");
+        this[state][_formData].push(normalizeArgs(name, value, filename));
+    }
+    delete(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "delete");
+        let _name = "" + name;
+        let index = -1;
+        let array = this[state][_formData];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                index = i;
+                continue;
+            }
+            result.push(item);
+        }
+        if (index > -1) {
+            this[state][_formData] = result;
+        }
+    }
+    get(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "get");
+        let _name = "" + name;
+        let array = this[state][_formData];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                return item[1];
+            }
+        }
+        return null;
+    }
+    getAll(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "getAll");
+        let _name = "" + name;
+        let array = this[state][_formData];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                result.push(item[1]);
+            }
+        }
+        return result;
+    }
+    has(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "has");
+        let _name = "" + name;
+        let array = this[state][_formData];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    set(...args) {
+        const [name, value, filename] = args;
+        checkArgsFn(args, 2, "set");
+        let _name = "" + name;
+        let _args = normalizeArgs(name, value, filename);
+        let index = -1;
+        let array = this[state][_formData];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (index === -1) {
+                    index = i;
+                    result.push(_args);
+                }
+                continue;
+            }
+            result.push(item);
+        }
+        if (index === -1) {
+            result.push(_args);
+        }
+        this[state][_formData] = result;
+    }
+    forEach(...args) {
+        const [callbackfn, thisArg] = args;
+        checkArgsFn(args, 1, "forEach");
+        if (typeof callbackfn !== "function") {
+            throw new TypeError("Failed to execute 'forEach' on 'FormData': parameter 1 is not of type 'Function'.");
+        }
+        let array = this[state][_formData];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            callbackfn.call(thisArg, item[1], item[0], thisArg);
+        }
+    }
+    entries() {
+        return this[state][_formData].map(x => [x[0], x[1]]).values();
+    }
+    keys() {
+        return this[state][_formData].map(x => x[0]).values();
+    }
+    values() {
+        return this[state][_formData].map(x => x[1]).values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /** @internal */ toString() { return "[object FormData]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "FormData"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["FormData"] }; }
+}
+/** @internal */
+const _formData = Symbol();
+/** @internal */
+class FormDataState {
+    constructor() {
+        this[_a] = [];
+    }
+}
+_a = _formData;
+/** @internal */
+function FormData_toBlob(formData) {
+    const boundary = "----formdata-mphttpx-" + Math.random();
+    const p = `--${boundary}\r\nContent-Disposition: form-data; name="`;
+    let chunks = [];
+    for (let i = 0; i < formData[state][_formData].length; ++i) {
+        let pair = formData[state][_formData][i];
+        let name = pair[0];
+        let value = pair[1];
+        if (typeof value === "string") {
+            chunks.push(p + escape(normalizeLinefeeds(name)) + `"\r\n\r\n${normalizeLinefeeds(value)}\r\n`);
+        }
+        else {
+            chunks.push(p + escape(normalizeLinefeeds(name)) + `"; filename="${escape(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}\r\n\r\n`, value, `\r\n`);
+        }
+    }
+    chunks.push(`--${boundary}--`);
+    return new BlobP(chunks, { type: "multipart/form-data; boundary=" + boundary });
+}
+function normalizeArgs(name, value, filename) {
+    if (isPolyfillType("Blob", value)) {
+        filename = filename !== undefined
+            ? ("" + filename)
+            : typeof value.name === "string"
+                ? value.name
+                : "blob";
+        if (value.name !== filename || isObjectType("Blob", value) || isPolyfillType("Blob", value, true)) {
+            value = new FileP([value], filename);
+        }
+        return ["" + name, value];
+    }
+    return ["" + name, "" + value];
+}
+// normalize line feeds for textarea
+// https://html.spec.whatwg.org/multipage/form-elements.html#textarea-line-break-normalisation-transformation
+function normalizeLinefeeds(value) {
+    return value.replace(/\r?\n|\r/g, "\r\n");
+}
+function escape(str) {
+    return str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22');
+}
+/** @internal */
+function createFormDataFromBinaryText(text, boundary) {
+    const throwParseError = () => {
+        throw new TypeError("Could not parse content as FormData.");
+    };
+    if (typeof text !== "string" || text.trim() === "") {
+        throwParseError();
+    }
+    let firstLineEnd = text.indexOf("\r\n");
+    if (firstLineEnd === -1) {
+        throwParseError();
+    }
+    let _boundary = text.substring(2, firstLineEnd).trim();
+    if (!_boundary) {
+        throwParseError();
+    }
+    if (boundary !== undefined && boundary !== _boundary) {
+        throwParseError();
+    }
+    let parts = text.split(`--${_boundary}`).filter(part => {
+        let trimmed = part.trim();
+        return trimmed !== "" && trimmed !== "--";
+    });
+    if (parts.length === 0) {
+        throwParseError();
+    }
+    let formData = new FormDataP();
+    parts.forEach(part => {
+        let separatorIndex = part.indexOf("\r\n\r\n");
+        if (separatorIndex === -1) {
+            throwParseError();
+        }
+        let headerRaw = part.substring(0, separatorIndex).trim();
+        let nameMatch = headerRaw.match(/name="([^"]*)"/);
+        if (!nameMatch || nameMatch.length < 2) {
+            throwParseError();
+        }
+        let fieldName = nameMatch[1];
+        let filenameMatch = headerRaw.match(/filename="([^"]*)"/);
+        let contentRaw = part.substring(separatorIndex + 4);
+        if (!filenameMatch) {
+            formData.append(fieldName, contentRaw.replace(/^[\r\n]+|[\r\n]+$/g, ""));
+        }
+        else {
+            let filename = filenameMatch[1] || "";
+            let contentTypeMatch = headerRaw.match(/Content-Type: ([^\r\n]+)/);
+            let mimeType = contentTypeMatch ? (contentTypeMatch[1] || "").trim() : "text/plain";
+            let content = contentRaw.replace(/\r\n/g, "");
+            formData.append(fieldName, new FileP([content], filename, { type: mimeType }));
+        }
+    });
+    return formData;
+}
+const FormDataE = g["FormData"] || FormDataP;
+
+export { FormDataE as FormData, FormDataP, FormData_toBlob, createFormDataFromBinaryText };

package/dist/esm/HeadersP.js

@@ -0,0 +1,170 @@
+import { g, isObjectType, isPolyfillType, polyfill, checkArgsLength } from './isPolyfill.js';
+
+var _a, _b;
+/** @internal */ const state = Symbol( /* "HeadersState" */);
+const checkArgsFn = (args, required, funcName) => { checkArgsLength(args, required, "Headers", funcName); };
+class HeadersP {
+    constructor(init) {
+        this[state] = new HeadersState();
+        if (init !== undefined) {
+            if (isObjectType("Headers", init) || isPolyfillType("Headers", init)) {
+                init.forEach((value, name) => { Headers_append(this, name, value); }, this);
+            }
+            else if (Array.isArray(init) || (init && typeof init === "object" && Symbol.iterator in init)) {
+                let _init = Array.isArray(init) ? init : Array.from(init);
+                _init.forEach(item => {
+                    if (Array.isArray(item) || (item && typeof item === "object" && Symbol.iterator in item)) {
+                        let pair = Array.isArray(item) ? item : Array.from(item);
+                        if (pair.length === 2) {
+                            this.append(pair[0], pair[1]);
+                        }
+                        else {
+                            throw new TypeError("Failed to construct 'Headers': Invalid value");
+                        }
+                    }
+                    else {
+                        throw new TypeError("Failed to construct 'Headers': The provided value cannot be converted to a sequence.");
+                    }
+                }, this);
+            }
+            else {
+                if (init && typeof init === "object") {
+                    Object.getOwnPropertyNames(init).forEach(name => { this.append(name, init[name]); }, this);
+                }
+                else {
+                    throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(record<ByteString, ByteString> or sequence<sequence<ByteString>>)'.");
+                }
+            }
+        }
+        this[state][_initialized] = true;
+    }
+    append(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 2, "append");
+        let _name = normalizeName(name, throwsFn(this[state][_initialized] ? "append" : ""));
+        let _value = normalizeValue(value);
+        Headers_append(this, _name, _value);
+    }
+    delete(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "delete");
+        let _name = normalizeName(name, throwsFn("delete"));
+        delete this[state][_headersDict][_name];
+    }
+    get(...args) {
+        var _c;
+        const [name] = args;
+        checkArgsFn(args, 1, "get");
+        let _name = normalizeName(name, throwsFn("get"));
+        return (_c = this[state][_headersDict][_name]) !== null && _c !== void 0 ? _c : null;
+    }
+    getSetCookie() {
+        let value = this.get("Set-Cookie");
+        return value ? value.split(", ") : [];
+    }
+    has(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "has");
+        let _name = normalizeName(name, throwsFn("has"));
+        return this[state][_headersDict].hasOwnProperty(_name);
+    }
+    set(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 2, "set");
+        let _name = normalizeName(name, throwsFn("set"));
+        let _value = normalizeValue(value);
+        this[state][_headersDict][_name] = _value;
+    }
+    forEach(...args) {
+        const [callbackfn, thisArg] = args;
+        checkArgsFn(args, 1, "forEach");
+        if (typeof callbackfn !== "function") {
+            throw new TypeError("Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'.");
+        }
+        let names = Object.getOwnPropertyNames(this[state][_headersDict]);
+        for (let i = 0; i < names.length; ++i) {
+            let name = names[i];
+            callbackfn.call(thisArg, this[state][_headersDict][name], name, this);
+        }
+    }
+    entries() {
+        let array = [];
+        this.forEach((value, name) => { array.push([name, value]); });
+        return array.values();
+    }
+    keys() {
+        let array = [];
+        this.forEach((value, name) => { array.push(name); });
+        return array.values();
+    }
+    values() {
+        let array = [];
+        this.forEach((value, name) => { array.push(value); });
+        return array.values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /** @internal */ toString() { return "[object Headers]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Headers"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Headers"] }; }
+}
+/** @internal */ const _initialized = Symbol();
+/** @internal */ const _headersDict = Symbol();
+/** @internal */
+class HeadersState {
+    constructor() {
+        this[_a] = false;
+        this[_b] = {};
+    }
+}
+_a = _initialized, _b = _headersDict;
+function Headers_append(headers, name, value) {
+    let dict = headers[state][_headersDict];
+    let oldValue = dict[name];
+    dict[name] = oldValue !== undefined ? `${oldValue}, ${value}` : value;
+}
+function throwsFn(kind) {
+    return () => {
+        throw new TypeError(`Failed to ${kind ? ("execute '" + kind + "' on") : "construct"} 'Headers': Invalid name`);
+    };
+}
+/** @internal */
+function normalizeName(name, throwError) {
+    if (typeof name !== "string") {
+        name = "" + name;
+    }
+    if (throwError && (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "")) {
+        throwError();
+    }
+    return name.toLowerCase();
+}
+/** @internal */
+function normalizeValue(value) {
+    return typeof value === "string" ? value : ("" + value);
+}
+/** @internal */
+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 HeadersE = g["Headers"] || HeadersP;
+
+export { HeadersE as Headers, HeadersP, normalizeName, normalizeValue, parseHeaders };

package/dist/esm/MessageEventP.js

@@ -0,0 +1,61 @@
+import { EventP, Event_getEtField } from './EventP.js';
+import { g, checkArgsLength, polyfill } from './isPolyfill.js';
+
+const dispatched = 1;
+/** @internal */
+const state = Symbol( /* "MessageEventState" */);
+class MessageEventP extends EventP {
+    constructor(type, eventInitDict) {
+        var _a;
+        super(type, eventInitDict);
+        this[state] = new MessageEventState();
+        const s = this[state];
+        s.data = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.data) !== null && _a !== void 0 ? _a : null;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.origin) !== undefined)
+            s.origin = "" + eventInitDict.origin;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.lastEventId) !== undefined)
+            s.lastEventId = "" + eventInitDict.lastEventId;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.source) !== undefined)
+            s.source = eventInitDict.source;
+        if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.ports) !== undefined)
+            s.ports = eventInitDict.ports;
+    }
+    get data() { return this[state].data; }
+    get lastEventId() { return this[state].lastEventId; }
+    get origin() { return this[state].origin; }
+    get ports() { return this[state].ports; }
+    get source() { return this[state].source; }
+    initMessageEvent(...args) {
+        const [type, bubbles, cancelable, data, origin, lastEventId, source, ports] = args;
+        checkArgsLength(args, 1, "MessageEvent", "initMessageEvent");
+        if (Event_getEtField(this, dispatched))
+            return;
+        this.initEvent(type, bubbles, cancelable);
+        const s = this[state];
+        s.data = data !== null && data !== void 0 ? data : null;
+        if (origin !== undefined)
+            s.origin = "" + origin;
+        if (lastEventId !== undefined)
+            s.lastEventId = "" + lastEventId;
+        if (source !== undefined)
+            s.source = source;
+        if (ports !== undefined)
+            s.ports = ports;
+    }
+    /** @internal */ toString() { return "[object MessageEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "MessageEvent"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["MessageEvent", "Event"] }; }
+}
+/** @internal */
+class MessageEventState {
+    constructor() {
+        this.data = null;
+        this.lastEventId = "";
+        this.origin = "";
+        this.ports = [];
+        this.source = null;
+    }
+}
+const MessageEventE = g["EventTarget"] ? g["MessageEvent"] : MessageEventP;
+
+export { MessageEventE as MessageEvent, MessageEventP };

package/dist/esm/ProgressEventP.js

@@ -0,0 +1,65 @@
+import { g, polyfill } from './isPolyfill.js';
+import { EventTarget_fire } from './EventTargetP.js';
+import { EventP, eventState as state$1, Event_setTrusted } from './EventP.js';
+
+/** @internal */
+const state = Symbol( /* "ProgressEventState" */);
+class ProgressEventP extends EventP {
+    constructor(type, eventInitDict) {
+        var _a, _b;
+        super(type, eventInitDict);
+        this[state] = new ProgressEventState();
+        const s = this[state];
+        s.lengthComputable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.lengthComputable);
+        s.loaded = Number((_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.loaded) !== null && _a !== void 0 ? _a : 0);
+        s.total = Number((_b = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.total) !== null && _b !== void 0 ? _b : 0);
+        let errField = "";
+        if (isNaN(s.loaded)) {
+            errField = "loaded";
+        }
+        if (isNaN(s.total)) {
+            errField = "total";
+        }
+        if (errField) {
+            throw new TypeError(`Failed to construct 'ProgressEvent': Failed to read the '${errField}' property from 'ProgressEventInit': The provided double value is non-finite.`);
+        }
+    }
+    get lengthComputable() { return getValue(this[state].lengthComputable); }
+    get loaded() { return getValue(this[state].loaded); }
+    get total() { return getValue(this[state].total); }
+    /** @internal */ toString() { return "[object ProgressEvent]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "ProgressEvent"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["ProgressEvent", "Event"] }; }
+}
+/** @internal */
+class ProgressEventState {
+    constructor() {
+        this.lengthComputable = false;
+        this.loaded = 0;
+        this.total = 0;
+    }
+}
+function getValue(val) {
+    return typeof val === "function" ? val() : val;
+}
+function createInnerProgressEvent(target, type, { lengthComputable = false, loaded = 0, total = 0, } = {}) {
+    let event = new ProgressEventP(type);
+    event[state].lengthComputable = lengthComputable;
+    event[state].loaded = loaded;
+    event[state].total = total;
+    event[state$1].target = target;
+    Event_setTrusted(event, true);
+    return event;
+}
+/** @internal */
+function emitProcessEvent(target, type, loaded = 0, total = 0) {
+    let event = createInnerProgressEvent(target, type, {
+        lengthComputable: () => { return getValue(total) > 0; },
+        loaded,
+        total,
+    });
+    EventTarget_fire(target, event);
+}
+const ProgressEventE = g["EventTarget"] ? g["ProgressEvent"] : ProgressEventP;
+
+export { ProgressEventE as ProgressEvent, ProgressEventP, emitProcessEvent };