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

package/dist/esm/XMLHttpRequestP.js

@@ -0,0 +1,559 @@
+import { convert, convertBack } from './convertor.js';
+import { Uint8Array_toBase64, encode } from './BlobP.js';
+import { normalizeMethod, HeadersP } from './HeadersP.js';
+import { EventTargetP, attachFn, executeFn, EventTargetState, eventTargetState as state$2, EventTarget_fire } from './EventTargetP.js';
+import { createInnerEvent } from './EventP.js';
+import { emitProcessEvent } from './ProgressEventP.js';
+import { mp as mp$1 } from './platform.js';
+import { polyfill, checkArgsLength, MPException } from './isPolyfill.js';
+import './FormDataP.js';
+import './FileP.js';
+import './TextEncoderP.js';
+import './TextDecoderP.js';
+
+const request = mp$1 ? mp$1.request : function errorRequest(options) {
+    const errMsg = "NOT_SUPPORTED_ERR";
+    const errno = 9;
+    const err = {
+        errMsg,
+        errno,
+        exception: {
+            retryCount: 0,
+            reasons: [{ errMsg, errno }],
+        },
+        useHttpDNS: false,
+    };
+    Promise.resolve(err)
+        .then(err => { try {
+        if (options.fail) {
+            options.fail(err);
+        }
+    }
+    catch (e) {
+        console.error(e);
+    } })
+        .then(() => { if (options.complete) {
+        options.complete(err);
+    } });
+    throw new ReferenceError("request is not defined");
+};
+
+var _a$1;
+/** @internal */ const state$1 = Symbol( /* "XMLHttpRequestEventTargetState" */);
+class XMLHttpRequestEventTargetP extends EventTargetP {
+    /** @internal */
+    constructor() {
+        if (new.target === XMLHttpRequestEventTargetP) {
+            throw new TypeError("Failed to construct 'XMLHttpRequestEventTarget': Illegal constructor");
+        }
+        super();
+        this[state$1] = new XMLHttpRequestEventTargetState(this);
+    }
+    get onabort() { return this[state$1].onabort; }
+    set onabort(value) { this[state$1].onabort = value; attach(this, "abort"); }
+    get onerror() { return this[state$1].onerror; }
+    set onerror(value) { this[state$1].onerror = value; attach(this, "error"); }
+    get onload() { return this[state$1].onload; }
+    set onload(value) { this[state$1].onload = value; attach(this, "load"); }
+    get onloadend() { return this[state$1].onloadend; }
+    set onloadend(value) { this[state$1].onloadend = value; attach(this, "loadend"); }
+    get onloadstart() { return this[state$1].onloadstart; }
+    set onloadstart(value) { this[state$1].onloadstart = value; attach(this, "loadstart"); }
+    get onprogress() { return this[state$1].onprogress; }
+    set onprogress(value) { this[state$1].onprogress = value; attach(this, "progress"); }
+    get ontimeout() { return this[state$1].ontimeout; }
+    set ontimeout(value) { this[state$1].ontimeout = value; attach(this, "timeout"); }
+    /** @internal */ toString() { return "[object XMLHttpRequestEventTarget]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "XMLHttpRequestEventTarget"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestEventTarget", "EventTarget"] }; }
+}
+/** @internal */
+const _handlers$1 = Symbol();
+/** @internal */
+class XMLHttpRequestEventTargetState {
+    /**
+     * @param _target XMLHttpRequestEventTarget
+     */
+    constructor(_target) {
+        this[_a$1] = getHandlers$1(this);
+        this.onabort = null;
+        this.onerror = null;
+        this.onload = null;
+        this.onloadend = null;
+        this.onloadstart = null;
+        this.onprogress = null;
+        this.ontimeout = null;
+        this.target = _target;
+    }
+}
+_a$1 = _handlers$1;
+function attach(target, type) {
+    const s = target[state$1];
+    const fnName = ("on" + type);
+    const cb = s[fnName];
+    const listener = s[_handlers$1][fnName];
+    attachFn(target, type, cb, listener);
+}
+function getHandlers$1(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); },
+        ontimeout: (ev) => { executeFn(s.target, s.ontimeout, ev); },
+    };
+}
+const responseTypes = ["", "text", "json", "arraybuffer", "blob", "document"];
+/** @internal */
+function normalizeResponseType(responseType) {
+    return responseTypes.indexOf(responseType) > -1 ? responseType : "";
+}
+const statusMessages = {
+    100: "Continue",
+    101: "Switching Protocols",
+    102: "Processing",
+    103: "Early Hints",
+    200: "OK",
+    201: "Created",
+    202: "Accepted",
+    203: "Non-Authoritative Information",
+    204: "No Content",
+    205: "Reset Content",
+    206: "Partial Content",
+    207: "Multi-Status",
+    208: "Already Reported",
+    226: "IM Used",
+    300: "Multiple Choices",
+    301: "Moved Permanently",
+    302: "Found",
+    303: "See Other",
+    304: "Not Modified",
+    307: "Temporary Redirect",
+    308: "Permanent Redirect",
+    400: "Bad Request",
+    401: "Unauthorized",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Content Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "I'm a teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Entity",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required"
+};
+/** @internal */
+function statusTextMap(val) {
+    return statusMessages[val] || "unknown";
+}
+
+class XMLHttpRequestUploadP extends XMLHttpRequestEventTargetP {
+    /** @internal */
+    constructor() {
+        if (new.target === XMLHttpRequestUploadP) {
+            throw new TypeError("Failed to construct 'XMLHttpRequestUpload': Illegal constructor");
+        }
+        super();
+    }
+    /** @internal */ toString() { return "[object XMLHttpRequestUpload]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "XMLHttpRequestUpload"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequestUpload", "XMLHttpRequestEventTarget", "EventTarget"] }; }
+}
+/** @internal */
+function createXMLHttpRequestUpload() {
+    let upload = Object.create(XMLHttpRequestUploadP.prototype);
+    upload[state$2] = new EventTargetState(upload);
+    upload[state$1] = new XMLHttpRequestEventTargetState(upload);
+    return upload;
+}
+
+var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+const mp = { request: request };
+const setRequest = (request) => { mp.request = request; };
+/** @internal */ const state = Symbol( /* "XMLHttpRequestState" */);
+class XMLHttpRequestImpl extends XMLHttpRequestEventTargetP {
+    static get UNSENT() { return 0; }
+    static get OPENED() { return 1; }
+    static get HEADERS_RECEIVED() { return 2; }
+    static get LOADING() { return 3; }
+    static get DONE() { return 4; }
+    constructor() {
+        super();
+        this[state] = new XMLHttpRequestState(this);
+    }
+    get UNSENT() { return 0; }
+    get OPENED() { return 1; }
+    get HEADERS_RECEIVED() { return 2; }
+    get LOADING() { return 3; }
+    get DONE() { return 4; }
+    get readyState() { return this[state].readyState; }
+    get response() { return this[state].response; }
+    get responseText() { return (!this.responseType || this.responseType === "text") ? this.response : ""; }
+    get responseType() { return this[state].responseType; }
+    set responseType(value) { this[state].responseType = normalizeResponseType(value); }
+    get responseURL() { return this[state].responseURL; }
+    get responseXML() { return null; }
+    get status() { return this[state].status; }
+    get statusText() {
+        if (this.readyState === 0 /* UNSENT */ || this.readyState === 1 /* OPENED */)
+            return "";
+        return this[state].statusText || statusTextMap(this.status);
+    }
+    get timeout() { return this[state].timeout; }
+    set timeout(value) { this[state].timeout = value > 0 ? value : 0; }
+    get upload() {
+        const s = this[state];
+        if (!s.upload) {
+            s.upload = createXMLHttpRequestUpload();
+        }
+        return s.upload;
+    }
+    get withCredentials() { return this[state].withCredentials; }
+    set withCredentials(value) { this[state].withCredentials = !!value; }
+    abort() {
+        clearRequest(this);
+    }
+    getAllResponseHeaders() {
+        const headers = this[state][_responseHeaders];
+        if (!headers)
+            return "";
+        let result = [];
+        headers.forEach((value, name) => { result.push(`${name}: ${value}\r\n`); });
+        return result.join("");
+    }
+    getResponseHeader(...args) {
+        const [name] = args;
+        checkArgsLength(args, 1, "XMLHttpRequest", "getResponseHeader");
+        if (!this[state][_responseHeaders])
+            return null;
+        return this[state][_responseHeaders].get(name);
+    }
+    open(...args) {
+        const [method, url, async = true, username = null, password = null] = args;
+        checkArgsLength(args, 2, "XMLHttpRequest", "open");
+        if (!async) {
+            console.warn("Synchronous XMLHttpRequest is not supported because of its detrimental effects to the end user's experience.");
+        }
+        const s = this[state];
+        clearRequest(this, false);
+        s[_method] = normalizeMethod(method);
+        s[_requestURL] = "" + url;
+        if (username !== null || password !== null) {
+            let _username = "" + (username !== null && username !== void 0 ? username : "");
+            let _password = "" + (password !== null && password !== void 0 ? password : "");
+            if (_username.length > 0 || _password.length > 0) {
+                let auth = `Basic ${Uint8Array_toBase64(encode(_username + ":" + _password))}`;
+                this.setRequestHeader("Authorization", auth);
+            }
+        }
+        s[_inAfterOpenBeforeSend] = true;
+        setReadyStateAndNotify(this, 1 /* OPENED */);
+    }
+    overrideMimeType(...args) {
+        const [mime] = args;
+        checkArgsLength(args, 1, "XMLHttpRequest", "overrideMimeType");
+        if (this[state][_inAfterOpenBeforeSend]) {
+            console.error(`TypeError: Failed to execute 'overrideMimeType' on 'XMLHttpRequest': mimeType ('${mime}') not implemented.`);
+        }
+    }
+    send(body) {
+        const s = this[state];
+        if (!s[_inAfterOpenBeforeSend] || s.readyState !== 1 /* OPENED */) {
+            throw new MPException("Failed to execute 'send' on 'XMLHttpRequest': The object's state must be OPENED.", "InvalidStateError");
+        }
+        s[_inAfterOpenBeforeSend] = false;
+        const allowsRequestBody = s[_method] !== "GET" && s[_method] !== "HEAD";
+        const processHeaders = allowsRequestBody && !s[_requestHeaders].has("Content-Type");
+        const processContentLength = allowsRequestBody && !!body;
+        let headers = () => { let dict = {}; s[_requestHeaders].forEach((value, name) => { dict[name] = value; }); return dict; };
+        let contentLength = () => 0;
+        const processHeadersFn = processHeaders ? (v) => { s[_requestHeaders].set("Content-Type", v); } : void 0;
+        const processContentLengthFn = processContentLength ? (v) => { contentLength = v; } : void 0;
+        let data = body;
+        try {
+            data = convert(body, false, processHeadersFn, processContentLengthFn);
+        }
+        catch (e) {
+            console.warn(e);
+        }
+        let options = {
+            url: s[_requestURL],
+            method: s[_method],
+            header: headers(),
+            data: data !== "" ? data : void 0,
+            dataType: s.responseType === "json" ? "json" : normalizeDataType(s.responseType),
+            responseType: normalizeDataType(s.responseType),
+            withCredentials: s.withCredentials,
+            success: requestSuccess.bind(this),
+            fail: requestFail.bind(this),
+            complete: requestComplete.bind(this),
+        };
+        // Alipay Mini Program
+        options.headers = options.header;
+        s[_requestTask] = mp.request(options);
+        emitProcessEvent(this, "loadstart");
+        if (processContentLength && s.upload) {
+            emitProcessEvent(this.upload, "loadstart", 0, contentLength);
+        }
+        setTimeout(() => {
+            if (s.upload) {
+                const _aborted = s[_inAfterOpenBeforeSend] || s.readyState !== 1 /* OPENED */;
+                const _contentLength = _aborted ? 0 : contentLength;
+                if (_aborted) {
+                    emitProcessEvent(this.upload, "abort");
+                }
+                else {
+                    if (processContentLength) {
+                        emitProcessEvent(this.upload, "load", _contentLength, _contentLength);
+                    }
+                }
+                if (_aborted || processContentLength) {
+                    emitProcessEvent(this.upload, "loadend", _contentLength, _contentLength);
+                }
+            }
+        });
+        checkRequestTimeout(this);
+    }
+    setRequestHeader(...args) {
+        const [name, value] = args;
+        checkArgsLength(args, 2, "XMLHttpRequest", "setRequestHeader");
+        const s = this[state];
+        if (!s[_inAfterOpenBeforeSend] || s.readyState !== 1 /* OPENED */) {
+            throw new MPException("Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.", "InvalidStateError");
+        }
+        let _name = "" + name;
+        let _value = "" + value;
+        try {
+            s[_requestHeaders].append(_name, _value);
+        }
+        catch (e) {
+            throw new SyntaxError(`Failed to execute 'setRequestHeader' on 'XMLHttpRequest': '${_name}' is not a valid HTTP header field name.`);
+        }
+    }
+    get onreadystatechange() { return this[state].onreadystatechange; }
+    set onreadystatechange(value) {
+        this[state].onreadystatechange = value;
+        attachFn(this, "readystatechange", value, this[state][_handlers].onreadystatechange);
+    }
+    /** @internal */ toString() { return "[object XMLHttpRequest]"; }
+    /** @internal */ get [Symbol.toStringTag]() { return "XMLHttpRequest"; }
+    /** @internal */ get isPolyfill() { return { symbol: polyfill, hierarchy: ["XMLHttpRequest", "XMLHttpRequestEventTarget", "EventTarget"] }; }
+}
+/** @internal */ const _handlers = Symbol();
+/** @internal */ const _inAfterOpenBeforeSend = Symbol();
+/** @internal */ const _resetPending = Symbol();
+/** @internal */ const _timeoutId = Symbol();
+/** @internal */ const _requestURL = Symbol();
+/** @internal */ const _method = Symbol();
+/** @internal */ const _requestHeaders = Symbol();
+/** @internal */ const _responseHeaders = Symbol();
+/** @internal */ const _responseContentLength = Symbol();
+/** @internal */ const _requestTask = Symbol();
+/** @internal */
+class XMLHttpRequestState {
+    constructor(target) {
+        this.readyState = 0 /* UNSENT */;
+        this.response = "";
+        this.responseType = "";
+        this.responseURL = "";
+        this.status = 0;
+        this.statusText = "";
+        this.timeout = 0;
+        this.withCredentials = false;
+        this[_a] = getHandlers(this);
+        this.onreadystatechange = null;
+        this[_b] = false;
+        this[_c] = false;
+        this[_d] = 0;
+        this[_e] = "";
+        this[_f] = "GET";
+        this[_g] = new HeadersP();
+        this[_h] = null;
+        this[_j] = () => 0;
+        this[_k] = null;
+        this.target = target;
+    }
+}
+_a = _handlers, _b = _inAfterOpenBeforeSend, _c = _resetPending, _d = _timeoutId, _e = _requestURL, _f = _method, _g = _requestHeaders, _h = _responseHeaders, _j = _responseContentLength, _k = _requestTask;
+function getHandlers(s) {
+    return {
+        onreadystatechange: (ev) => { executeFn(s.target, s.onreadystatechange, ev); },
+    };
+}
+function normalizeDataType(responseType) {
+    return (responseType === "blob" || responseType === "arraybuffer") ? "arraybuffer" : "text";
+}
+function requestSuccess(res) {
+    const s = this[state];
+    s.responseURL = s[_requestURL];
+    s.status = "statusCode" in res ? res.statusCode : "status" in res ? res.status : 200;
+    s[_responseHeaders] = new HeadersP(("header" in res ? res.header : "headers" in res ? res.headers : {}));
+    let lengthStr = s[_responseHeaders].get("Content-Length");
+    s[_responseContentLength] = () => { return lengthStr ? parseInt(lengthStr) : 0; };
+    if (s.readyState === 1 /* OPENED */) {
+        setReadyStateAndNotify(this, 2 /* HEADERS_RECEIVED */);
+        setReadyStateAndNotify(this, 3 /* LOADING */);
+        setTimeout(() => {
+            if (!s[_inAfterOpenBeforeSend]) {
+                let l = s[_responseContentLength];
+                try {
+                    s.response = convertBack(s.responseType, res.data);
+                    emitProcessEvent(this, "load", l, l);
+                }
+                catch (e) {
+                    console.error(e);
+                    emitProcessEvent(this, "error");
+                }
+            }
+        });
+    }
+}
+function requestFail(err) {
+    // Alipay Mini Program
+    // error: 14 --- JSON parse data error
+    // error: 19 --- http status error
+    // At this point, the error data object will contain three pieces of information
+    // returned from the server: status, headers, and data.
+    // In the browser's XMLHttpRequest, these two errors (Error 14 and Error 19)
+    // differ from those in Alipay Mini Programs and should instead return normally.
+    // Therefore, this scenario is also handled here as a successful request response.
+    if (("header" in err && "statusCode" in err) || ("headers" in err && "status" in err)) {
+        requestSuccess.call(this, {
+            statusCode: "statusCode" in err ? err.statusCode : err.status || 0,
+            header: "header" in err ? err.header : err.headers || {},
+            data: "data" in err ? err.data || "" : "",
+        });
+        return;
+    }
+    const s = this[state];
+    s.status = 0;
+    s.statusText = "errMsg" in err ? err.errMsg : "errorMessage" in err ? err.errorMessage : "";
+    if (!s[_inAfterOpenBeforeSend] && s.readyState !== 0 /* UNSENT */ && s.readyState !== 4 /* DONE */) {
+        emitProcessEvent(this, "error");
+        resetRequestTimeout(this);
+    }
+}
+function requestComplete() {
+    const s = this[state];
+    s[_requestTask] = null;
+    if (!s[_inAfterOpenBeforeSend] && (s.readyState === 1 /* OPENED */ || s.readyState === 3 /* LOADING */)) {
+        setReadyStateAndNotify(this, 4 /* DONE */);
+    }
+    setTimeout(() => {
+        if (!s[_inAfterOpenBeforeSend]) {
+            let l = s[_responseContentLength];
+            emitProcessEvent(this, "loadend", l, l);
+        }
+    });
+}
+// Alipay Mini Program
+function safeAbort(task) {
+    if ("abort" in task && typeof task.abort === "function") {
+        task.abort();
+    }
+}
+function clearRequest(xhr, delay = true) {
+    const s = xhr[state];
+    const timerFn = delay ? setTimeout : (f) => { f(); };
+    s[_resetPending] = true;
+    if (s[_requestTask] && s.readyState !== 4 /* DONE */) {
+        if (delay) {
+            setReadyStateAndNotify(xhr, 4 /* DONE */);
+        }
+        timerFn(() => {
+            const requestTask = s[_requestTask];
+            if (requestTask) {
+                safeAbort(requestTask);
+            }
+            if (delay) {
+                emitProcessEvent(xhr, "abort");
+            }
+            if (delay && !requestTask) {
+                emitProcessEvent(xhr, "loadend");
+            }
+        });
+    }
+    timerFn(() => {
+        if (s[_resetPending]) {
+            if (delay) {
+                s.readyState = 0 /* UNSENT */;
+            }
+            resetXHR(xhr);
+        }
+    });
+}
+function checkRequestTimeout(xhr) {
+    const s = xhr[state];
+    if (s.timeout) {
+        s[_timeoutId] = setTimeout(() => {
+            if (!s.status && s.readyState !== 4 /* DONE */) {
+                if (s[_requestTask])
+                    safeAbort(s[_requestTask]);
+                setReadyStateAndNotify(xhr, 4 /* DONE */);
+                emitProcessEvent(xhr, "timeout");
+            }
+        }, s.timeout);
+    }
+}
+function resetXHR(xhr) {
+    const s = xhr[state];
+    s[_resetPending] = false;
+    resetRequestTimeout(xhr);
+    s.response = "";
+    s.responseURL = "";
+    s.status = 0;
+    s.statusText = "";
+    s[_requestHeaders] = new HeadersP();
+    s[_responseHeaders] = null;
+    s[_responseContentLength] = () => 0;
+}
+function resetRequestTimeout(xhr) {
+    const s = xhr[state];
+    if (s[_timeoutId]) {
+        clearTimeout(s[_timeoutId]);
+        s[_timeoutId] = 0;
+    }
+}
+function setReadyStateAndNotify(xhr, value) {
+    const s = xhr[state];
+    let hasChanged = value !== s.readyState;
+    s.readyState = value;
+    if (hasChanged) {
+        let evt = createInnerEvent(xhr, "readystatechange");
+        EventTarget_fire(xhr, evt);
+    }
+}
+const XMLHttpRequestE = (typeof XMLHttpRequest !== "undefined" && XMLHttpRequest) || XMLHttpRequestImpl;
+
+export { XMLHttpRequestE as XMLHttpRequest, XMLHttpRequestImpl, setRequest };

package/dist/esm/convertor.js

@@ -0,0 +1,80 @@
+import { Blob_toUint8Array, decode, encode, BlobP } from './BlobP.js';
+import { FormData_toBlob } from './FormDataP.js';
+import { isObjectType, isPolyfillType, isArrayBuffer } from './isPolyfill.js';
+import './TextEncoderP.js';
+import './TextDecoderP.js';
+import './FileP.js';
+
+/** @internal */
+function convert(body, cloneArrayBuffer = true, setContentType, setContentLength) {
+    let result;
+    if (typeof body === "string") {
+        result = body;
+        if (setContentType) {
+            setContentType("text/plain;charset=UTF-8");
+        }
+    }
+    else if (isObjectType("URLSearchParams", body) || isPolyfillType("URLSearchParams", body)) {
+        result = body.toString();
+        if (setContentType) {
+            setContentType("application/x-www-form-urlencoded;charset=UTF-8");
+        }
+    }
+    else if (isArrayBuffer(body)) {
+        result = cloneArrayBuffer ? body.slice(0) : body;
+    }
+    else if (ArrayBuffer.isView(body)) {
+        result = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
+    }
+    else if (isPolyfillType("Blob", body)) {
+        result = Blob_toUint8Array(body).buffer.slice(0);
+        if (setContentType && body.type) {
+            setContentType(body.type);
+        }
+    }
+    else if (isPolyfillType("FormData", body)) {
+        let blob = FormData_toBlob(body);
+        result = Blob_toUint8Array(blob).buffer;
+        if (setContentType) {
+            setContentType(blob.type);
+        }
+    }
+    else if (!body) {
+        result = "";
+    }
+    else {
+        result = "" + body;
+    }
+    if (setContentLength) {
+        let calculated = false, contentLength = 0;
+        setContentLength(() => {
+            if (!calculated) {
+                calculated = true;
+                contentLength = (typeof result === "string" ? encode(result).buffer : result).byteLength;
+            }
+            return contentLength;
+        });
+    }
+    return result;
+}
+/** @internal */
+function convertBack(type, data) {
+    let temp = !!data ? (typeof data !== "string" && !isArrayBuffer(data) ? JSON.stringify(data) : data) : "";
+    if (!type || type === "text") {
+        return typeof temp === "string" ? temp : decode(temp);
+    }
+    else if (type === "json") {
+        return JSON.parse(typeof temp === "string" ? temp : decode(temp));
+    }
+    else if (type === "arraybuffer") {
+        return isArrayBuffer(temp) ? temp.slice(0) : encode(temp).buffer;
+    }
+    else if (type === "blob") {
+        return new BlobP([temp]);
+    }
+    else {
+        return temp;
+    }
+}
+
+export { convert, convertBack };