mphttpx 1.2.0-beta.1 → 1.2.0-beta.3

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 };

package/dist/esm/RequestP.js

@@ -0,0 +1,146 @@
+import { AbortControllerP } from './AbortControllerP.js';
+import { HeadersP, normalizeMethod } from './HeadersP.js';
+import { g, checkArgsLength, isPolyfillType, polyfill } from './isPolyfill.js';
+import { BodyImpl, bodyState as state$1, Body_toPayload, Body_init } from './BodyImpl.js';
+import './AbortSignalP.js';
+import './EventP.js';
+import './EventTargetP.js';
+import './convertor.js';
+import './BlobP.js';
+import './TextEncoderP.js';
+import './TextDecoderP.js';
+import './FormDataP.js';
+import './FileP.js';
+
+/** @internal */ const state = Symbol( /* "RequestState" */);
+class RequestP extends BodyImpl {
+    constructor(...args) {
+        const [input, init] = args;
+        checkArgsLength(args, 1, "Request");
+        super();
+        this[state$1].name = "Request";
+        this[state] = new RequestState();
+        const s = this[state];
+        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;
+        if (isPolyfillType("Request", 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) {
+                s.headers = new HeadersP(input.headers);
+            }
+            s.method = input.method;
+            s.mode = input.mode;
+            let inputSignal = input[state].signal;
+            if (inputSignal) {
+                s.signal = inputSignal;
+            }
+            s.url = input.url;
+            let payload = Body_toPayload(input);
+            if (!body && payload !== "") {
+                body = payload;
+                input[state$1].bodyUsed = true;
+            }
+        }
+        else {
+            s.url = "" + input;
+        }
+        if (_init.cache) {
+            s.cache = _init.cache;
+        }
+        if (_init.credentials) {
+            s.credentials = _init.credentials;
+        }
+        if (_init.headers) {
+            s.headers = new HeadersP(_init.headers);
+        }
+        if (_init.method) {
+            s.method = normalizeMethod(_init.method);
+        }
+        if (_init.mode) {
+            s.mode = _init.mode;
+        }
+        if (_init.signal) {
+            s.signal = _init.signal;
+        }
+        if ((this.method === "GET" || this.method === "HEAD") && body) {
+            throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
+        }
+        Body_init(this, body);
+        if (this.method === "GET" || this.method === "HEAD") {
+            if (_init.cache === "no-store" || _init.cache === "no-cache") {
+                // Search for a '_' parameter in the query string
+                let reParamSearch = /([?&])_=[^&]*/;
+                if (reParamSearch.test(this.url)) {
+                    // If it already exists then set the value with the current time
+                    s.url = this.url.replace(reParamSearch, "$1_=" + (new Date()).getTime());
+                }
+                else {
+                    // Otherwise add a new '_' parameter to the end with the current time
+                    let reQueryString = /\?/;
+                    s.url += (reQueryString.test(this.url) ? "&" : "?") + "_=" + (new Date()).getTime();
+                }
+            }
+        }
+    }
+    get cache() { return this[state].cache; }
+    get credentials() { return this[state].credentials; }
+    get destination() { return this[state].destination; }
+    get headers() {
+        const s = this[state];
+        if (!s.headers) {
+            s.headers = new HeadersP();
+        }
+        return s.headers;
+    }
+    get integrity() { return this[state].integrity; }
+    get keepalive() { return this[state].keepalive; }
+    get method() { return this[state].method; }
+    get mode() { return this[state].mode; }
+    get redirect() { return this[state].redirect; }
+    get referrer() { return this[state].referrer; }
+    get referrerPolicy() { return this[state].referrerPolicy; }
+    get signal() {
+        const s = this[state];
+        if (!s.signal) {
+            s.signal = (new AbortControllerP()).signal;
+        }
+        return s.signal;
+    }
+    get url() { return this[state].url; }
+    clone() {
+        var _a;
+        if (this.bodyUsed) {
+            throw new TypeError("Failed to execute 'clone' on 'Request': Request body is already used");
+        }
+        return new RequestP(this, { body: (_a = Body_toPayload(this)) !== null && _a !== void 0 ? _a : null });
+    }
+    /** @internal */ toString() { return "[object Request]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Request"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Request"] }; }
+}
+/** @internal */
+class RequestState {
+    constructor() {
+        this.cache = "default";
+        this.credentials = "same-origin";
+        this.destination = "";
+        this.integrity = "";
+        this.keepalive = false;
+        this.method = "GET";
+        this.mode = "cors";
+        this.redirect = "follow";
+        this.referrer = "about:client";
+        this.referrerPolicy = "";
+        this.url = "";
+    }
+}
+const RequestE = g["Request"] || RequestP;
+
+export { RequestE as Request, RequestP, state as requestState };

package/dist/esm/ResponseP.js

@@ -0,0 +1,98 @@
+import { HeadersP } from './HeadersP.js';
+import { g, checkArgsLength, polyfill } from './isPolyfill.js';
+import { BodyImpl, bodyState as state$1, Body_init, Body_toPayload } from './BodyImpl.js';
+import './convertor.js';
+import './BlobP.js';
+import './TextEncoderP.js';
+import './TextDecoderP.js';
+import './FormDataP.js';
+import './FileP.js';
+
+/** @internal */ const state = Symbol( /* "ResponseState" */);
+class ResponseP extends BodyImpl {
+    constructor(body, init) {
+        super();
+        this[state$1].name = "Response";
+        this[state] = new ResponseState();
+        const s = this[state];
+        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'.");
+        }
+        let status = _init.status === undefined ? 200 : _init.status;
+        if (status < 200 || status > 500) {
+            throw new RangeError(`Failed to construct 'Response': The status provided (${+status}) is outside the range [200, 599].`);
+        }
+        if (_init.headers) {
+            s.headers = new HeadersP(_init.headers);
+        }
+        s.ok = status >= 200 && status < 300;
+        s.status = status;
+        s.statusText = _init.statusText === undefined ? "" : "" + _init.statusText;
+        Body_init(this, body);
+    }
+    get headers() {
+        const s = this[state];
+        if (!s.headers) {
+            s.headers = new HeadersP();
+        }
+        return s.headers;
+    }
+    get ok() { return this[state].ok; }
+    get redirected() { return this[state].redirected; }
+    get status() { return this[state].status; }
+    get statusText() { return this[state].statusText; }
+    get type() { return this[state].type; }
+    get url() { return this[state].url; }
+    clone() {
+        if (this.bodyUsed) {
+            throw new TypeError("Failed to execute 'clone' on 'Response': Response body is already used");
+        }
+        let response = new ResponseP(Body_toPayload(this), {
+            headers: new HeadersP(this.headers),
+            status: this.status,
+            statusText: this.statusText,
+        });
+        response[state].url = this.url;
+        return response;
+    }
+    static json(...args) {
+        const [data, init] = args;
+        checkArgsLength(args, 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: "" });
+        response[state].ok = false;
+        response[state].status = 0;
+        response[state].type = "error";
+        return response;
+    }
+    static redirect(...args) {
+        const [url, status = 301] = args;
+        checkArgsLength(args, 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 } });
+    }
+    /** @internal */ toString() { return "[object Response]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "Response"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["Response"] }; }
+}
+/** @internal */
+class ResponseState {
+    constructor() {
+        this.ok = true;
+        this.redirected = false;
+        this.status = 200;
+        this.statusText = "";
+        this.type = "default";
+        this.url = "";
+    }
+}
+const ResponseE = g["Response"] || ResponseP;
+
+export { ResponseE as Response, ResponseP, state as responseState };

package/dist/esm/TextDecoderP.js

@@ -0,0 +1,183 @@
+import { g, isArrayBuffer, isObjectType, polyfill } from './isPolyfill.js';
+
+var _a, _b;
+/** @internal */
+const state = Symbol( /* "TextDecoderState" */);
+class TextDecoderP {
+    constructor(label = "utf-8", { fatal = false, ignoreBOM = false } = {}) {
+        let _label = "" + label;
+        if (["utf-8", "utf8", "unicode-1-1-utf-8"].indexOf(_label.toLowerCase()) === -1) {
+            throw new RangeError(`Failed to construct 'TextDecoder': encoding ('${_label}') not implemented.`);
+        }
+        this[state] = new TextDecoderState();
+        this[state].fatal = !!fatal;
+        this[state].ignoreBOM = !!ignoreBOM;
+    }
+    get encoding() { return "utf-8"; }
+    get fatal() { return this[state].fatal; }
+    get ignoreBOM() { return this[state].ignoreBOM; }
+    decode(input, { stream = false } = {}) {
+        const s = this[state];
+        let bytes;
+        if (input !== undefined) {
+            if (isArrayBuffer(input)) {
+                bytes = new Uint8Array(input);
+            }
+            else if (input instanceof Uint8Array || isObjectType("Uint8Array", input)) {
+                bytes = input;
+            }
+            else if (ArrayBuffer.isView(input)) {
+                bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+            }
+            else {
+                throw new TypeError("Failed to execute 'decode' on 'TextDecoder': parameter 1 is not of type 'ArrayBuffer'.");
+            }
+        }
+        else {
+            if (s[_partial].length > 0) {
+                if (this.fatal) {
+                    s[_partial] = [];
+                    throw new TypeError("TextDecoder: Incomplete UTF-8 sequence.");
+                }
+            }
+            return "";
+        }
+        if (s[_bomDone] < 3) {
+            s[_bomDone] += bytes.length;
+            if (bytes.length >= 3) {
+                if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) {
+                    bytes = bytes.subarray(3); // × WeChat 2.5.0
+                }
+            }
+        }
+        if (s[_partial].length > 0) {
+            let merged = new Uint8Array(s[_partial].length + bytes.length);
+            merged.set(s[_partial], 0);
+            merged.set(bytes, s[_partial].length);
+            bytes = merged;
+            s[_partial] = [];
+        }
+        let end = bytes.length;
+        let res = [];
+        if (stream && bytes.length > 0) {
+            let i = bytes.length;
+            while (i > 0 && i > bytes.length - 4) {
+                let byte = bytes[i - 1];
+                if ((byte & 0b11000000) !== 0b10000000) {
+                    let len = getBytesPerSequence(byte);
+                    if (len > bytes.length - (i - 1)) {
+                        end = i - 1;
+                    }
+                    break;
+                }
+                i--;
+            }
+            s[_partial] = Array.from(bytes.slice(end)); // save tail        // × WeChat 2.5.0
+            bytes = bytes.slice(0, end); // × WeChat 2.5.0
+        }
+        let i = 0;
+        while (i < end) {
+            let codePoint = null;
+            let firstByte = bytes[i];
+            let bytesPerSequence = getBytesPerSequence(firstByte);
+            if (i + bytesPerSequence <= end) {
+                let secondByte, thirdByte, fourthByte, tempCodePoint;
+                switch (bytesPerSequence) {
+                    case 1:
+                        if (firstByte < 0x80) {
+                            codePoint = firstByte;
+                        }
+                        break;
+                    case 2:
+                        secondByte = bytes[i + 1];
+                        if ((secondByte & 0xC0) === 0x80) {
+                            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
+                            if (tempCodePoint > 0x7F) {
+                                codePoint = tempCodePoint;
+                            }
+                        }
+                        break;
+                    case 3:
+                        secondByte = bytes[i + 1];
+                        thirdByte = bytes[i + 2];
+                        if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+                            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
+                            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+                                codePoint = tempCodePoint;
+                            }
+                        }
+                        break;
+                    case 4:
+                        secondByte = bytes[i + 1];
+                        thirdByte = bytes[i + 2];
+                        fourthByte = bytes[i + 3];
+                        if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+                            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
+                            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+                                codePoint = tempCodePoint;
+                            }
+                        }
+                        break;
+                }
+            }
+            if (codePoint === null) {
+                if (this.fatal) {
+                    s[_partial] = [];
+                    throw new TypeError("TextDecoder.decode: Decoding failed.");
+                }
+                let skip = 1;
+                while (i + skip < end && (bytes[i + skip] & 0b11000000) === 0b10000000) {
+                    skip += 1;
+                }
+                // we did not generate a valid codePoint so insert a replacement char (U+FFFD)
+                res.push(0xFFFD);
+                i += skip;
+                continue;
+            }
+            else if (codePoint > 0xFFFF) {
+                // encode to utf16 (surrogate pair dance)
+                codePoint -= 0x10000;
+                res.push(codePoint >>> 10 & 0x3FF | 0xD800);
+                codePoint = 0xDC00 | codePoint & 0x3FF;
+            }
+            res.push(codePoint);
+            i += bytesPerSequence;
+        }
+        return res.length > 0x4000 ? buildString(res) : concatString(res);
+    }
+    /** @internal */ toString() { return "[object TextDecoder]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "TextDecoder"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextDecoder"] }; }
+}
+/** @internal */ const _bomDone = Symbol();
+/** @internal */ const _partial = Symbol();
+/** @internal */
+class TextDecoderState {
+    constructor() {
+        this.fatal = false;
+        this.ignoreBOM = false;
+        this[_a] = 0;
+        this[_b] = [];
+    }
+}
+_a = _bomDone, _b = _partial;
+function getBytesPerSequence(byte) {
+    return (byte > 0xEF) ? 4 : (byte > 0xDF) ? 3 : (byte > 0xBF) ? 2 : 1;
+}
+const buildString = (res) => {
+    let arr = [];
+    for (let i = 0, len = res.length; i < len; i += 0x1000) {
+        arr.push(String.fromCharCode.apply(String, res.slice(i, i + 0x1000)));
+    }
+    return arr.join("");
+};
+const concatString = (res) => {
+    let str = "";
+    for (let i = 0, len = res.length; i < len; i += 0x1000) {
+        str += String.fromCharCode.apply(String, res.slice(i, i + 0x1000));
+    }
+    return str;
+};
+const TextDecoderE = g["TextDecoder"] || TextDecoderP;
+
+export { TextDecoderE as TextDecoder, TextDecoderP };

package/dist/esm/TextEncoderP.js

@@ -0,0 +1,119 @@
+import { g, checkArgsLength, isObjectType, polyfill } from './isPolyfill.js';
+
+class TextEncoderP {
+    get encoding() { return "utf-8"; }
+    encode(input = "") {
+        let _input = "" + input;
+        return encodeText(_input).encoded;
+    }
+    encodeInto(...args) {
+        const [source, destination] = args;
+        checkArgsLength(args, 2, "TextEncoder", "encodeInto");
+        let _source = "" + source;
+        if (!(destination instanceof Uint8Array || isObjectType("Uint8Array", destination))) {
+            throw new TypeError("Failed to execute 'encodeInto' on 'TextEncoder': parameter 2 is not of type 'Uint8Array'.");
+        }
+        let result = encodeText(_source, destination);
+        return { read: result.read, written: result.written };
+    }
+    /** @internal */ toString() { return "[object TextEncoder]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "TextEncoder"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["TextEncoder"] }; }
+}
+function encodeText(input, destination) {
+    const HAS_DESTINATION = typeof destination !== "undefined";
+    let pos = 0;
+    let read = 0;
+    let len = input.length;
+    let at = 0; // output position
+    let tlen = Math.max(32, len + (len >> 1) + 7); // 1.5x size
+    let target = HAS_DESTINATION ? destination : new Uint8Array((tlen >> 3) << 3); // ... but at 8 byte offset
+    while (pos < len) {
+        let value = input.charCodeAt(pos);
+        let codeUnitCount = 1;
+        if (value >= 0xd800 && value <= 0xdbff) {
+            // high surrogate
+            if (pos + 1 < len) {
+                let extra = input.charCodeAt(pos + 1);
+                if ((extra & 0xfc00) === 0xdc00) {
+                    codeUnitCount = 2;
+                    pos += 2;
+                    value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
+                }
+                else {
+                    pos += 1;
+                    value = 0xfffd;
+                }
+            }
+            else {
+                pos += 1;
+                value = 0xfffd;
+            }
+        }
+        else if (value >= 0xdc00 && value <= 0xdfff) {
+            pos += 1;
+            value = 0xfffd;
+        }
+        else {
+            pos += 1;
+        }
+        // expand the buffer if we couldn't write 4 bytes
+        if (!HAS_DESTINATION && at + 4 > target.length) {
+            tlen += 8; // minimum extra
+            tlen *= (1.0 + (pos / input.length) * 2); // take 2x the remaining
+            tlen = (tlen >> 3) << 3; // 8 byte offset
+            let update = new Uint8Array(tlen);
+            update.set(target);
+            target = update;
+        }
+        let byteCount;
+        if ((value & 0xffffff80) === 0) { // 1-byte
+            byteCount = 1;
+        }
+        else if ((value & 0xfffff800) === 0) { // 2-byte
+            byteCount = 2;
+        }
+        else if ((value & 0xffff0000) === 0) { // 3-byte
+            byteCount = 3;
+        }
+        else if ((value & 0xffe00000) === 0) { // 4-byte
+            byteCount = 4;
+        }
+        else {
+            value = 0xfffd;
+            byteCount = 3;
+        }
+        if (HAS_DESTINATION && at + byteCount > target.length) {
+            break;
+        }
+        switch (byteCount) {
+            case 1: // 1-byte
+                target[at++] = value; // ASCII
+                break;
+            case 2: // 2-byte
+                target[at++] = ((value >> 6) & 0x1f) | 0xc0;
+                target[at++] = (value & 0x3f) | 0x80;
+                break;
+            case 3: // 3-byte
+                target[at++] = ((value >> 12) & 0x0f) | 0xe0;
+                target[at++] = ((value >> 6) & 0x3f) | 0x80;
+                target[at++] = (value & 0x3f) | 0x80;
+                break;
+            case 4: // 4-byte
+                target[at++] = ((value >> 18) & 0x07) | 0xf0;
+                target[at++] = ((value >> 12) & 0x3f) | 0x80;
+                target[at++] = ((value >> 6) & 0x3f) | 0x80;
+                target[at++] = (value & 0x3f) | 0x80;
+                break;
+        }
+        read += codeUnitCount;
+    }
+    return {
+        encoded: !HAS_DESTINATION ? target.slice(0, at) : destination,
+        read: read,
+        written: at,
+    };
+}
+const TextEncoderE = g["TextEncoder"] || TextEncoderP;
+
+export { TextEncoderE as TextEncoder, TextEncoderP };