mphttpx 1.1.0 → 1.2.0-beta.2

package/dist/cjs/TextDecoderP.js

@@ -0,0 +1,186 @@
+'use strict';
+
+var isPolyfill = require('./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 (isPolyfill.isArrayBuffer(input)) {
+                bytes = new Uint8Array(input);
+            }
+            else if (input instanceof Uint8Array || isPolyfill.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: isPolyfill.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 = isPolyfill.g["TextDecoder"] || TextDecoderP;
+
+exports.TextDecoder = TextDecoderE;
+exports.TextDecoderP = TextDecoderP;

package/dist/cjs/TextEncoderP.js

@@ -0,0 +1,122 @@
+'use strict';
+
+var isPolyfill = require('./isPolyfill.js');
+
+class TextEncoderP {
+    get encoding() { return "utf-8"; }
+    encode(input = "") {
+        let _input = "" + input;
+        return encodeText(_input).encoded;
+    }
+    encodeInto(...args) {
+        const [source, destination] = args;
+        isPolyfill.checkArgsLength(args, 2, "TextEncoder", "encodeInto");
+        let _source = "" + source;
+        if (!(destination instanceof Uint8Array || isPolyfill.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: isPolyfill.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 = isPolyfill.g["TextEncoder"] || TextEncoderP;
+
+exports.TextEncoder = TextEncoderE;
+exports.TextEncoderP = TextEncoderP;

package/dist/cjs/URLSearchParamsP.js

@@ -0,0 +1,230 @@
+'use strict';
+
+var isPolyfill = require('./isPolyfill.js');
+
+var _a;
+/** @internal */ const state = Symbol( /* "URLSearchParamsState" */);
+const checkArgsFn = (args, required, funcName) => { isPolyfill.checkArgsLength(args, required, "URLSearchParams", funcName); };
+class URLSearchParamsP {
+    constructor(init) {
+        this[state] = new URLSearchParamsState();
+        if (init !== undefined) {
+            if (isPolyfill.isObjectType("URLSearchParams", init) || isPolyfill.isPolyfillType("URLSearchParams", init)) {
+                init.forEach((value, name) => { this.append(name, value); }, this);
+            }
+            else if (init && typeof init === "object") {
+                if (Array.isArray(init) || Symbol.iterator in init) {
+                    let _init = Array.isArray(init) ? init : Array.from(init);
+                    for (let i = 0; i < _init.length; ++i) {
+                        let item = _init[i];
+                        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 'URLSearchParams': Sequence initializer must only contain pair elements");
+                            }
+                        }
+                        else {
+                            throw new TypeError("Failed to construct 'URLSearchParams': The provided value cannot be converted to a sequence.");
+                        }
+                    }
+                }
+                else {
+                    Object.getOwnPropertyNames(init).forEach(name => { this.append(name, init[name]); }, this);
+                }
+            }
+            else {
+                let _init = "" + init;
+                if (_init.indexOf("?") === 0) {
+                    _init = _init.slice(1);
+                }
+                let pairs = _init.split("&");
+                for (let i = 0; i < pairs.length; ++i) {
+                    let pair = pairs[i], separatorIndex = pair.indexOf("=");
+                    if (separatorIndex > -1) {
+                        this.append(decode(pair.slice(0, separatorIndex)), decode(pair.slice(separatorIndex + 1)));
+                    }
+                    else {
+                        if (pair) {
+                            this.append(decode(pair), "");
+                        }
+                    }
+                }
+            }
+        }
+    }
+    get size() { return this[state][_urlspArray].length; }
+    append(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 2, "append");
+        this[state][_urlspArray].push(["" + name, normalizeValue(value)]);
+    }
+    delete(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 1, "delete");
+        let _name = "" + name;
+        let index = -1;
+        let array = this[state][_urlspArray];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (args.length !== 1 && item[1] !== normalizeValue(value)) {
+                    result.push(item);
+                }
+                index = i;
+                continue;
+            }
+            result.push(item);
+        }
+        if (index > -1) {
+            this[state][_urlspArray] = result;
+        }
+    }
+    get(...args) {
+        const [name] = args;
+        checkArgsFn(args, 1, "get");
+        let _name = "" + name;
+        let array = this[state][_urlspArray];
+        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][_urlspArray];
+        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, value] = args;
+        checkArgsFn(args, 1, "has");
+        let _name = "" + name;
+        let array = this[state][_urlspArray];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            if (item[0] === _name) {
+                if (args.length === 1) {
+                    return true;
+                }
+                else {
+                    if (item[1] === normalizeValue(value)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    set(...args) {
+        const [name, value] = args;
+        checkArgsFn(args, 2, "set");
+        let _name = "" + name;
+        let _value = normalizeValue(value);
+        let index = -1;
+        let array = this[state][_urlspArray];
+        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([_name, _value]);
+                }
+                continue;
+            }
+            result.push(item);
+        }
+        if (index === -1) {
+            result.push([_name, _value]);
+        }
+        this[state][_urlspArray] = result;
+    }
+    sort() {
+        this[state][_urlspArray].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    }
+    forEach(...args) {
+        const [callbackfn, thisArg] = args;
+        checkArgsFn(args, 1, "forEach");
+        if (typeof callbackfn !== "function") {
+            throw new TypeError("Failed to execute 'forEach' on 'URLSearchParams': parameter 1 is not of type 'Function'.");
+        }
+        let array = this[state][_urlspArray];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            callbackfn.call(thisArg, item[1], item[0], this);
+        }
+    }
+    entries() {
+        return this[state][_urlspArray].map(x => [x[0], x[1]]).values();
+    }
+    keys() {
+        return this[state][_urlspArray].map(x => x[0]).values();
+    }
+    values() {
+        return this[state][_urlspArray].map(x => x[1]).values();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    toString() {
+        let array = this[state][_urlspArray];
+        let result = [];
+        for (let i = 0; i < array.length; ++i) {
+            let item = array[i];
+            result.push(encode(item[0]) + "=" + encode(item[1]));
+        }
+        return result.join("&");
+    }
+    /** @internal */ get [Symbol.toStringTag]() { return "URLSearchParams"; }
+    /** @internal */ get isPolyfill() { return { symbol: isPolyfill.polyfill, hierarchy: ["URLSearchParams"] }; }
+}
+/** @internal */
+const _urlspArray = Symbol();
+/** @internal */
+class URLSearchParamsState {
+    constructor() {
+        this[_a] = [];
+    }
+}
+_a = _urlspArray;
+function normalizeValue(value) {
+    return typeof value === "string" ? value : (value !== null && value !== undefined && typeof value.toString === "function"
+        ? value.toString()
+        : JSON.stringify(value));
+}
+function encode(str) {
+    const replace = {
+        "!": "%21",
+        "'": "%27",
+        "(": "%28",
+        ")": "%29",
+        "~": "%7E",
+        "%20": "+",
+        "%00": "\x00",
+    };
+    return encodeURIComponent(str).replace(/[!'\(\)~]|%20|%00/g, match => replace[match]);
+}
+function decode(str) {
+    return str
+        .replace(/[ +]/g, "%20")
+        .replace(/(%[a-f0-9]{2})+/ig, match => decodeURIComponent(match));
+}
+const URLSearchParamsE = isPolyfill.g["URLSearchParams"] || URLSearchParamsP;
+
+exports.URLSearchParams = URLSearchParamsE;
+exports.URLSearchParamsP = URLSearchParamsP;