mphttpx 2.1.2 → 2.1.5-beta.2

package/dist/esm/encoding/TextDecoderP.js

@@ -1,20 +1,19 @@
 import { setState, SymbolP } from '../utils.js';
 import { isArrayBuffer } from '../helpers/isArrayBuffer.js';
 
+const validLabels = ["utf-8", "utf8", "unicode-1-1-utf-8"];
 class TextDecoderP {
     constructor(label = "utf-8", options) {
-        if (["utf-8", "utf8", "unicode-1-1-utf-8"].indexOf(("" + label).toLowerCase()) === -1) {
+        if (validLabels.indexOf((typeof label === "string" ? label : ("" + label)).toLowerCase()) === -1) {
             throw new RangeError(`Failed to construct 'TextDecoder': encoding ('${label}') not implemented.`);
         }
-        setState(this, "__TextDecoder__", new TextDecoderState());
-        state(this).fatal = !!(options === null || options === void 0 ? void 0 : options.fatal);
-        state(this).ignoreBOM = !!(options === null || options === void 0 ? void 0 : options.ignoreBOM);
+        setState(this, "__TextDecoder__", new TextDecoderState(options));
     }
     get encoding() { return "utf-8"; }
     get fatal() { return state(this).fatal; }
     get ignoreBOM() { return state(this).ignoreBOM; }
     decode(input, options) {
-        return decodeText(state(this), input, options);
+        return decodeText(input, options, state(this));
     }
     /** @internal */ toString() { return "[object TextDecoder]"; }
     /** @internal */ get [SymbolP.toStringTag]() { return "TextDecoder"; }
@@ -22,30 +21,18 @@ class TextDecoderP {
 }
 /** @internal */
 class TextDecoderState {
-    constructor() {
-        this.fatal = false;
-        this.ignoreBOM = false;
+    constructor({ fatal = false, ignoreBOM = false } = {}) {
         this.initial = 0;
         this.partial = [];
+        this.fatal = !!fatal;
+        this.ignoreBOM = !!ignoreBOM;
     }
 }
 function state(target) {
     return target.__TextDecoder__;
 }
-function decodeText(settings, input, options) {
-    let bytes;
-    if (input !== undefined) {
-        if (isArrayBuffer(input)) {
-            bytes = new Uint8Array(input);
-        }
-        else if (ArrayBuffer.isView(input)) {
-            bytes = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
-        }
-        else {
-            throw new TypeError("Input could not be converted to any of: ArrayBufferView, ArrayBuffer.");
-        }
-    }
-    else {
+function decodeText(input, { stream = false } = {}, settings = { fatal: false, initial: 0, partial: [] }) {
+    if (input === undefined) {
         if (settings.partial.length > 0) {
             if (settings.fatal) {
                 settings.partial = [];
@@ -54,6 +41,11 @@ function decodeText(settings, input, options) {
         }
         return "";
     }
+    let bytes = isArrayBuffer(input)
+        ? new Uint8Array(input)
+        : ArrayBuffer.isView(input)
+            ? new Uint8Array(input.buffer, input.byteOffset, input.byteLength)
+            : (() => { throw new TypeError("Input could not be converted to any of: ArrayBufferView, ArrayBuffer."); })();
     if (settings.initial < 3) {
         settings.initial += bytes.length;
         if (bytes.length >= 3) {
@@ -71,29 +63,32 @@ function decodeText(settings, input, options) {
     }
     let end = bytes.length;
     let res = [];
-    if (!!(options === null || options === void 0 ? void 0 : options.stream) && bytes.length > 0) {
+    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);
+                let len = (byte > 0xEF) ? 4 : (byte > 0xDF) ? 3 : (byte > 0xBF) ? 2 : 1;
                 if (len > bytes.length - (i - 1)) {
                     end = i - 1;
                 }
                 break;
             }
-            i--;
+            --i;
         }
         settings.partial = Array.from(bytes.slice(end)); // save tail   // × WeChat 2.5.0
         bytes = bytes.slice(0, end); // × WeChat 2.5.0
     }
+    let codePoint = 0;
+    let tempCodePoint = 0;
+    let bytesPerSequence = 0;
+    let firstByte = 0, secondByte = 0, thirdByte = 0, fourthByte = 0;
     let i = 0;
     while (i < end) {
-        let codePoint = null;
-        let firstByte = bytes[i];
-        let bytesPerSequence = getBytesPerSequence(firstByte);
+        codePoint = 0;
+        firstByte = bytes[i];
+        bytesPerSequence = (firstByte > 0xEF) ? 4 : (firstByte > 0xDF) ? 3 : (firstByte > 0xBF) ? 2 : 1;
         if (i + bytesPerSequence <= end) {
-            let secondByte, thirdByte, fourthByte, tempCodePoint;
             switch (bytesPerSequence) {
                 case 1:
                     if (firstByte < 0x80) {
@@ -132,7 +127,7 @@ function decodeText(settings, input, options) {
                     break;
             }
         }
-        if (codePoint === null) {
+        if (codePoint === 0 && ((bytesPerSequence === 1 && firstByte !== 0) || bytesPerSequence > 1)) {
             if (settings.fatal) {
                 settings.partial = [];
                 throw new TypeError("Decoding failed.");
@@ -157,9 +152,6 @@ function decodeText(settings, input, options) {
     }
     return res.length > 0x4000 ? buildString(res) : concatString(res);
 }
-function getBytesPerSequence(byte) {
-    return (byte > 0xEF) ? 4 : (byte > 0xDF) ? 3 : (byte > 0xBF) ? 2 : 1;
-}
 function buildString(val) {
     let arr = [];
     for (let i = 0, len = val.length; i < len; i += 0x1000) {

package/dist/esm/encoding/TextEncoderP.js

@@ -3,14 +3,14 @@ import { checkArgsLength, isObjectType, SymbolP } from '../utils.js';
 class TextEncoderP {
     get encoding() { return "utf-8"; }
     encode(input = "") {
-        return encodeText("" + input).encoded;
+        return encodeText(typeof input === "string" ? input : ("" + input)).encoded;
     }
     encodeInto(source, destination) {
         checkArgsLength(arguments.length, 2, "TextEncoder", "encodeInto");
         if (!(destination instanceof Uint8Array || isObjectType("Uint8Array", destination) /* Mini Program */)) {
             throw new TypeError("Failed to execute 'encodeInto' on 'TextEncoder': parameter 2 is not of type 'Uint8Array'.");
         }
-        let result = encodeText("" + source, destination);
+        let result = encodeText(typeof source === "string" ? source : ("" + source), destination);
         return { read: result.read, written: result.written };
     }
     /** @internal */ toString() { return "[object TextEncoder]"; }
@@ -25,9 +25,12 @@ function encodeText(input, destination) {
     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
+    let value = 0;
+    let codeUnitCount = 0;
+    let byteCount = 0;
     while (pos < len) {
-        let value = input.charCodeAt(pos);
-        let codeUnitCount = 1;
+        value = input.charCodeAt(pos);
+        codeUnitCount = 1;
         if (value >= 0xd800 && value <= 0xdbff) {
             // high surrogate
             if (pos + 1 < len) {
@@ -63,7 +66,6 @@ function encodeText(input, destination) {
             update.set(target);
             target = update;
         }
-        let byteCount;
         if ((value & 0xffffff80) === 0) { // 1-byte
             byteCount = 1;
         }

package/dist/esm/event-system/AbortControllerP.js

@@ -6,9 +6,7 @@ class AbortControllerP {
         setState(this, "__AbortController__", new AbortControllerState());
     }
     get signal() { return state(this).signal; }
-    abort(reason) {
-        AbortSignal_abort(this.signal, true, reason);
-    }
+    abort(reason) { AbortSignal_abort(this.signal, true, reason); }
     /** @internal */ toString() { return "[object AbortController]"; }
     /** @internal */ get [SymbolP.toStringTag]() { return "AbortController"; }
     /** @internal */ get __MPHTTPX__() { return { chain: ["AbortController"] }; }

package/dist/esm/event-system/AbortSignalP.js

@@ -17,13 +17,14 @@ class AbortSignalP extends EventTargetP {
             throw new TypeError("Failed to execute 'any' on 'AbortSignal': The provided value cannot be converted to a sequence.");
         }
         let _signals = Array.isArray(signals) ? signals : Array.from(signals);
-        _signals.forEach(sig => {
-            if (!isEventTarget(sig)) {
-                throw new TypeError("Failed to execute 'any' on 'AbortSignal': Failed to convert value to 'AbortSignal'.");
-            }
-        });
+        _signals.forEach(sig => { if (!isEventTarget(sig))
+            throw new TypeError("Failed to execute 'any' on 'AbortSignal': Failed to convert value to 'AbortSignal'."); });
         let signal = createAbortSignal();
-        let abortedSignal = _signals.find(x => x.aborted);
+        let abortedSignal = (() => { for (let i = 0; i < _signals.length; ++i) {
+            let sig = _signals[i];
+            if (sig.aborted)
+                return sig;
+        } })();
         if (abortedSignal) {
             AbortSignal_abort(signal, false, abortedSignal.reason);
         }
@@ -48,8 +49,8 @@ class AbortSignalP extends EventTargetP {
             throw new TypeError("Failed to execute 'timeout' on 'AbortSignal': Value is outside the 'unsigned long long' value range.");
         }
         const signal = createAbortSignal();
-        const whenTimeout = () => AbortSignal_abort(signal, true, new DOMExceptionP("signal timed out", "TimeoutError"));
-        setTimeout(whenTimeout, milliseconds);
+        const execTimeout = () => AbortSignal_abort(signal, true, new DOMExceptionP("signal timed out", "TimeoutError"));
+        setTimeout(execTimeout, milliseconds);
         return signal;
     }
     /** @internal */
@@ -93,16 +94,14 @@ function state(target) {
 /** @internal */
 function AbortSignal_abort(signal, notify = true, reason) {
     const s = state(signal);
-    const whenAbort = () => {
+    const execAbort = () => {
         s.aborted = true;
-        s.reason = reason !== null && reason !== void 0 ? reason : (new DOMExceptionP("signal is aborted without reason", "AbortError"));
-        if (notify) {
+        s.reason = reason !== undefined ? reason : new DOMExceptionP("signal is aborted without reason", "AbortError");
+        if (notify)
             emitEvent(signal, "abort");
-        }
     };
-    if (!signal.aborted) {
-        whenAbort();
-    }
+    if (!signal.aborted)
+        execAbort();
 }
 /** @internal */
 function createAbortSignal() {

package/dist/esm/event-system/CloseEventP.js

@@ -3,11 +3,10 @@ import { setState, SymbolP } from '../utils.js';
 
 class CloseEventP extends EventP {
     constructor(type, eventInitDict) {
-        var _a;
         super(type, eventInitDict);
         setState(this, "__CloseEvent__", new CloseEventState());
         const s = state(this);
-        let _code = Number((_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.code) !== null && _a !== void 0 ? _a : 0);
+        let _code = Number(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.code);
         s.code = isNaN(_code) ? 0 : _code;
         if ((eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.reason) !== undefined)
             s.reason = "" + eventInitDict.reason;

package/dist/esm/event-system/CustomEventP.js

@@ -1,9 +1,10 @@
 import { EventP } from './EventP.js';
-import { setState, checkArgsLength, SymbolP } from '../utils.js';
+import { checkArgsLength, setState, SymbolP } from '../utils.js';
 
 class CustomEventP extends EventP {
     constructor(type, eventInitDict) {
         var _a;
+        checkArgsLength(arguments.length, 1, "CustomEvent");
         super(type, eventInitDict);
         setState(this, "__CustomEvent__", new CustomEventState());
         state(this).detail = (_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.detail) !== null && _a !== void 0 ? _a : null;

package/dist/esm/event-system/EventP.js

@@ -8,13 +8,14 @@ class EventP {
     constructor(type, eventInitDict) {
         checkArgsLength(arguments.length, 1, "Event");
         setState(this, "__Event__", new EventState());
-        state(this).type = "" + type;
-        state(this).bubbles = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles);
-        state(this).cancelable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable);
-        state(this).composed = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.composed);
+        const s = state(this);
+        s.type = "" + type;
+        s.bubbles = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.bubbles);
+        s.cancelable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.cancelable);
+        s.composed = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.composed);
         Object.defineProperty(this, "isTrusted", {
             enumerable: true,
-            get: (function isTrusted() { return state(this).isTrusted === "YES"; }).bind(this),
+            get: function isTrusted() { return s.isTrusted === "YES"; },
         });
     }
     get NONE() { return 0; }
@@ -47,19 +48,20 @@ class EventP {
     }
     initEvent(type, bubbles, cancelable) {
         checkArgsLength(arguments.length, 1, className(this), "initEvent");
-        if (state(this).eventDispatched)
+        let s = state(this);
+        if (s.eventDispatched)
             return;
-        state(this).type = "" + type;
-        state(this).bubbles = !!bubbles;
-        state(this).cancelable = !!cancelable;
+        s.type = "" + type;
+        s.bubbles = !!bubbles;
+        s.cancelable = !!cancelable;
     }
     preventDefault() {
-        if (state(this).passive) {
+        let s = state(this);
+        if (s.passive)
             return console.warn(`Ignoring 'preventDefault()' call on event of type '${this.type}' from a listener registered as 'passive'.`);
-        }
         if (this.cancelable) {
-            state(this).defaultPrevented = true;
-            state(this).returnValue = false;
+            s.defaultPrevented = true;
+            s.returnValue = false;
         }
     }
     stopImmediatePropagation() {
@@ -85,7 +87,7 @@ class EventState {
         this.eventPhase = 0 /* NONE */;
         this.returnValue = true;
         this.target = null;
-        this.timeStamp = (new Date()).getTime() - EventState.timeStamp;
+        this.timeStamp = (new Date()).getTime() - timeStamp;
         this.type = "";
         this.passive = false;
         this.eventDispatched = false;
@@ -93,7 +95,7 @@ class EventState {
         Object.defineProperty(this, "isTrusted", createTrustedPropertyDescriptor());
     }
 }
-EventState.timeStamp = (new Date()).getTime();
+const timeStamp = (new Date()).getTime();
 /** @internal */
 function state(target) {
     return target.__Event__;

package/dist/esm/event-system/EventTargetP.js

@@ -8,24 +8,27 @@ class EventTargetP {
     }
     addEventListener(type, callback, options) {
         checkArgsLength(arguments.length, 2, className(this), "addEventListener");
-        if (!(typeof callback === "function" || typeof callback === "object" || callback === undefined)) {
+        if (typeof callback !== "function" && typeof callback !== "object" && callback !== undefined) {
             throw new TypeError(`Failed to execute 'addEventListener' on '${className(this)}': parameter 2 is not of type 'Object'.`);
         }
+        let s = state(this);
         let executor = new Executor(type, callback);
-        executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
-        if (!state(this).executors.some(x => x.equals(executor))) {
+        let capture = executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
+        if (!s.executors.some(x => x.equals(executor))) {
+            s.executors.push(executor);
             if (options && typeof options === "object") {
                 executor.options.once = !!options.once;
                 executor.options.passive = !!options.passive;
                 const signal = options.signal;
-                if (signal && isEventTarget(signal)) {
+                if (signal && isEventTarget(signal) && !signal.aborted) {
                     executor.options.signal = signal;
                     whenAbort(this, executor, signal);
                 }
             }
-            state(this).executors.push(executor);
-            const f = (v) => !!v.options.capture ? 0 : 1;
-            state(this).executors = state(this).executors.sort((a, b) => f(a) - f(b));
+            if (capture) {
+                let f = (v) => !!v.options.capture ? 0 : 1;
+                s.executors = s.executors.sort((a, b) => f(a) - f(b));
+            }
         }
     }
     dispatchEvent(event) {
@@ -43,13 +46,14 @@ class EventTargetP {
     }
     removeEventListener(type, callback, options) {
         checkArgsLength(arguments.length, 2, className(this), "removeEventListener");
-        if (!(typeof callback === "function" || typeof callback === "object" || callback === undefined)) {
+        if (typeof callback !== "function" && typeof callback !== "object" && callback !== undefined) {
             throw new TypeError(`Failed to execute 'removeEventListener' on '${className(this)}': parameter 2 is not of type 'Object'.`);
         }
+        let s = state(this);
         let executor = new Executor(type, callback);
         executor.options.capture = typeof options === "boolean" ? options : !!(options === null || options === void 0 ? void 0 : options.capture);
-        if (state(this).executors.some(x => x.equals(executor))) {
-            state(this).executors = state(this).executors.filter(x => !x.equals(executor));
+        if (s.executors.some(x => x.equals(executor))) {
+            s.executors = s.executors.filter(x => !x.equals(executor));
         }
     }
     /** @internal */ toString() { return "[object EventTarget]"; }

package/dist/esm/event-system/ProgressEventP.js

@@ -6,11 +6,12 @@ class ProgressEventP extends EventP {
         var _a, _b;
         super(type, eventInitDict);
         setState(this, "__ProgressEvent__", new ProgressEventState());
-        state(this).lengthComputable = !!(eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.lengthComputable);
-        state(this).loaded = Number((_a = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.loaded) !== null && _a !== void 0 ? _a : 0);
-        state(this).total = Number((_b = eventInitDict === null || eventInitDict === void 0 ? void 0 : eventInitDict.total) !== null && _b !== void 0 ? _b : 0);
-        checkNumber("loaded", this.loaded);
-        checkNumber("total", this.total);
+        const s = state(this);
+        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);
+        checkNumberField("loaded", this.loaded);
+        checkNumberField("total", this.total);
     }
     get lengthComputable() { return state(this).lengthComputable; }
     get loaded() { return state(this).loaded; }
@@ -30,7 +31,7 @@ class ProgressEventState {
 function state(target) {
     return target.__ProgressEvent__;
 }
-function checkNumber(field, value) {
+function checkNumberField(field, value) {
     if (isNaN(value)) {
         throw new TypeError(`Failed to construct 'ProgressEvent': Failed to read the '${field}' property from 'ProgressEventInit': The provided double value is non-finite.`);
     }

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

@@ -66,10 +66,11 @@ class HeadersP {
         if (typeof callbackfn !== "function") {
             throw new TypeError("Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'.");
         }
-        let names = Object.getOwnPropertyNames(state(this).dict);
+        let dict = state(this).dict;
+        let names = Object.getOwnPropertyNames(dict);
         for (let i = 0; i < names.length; ++i) {
             let name = names[i];
-            callbackfn.call(thisArg, state(this).dict[name], name, this);
+            callbackfn.call(thisArg, dict[name], name, this);
         }
     }
     entries() {
@@ -79,13 +80,13 @@ class HeadersP {
     }
     keys() {
         let array = [];
-        this.forEach((value, name) => { array.push(name); });
-        return array.values();
+        this.forEach((value, name) => { array.push([name, value]); });
+        return array.map(x => x[0]).values();
     }
     values() {
         let array = [];
-        this.forEach((value, name) => { array.push(value); });
-        return array.values();
+        this.forEach((value, name) => { array.push([name, value]); });
+        return array.map(x => x[1]).values();
     }
     // @ts-ignore
     /** @internal */ [SymbolP.iterator]() {

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

@@ -24,7 +24,7 @@ class RequestP extends BodyImpl {
             }
             s.cache = input.cache;
             s.credentials = input.credentials;
-            if (!_init.headers) {
+            if (_init.headers === undefined) {
                 state(this).headers = new HeadersP(input.headers);
             }
             s.method = input.method;
@@ -60,12 +60,14 @@ class RequestP extends BodyImpl {
             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") && body) {
-            throw new TypeError("Failed to construct 'Request': Request with GET/HEAD method cannot have body.");
+        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 (payload && payload.type && !this.headers.has("Content-Type")) {
+        if (!this.headers.has("Content-Type") && payload && payload.type) {
             this.headers.set("Content-Type", payload.type);
         }
         if (this.method === "GET" || this.method === "HEAD") {
@@ -99,9 +101,9 @@ class RequestP extends BodyImpl {
     get url() { return state(this).url; }
     clone() {
         if (!this.bodyUsed) {
-            let request = new RequestP(this);
+            let req = new RequestP(this);
             this.__Body__.bodyUsed = false;
-            return request;
+            return req;
         }
         else {
             throw new TypeError("Failed to execute 'clone' on 'Request': Request body is already used");

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

@@ -34,14 +34,13 @@ class ResponseP extends BodyImpl {
             state(this).headers = new HeadersP(_init.headers);
         }
         let status = _init.status === undefined ? 200 : _init.status;
-        if (status < 200 || status > 500) {
+        if (status < 200 || status > 500)
             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 (payload && payload.type && !this.headers.has("Content-Type")) {
+        if (!this.headers.has("Content-Type") && payload && payload.type) {
             this.headers.set("Content-Type", payload.type);
         }
     }

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

@@ -20,7 +20,7 @@ function fetchP(input, init) {
         let xhr = new mp.XMLHttpRequest();
         let aborted = false;
         let payload = request.__Body__.payload;
-        xhr.onload = function () {
+        xhr.onload = () => {
             let options = {
                 headers: parseHeaders(xhr.getAllResponseHeaders() || ""),
                 status: xhr.status,
@@ -37,21 +37,9 @@ function fetchP(input, init) {
                 resolve(response);
             });
         };
-        xhr.onerror = function () {
-            setTimeout(function () {
-                reject(new TypeError("Failed to fetch"));
-            });
-        };
-        xhr.ontimeout = function () {
-            setTimeout(function () {
-                reject(new DOMExceptionP("request:fail timeout", "TimeoutError"));
-            });
-        };
-        xhr.onabort = function () {
-            setTimeout(function () {
-                reject(new DOMExceptionP("The user aborted a request.", "AbortError"));
-            });
-        };
+        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;

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

@@ -1,8 +1,8 @@
-import { isBlob } from '../helpers/isBlob.js';
-import { isSequence } from '../helpers/isSequence.js';
-import { setState, className, SymbolP } from '../utils.js';
 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 {
@@ -19,13 +19,10 @@ class BlobP {
                 size += chunk.size;
                 tasks.push(chunk.arrayBuffer().then(r => new Uint8Array(r)));
             }
-            else if (isArrayBuffer(chunk) || ArrayBuffer.isView(chunk)) {
-                let bytes = BufferSource_toUint8Array(chunk);
-                size += bytes.length;
-                tasks.push(Promise.resolve(bytes));
-            }
             else {
-                let bytes = encode("" + chunk);
+                let bytes = (isArrayBuffer(chunk) || ArrayBuffer.isView(chunk))
+                    ? BufferSource_toUint8Array(chunk)
+                    : encode(chunk);
                 size += bytes.length;
                 tasks.push(Promise.resolve(bytes));
             }
@@ -88,22 +85,19 @@ function clone(buf) {
 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);
+    chunks.reduce((offset, chunk) => { result.set(chunk, offset); return offset + chunk.byteLength; }, 0);
     return result;
 }
-function calcSlicedSize(originalSize, start, end) {
+function calcSlicedSize(size, start, end) {
     const normalizeNumer = (n) => {
         let num = Number(n);
         if (isNaN(num))
             num = 0;
         if (num >= 0) {
-            num = Math.min(num, originalSize);
+            num = Math.min(num, size);
         }
         else {
-            num = Math.max(0, num + originalSize);
+            num = Math.max(0, num + size);
         }
         return num;
     };