fetch-xhr-shim 0.0.1-beta

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

@@ -0,0 +1,121 @@
+import { checkArgsLength, setState, className, _Symbol } from '../utils.js';
+
+class EventP {
+    static get NONE() { return 0; }
+    static get CAPTURING_PHASE() { return 1; }
+    static get AT_TARGET() { return 2; }
+    static get BUBBLING_PHASE() { return 3; }
+    constructor(type, eventInitDict) {
+        checkArgsLength(arguments.length, 1, "Event");
+        setState(this, "__Event__", new EventState());
+        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 s.isTrusted === "YES"; },
+        });
+    }
+    get NONE() { return 0; }
+    get CAPTURING_PHASE() { return 1; }
+    get AT_TARGET() { return 2; }
+    get BUBBLING_PHASE() { return 3; }
+    get bubbles() { return state(this).bubbles; }
+    get cancelBubble() { return state(this).cancelBubble; }
+    set cancelBubble(value) { if (value) {
+        state(this).cancelBubble = true;
+    } }
+    get cancelable() { return state(this).cancelable; }
+    get composed() { return state(this).composed; }
+    get currentTarget() { return state(this).currentTarget; }
+    get defaultPrevented() { return state(this).defaultPrevented; }
+    get eventPhase() { return state(this).eventPhase; }
+    get returnValue() { return state(this).returnValue; }
+    set returnValue(value) { if (!value) {
+        this.preventDefault();
+    } }
+    get srcElement() { return state(this).target; }
+    get target() { return state(this).target; }
+    get timeStamp() { return state(this).timeStamp; }
+    get type() { return state(this).type; }
+    composedPath() {
+        let path = this.target ? [this.target] : [];
+        if (this.currentTarget && this.currentTarget !== this.target)
+            path.push(this.currentTarget);
+        return path;
+    }
+    initEvent(type, bubbles, cancelable) {
+        checkArgsLength(arguments.length, 1, className(this), "initEvent");
+        let s = state(this);
+        if (s.eventDispatched)
+            return;
+        s.type = "" + type;
+        s.bubbles = !!bubbles;
+        s.cancelable = !!cancelable;
+    }
+    preventDefault() {
+        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) {
+            s.defaultPrevented = true;
+            s.returnValue = false;
+        }
+    }
+    stopImmediatePropagation() {
+        state(this).immediatePropagationStopped = true;
+        this.cancelBubble = true;
+    }
+    stopPropagation() {
+        this.cancelBubble = true;
+    }
+    /** @internal */ toString() { return "[object Event]"; }
+    /** @internal */ get [_Symbol.toStringTag]() { return "Event"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["Event"] }; }
+}
+/** @internal */
+class EventState {
+    constructor() {
+        this.bubbles = false;
+        this.cancelBubble = false;
+        this.cancelable = false;
+        this.composed = false;
+        this.currentTarget = null;
+        this.defaultPrevented = false;
+        this.eventPhase = 0 /* NONE */;
+        this.returnValue = true;
+        this.target = null;
+        this.timeStamp = (new Date()).getTime() - timeStamp;
+        this.type = "";
+        this.passive = false;
+        this.eventDispatched = false;
+        this.immediatePropagationStopped = false;
+        Object.defineProperty(this, "isTrusted", createTrustedPropertyDescriptor());
+    }
+}
+function state(target) {
+    return target.__Event__;
+}
+const timeStamp = (new Date()).getTime();
+function createTrustedPropertyDescriptor() {
+    let name = createTrustedPropertyDescriptor.name;
+    let idx = name.length;
+    let isTrusted = "NO";
+    return {
+        configurable: false,
+        enumerable: true,
+        get: function () { return isTrusted; },
+        set: function (value) { if (name === value.slice(0, idx)) {
+            isTrusted = value.slice(idx + 1);
+        } },
+    };
+}
+function Event_setTrusted(event, isTrusted) {
+    let s = state(event) || {};
+    s.isTrusted = `${createTrustedPropertyDescriptor.name}:${isTrusted ? "YES" : "NO"}`;
+}
+const EventE = (typeof Event !== "undefined" && Event) || EventP;
+
+export { EventE as Event, EventP, Event_setTrusted };

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

@@ -0,0 +1,174 @@
+import { Event_setTrusted } from './EventP.js';
+import { setState, checkArgsLength, className, isPolyfillType, _Symbol } from '../utils.js';
+
+class EventTargetP {
+    constructor() {
+        setState(this, "__EventTarget__", new EventTargetState());
+    }
+    addEventListener(type, callback, options) {
+        checkArgsLength(arguments.length, 2, className(this), "addEventListener");
+        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) || { executors: [] };
+        let executor = new Executor(type, callback);
+        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) && !signal.aborted) {
+                    executor.options.signal = signal;
+                    whenAbort(this, executor, signal);
+                }
+            }
+            if (capture) {
+                let f = (v) => !!v.options.capture ? 0 : 1;
+                s.executors = s.executors.sort((a, b) => f(a) - f(b));
+            }
+        }
+    }
+    dispatchEvent(event) {
+        checkArgsLength(arguments.length, 1, className(this), "dispatchEvent");
+        if (isPolyfillType("Event", event)) {
+            Event_setTrusted(event, false);
+        }
+        else if (!isEvent(event)) {
+            throw new TypeError(`Failed to execute 'dispatchEvent' on '${className(this)}': parameter 1 is not of type 'Event'.`);
+        }
+        else {
+            console.warn(`WARNING: undefined behavior when executing 'dispatchEvent' on '${className(this)}': parameter 1 is not of type 'Event(P)'.`);
+        }
+        return EventTarget_dispatchEvent(this, event);
+    }
+    removeEventListener(type, callback, options) {
+        checkArgsLength(arguments.length, 2, className(this), "removeEventListener");
+        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) || { executors: [] };
+        let executor = new Executor(type, callback);
+        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 = s.executors.filter(x => !x.equals(executor));
+        }
+    }
+    /** @internal */ toString() { return "[object EventTarget]"; }
+    /** @internal */ get [_Symbol.toStringTag]() { return "EventTarget"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["EventTarget"] }; }
+}
+/** @internal */
+class EventTargetState {
+    constructor() {
+        this.executors = [];
+    }
+}
+function state(target) {
+    return target.__EventTarget__;
+}
+function isEvent(value) {
+    const predicate = (str) => { return "[object " === str.slice(0, 8) && str.slice(-6) === "Event]"; };
+    return !!value
+        && typeof value === "object"
+        && (predicate(Object.prototype.toString.call(value)) || predicate(String(value)))
+        && "type" in value
+        && typeof value.type === "string";
+}
+function whenAbort(target, executor, signal) {
+    const onAbort = () => {
+        state(target).executors = state(target).executors.filter(x => !x.equals(executor));
+        signal.removeEventListener("abort", onAbort);
+    };
+    signal.addEventListener("abort", onAbort);
+}
+/** @internal */
+class Executor {
+    constructor(type, callback) {
+        this.options = {};
+        this.type = "" + type;
+        this.callback = extract(callback);
+    }
+    equals(executor) {
+        return Object.is(this.type, executor.type)
+            && Object.is(this.callback, executor.callback)
+            && Object.is(this.options.capture, executor.options.capture);
+    }
+}
+function extract(cb) {
+    return typeof cb === "function" ? cb : isEventListenerObject(cb) ? cb.handleEvent : cb;
+}
+function isEventListenerObject(cb) {
+    return !!cb && typeof cb === "object" && "handleEvent" in cb && typeof cb.handleEvent === "function";
+}
+function EventTarget_dispatchEvent(target, event) {
+    const s = state(target) || {};
+    const evs = event.__Event__ || {};
+    evs.target = target;
+    evs.currentTarget = target;
+    evs.eventPhase = 2 /* AT_TARGET */;
+    evs.eventDispatched = true;
+    let onceIndexes = [];
+    if (!Array.isArray(s.executors)) {
+        s.executors = [];
+    }
+    for (let i = 0; i < s.executors.length; ++i) {
+        if (evs.immediatePropagationStopped)
+            break;
+        let executor = s.executors[i];
+        if (executor.type !== event.type)
+            continue;
+        if (executor.options.once)
+            onceIndexes.push(i);
+        evs.passive = !!executor.options.passive;
+        try {
+            let cb = executor.callback;
+            if (typeof cb === "function")
+                cb.call(target, event);
+        }
+        catch (e) {
+            console.error(e);
+        }
+        evs.passive = false;
+    }
+    if (onceIndexes.length > 0) {
+        s.executors = s.executors.reduce((acc, cur, index) => {
+            if (onceIndexes.indexOf(index) === -1)
+                acc.push(cur);
+            return acc;
+        }, []);
+    }
+    evs.currentTarget = null;
+    evs.eventPhase = 0 /* NONE */;
+    evs.eventDispatched = false;
+    return !(event.cancelable && event.defaultPrevented);
+}
+function attachFn(target, handlers) {
+    return function attach(type) {
+        const fnName = ("on" + type);
+        const callback = target[fnName];
+        const listener = handlers[fnName];
+        typeof callback === "function"
+            ? EventTargetP.prototype.addEventListener.call(target, type, listener)
+            : EventTargetP.prototype.removeEventListener.call(target, type, listener);
+    };
+}
+function executeFn(target, cb, ev) {
+    if (typeof cb === "function")
+        cb.call(target, ev);
+}
+function isEventTarget(value) {
+    return isPolyfillType("EventTarget", value) || isExternalEventTarget(value);
+}
+function isExternalEventTarget(value) {
+    return !!value
+        && typeof value === "object"
+        && "addEventListener" in value
+        && typeof value.addEventListener === "function"
+        && "removeEventListener" in value
+        && typeof value.removeEventListener === "function";
+}
+const EventTargetE = (typeof EventTarget !== "undefined" && EventTarget) || EventTargetP;
+
+export { EventTargetE as EventTarget, EventTargetP, EventTarget_dispatchEvent, attachFn, executeFn, isEventTarget };

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

@@ -0,0 +1,51 @@
+import { setState, _Symbol } from '../utils.js';
+import { Event_setTrusted, EventP } from './EventP.js';
+import { EventTarget_dispatchEvent } from './EventTargetP.js';
+
+const fields = ["loaded", "total"];
+class ProgressEventP extends EventP {
+    constructor(type, eventInitDict) {
+        var _a, _b;
+        super(type, eventInitDict);
+        setState(this, "__ProgressEvent__", new ProgressEventState());
+        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);
+        for (let i = 0; i < fields.length; ++i) {
+            let field = fields[i];
+            if (isNaN(this[field])) {
+                throw new TypeError(`Failed to construct 'ProgressEvent': Failed to read the '${field}' property from 'ProgressEventInit': The provided double value is non-finite.`);
+            }
+        }
+    }
+    get lengthComputable() { return state(this).lengthComputable; }
+    get loaded() { return state(this).loaded; }
+    get total() { return state(this).total; }
+    /** @internal */ toString() { return "[object ProgressEvent]"; }
+    /** @internal */ get [_Symbol.toStringTag]() { return "ProgressEvent"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["ProgressEvent", "Event"] }; }
+}
+/** @internal */
+class ProgressEventState {
+    constructor() {
+        this.lengthComputable = false;
+        this.loaded = 0;
+        this.total = 0;
+    }
+}
+function state(target) {
+    return target.__ProgressEvent__;
+}
+function emitProgressEvent(target, type, loaded = 0, total = 0) {
+    let event = new ProgressEventP(type, {
+        lengthComputable: total > 0,
+        loaded,
+        total,
+    });
+    event.__Event__.target = target;
+    Event_setTrusted(event, true);
+    EventTarget_dispatchEvent(target, event);
+}
+
+export { ProgressEventP, emitProgressEvent };

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

@@ -0,0 +1,172 @@
+import { setState, className, _Symbol, isObjectType } from '../utils.js';
+import { isArrayBuffer } from '../encoding/TextDecoderP.js';
+import { isURLSearchParams } from '../network/URLSearchParamsP.js';
+import { encode, isBlob, decode, Blob as BlobE } from '../file-system/BlobP.js';
+import { isFormData, FormData_toBlob, extractBoundary, createFormDataFromBinaryText } from '../network/FormDataP.js';
+
+class Payload {
+    constructor(body, contentType) {
+        this._type = "";
+        if (contentType) {
+            this.type = contentType;
+        }
+        if (typeof body === "string") {
+            this.promise = Promise.resolve(body);
+            this.type = "text/plain;charset=UTF-8";
+            this.calcLength = () => encode(body).length;
+        }
+        else if (isURLSearchParams(body)) {
+            let _body = body.toString();
+            this.promise = Promise.resolve(_body);
+            this.type = "application/x-www-form-urlencoded;charset=UTF-8";
+            this.calcLength = () => encode(_body).length;
+        }
+        else if (isArrayBuffer(body)) {
+            this.promise = Promise.resolve(body.slice(0));
+            this.length = body.byteLength;
+        }
+        else if (ArrayBuffer.isView(body)) {
+            let _body = body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength);
+            this.promise = Promise.resolve(_body);
+            this.length = _body.byteLength;
+        }
+        else if (isBlob(body)) {
+            this.promise = body.arrayBuffer();
+            this.type = body.type;
+            this.length = body.size;
+        }
+        else if (isFormData(body)) {
+            let _body = FormData_toBlob(body, contentType ? extractBoundary(contentType) : undefined);
+            this.promise = _body.arrayBuffer();
+            this.type = _body.type;
+            this.length = _body.size;
+        }
+        else if (body === null || body === undefined) {
+            this.promise = Promise.resolve("");
+            this.length = 0;
+        }
+        else {
+            let _body = "" + body;
+            this.promise = Promise.resolve(_body);
+            this.type = "text/plain;charset=UTF-8";
+            this.calcLength = () => encode(_body).length;
+        }
+    }
+    get type() { return this._type; }
+    set type(value) { if (!this._type)
+        this._type = value; }
+    get size() {
+        var _a;
+        if (typeof this.length !== "number" && this.calcLength)
+            this.length = this.calcLength();
+        return (_a = this.length) !== null && _a !== void 0 ? _a : 0;
+    }
+    text() { return this.promise.then(r => typeof r === "string" ? r : decode(r)); }
+    arrayBuffer() { return this.promise.then(r => isArrayBuffer(r) ? r : encode(r).buffer); }
+}
+class BodyImpl {
+    /** @internal */
+    constructor() {
+        if (new.target === BodyImpl) {
+            throw new TypeError("Failed to construct 'Body': Illegal constructor");
+        }
+        setState(this, "__Body__", new BodyState());
+    }
+    get bodyUsed() { return state(this).bodyUsed; }
+    ;
+    get body() {
+        throw new TypeError(`Failed to access 'body' on '${className(this)}': property not implemented.`);
+    }
+    arrayBuffer() {
+        const kind = "arrayBuffer";
+        return consumed(this, kind) || read(this, kind);
+    }
+    blob() {
+        const kind = "blob";
+        return consumed(this, kind) || read(this, kind);
+    }
+    bytes() {
+        const kind = "bytes";
+        return consumed(this, kind) || read(this, kind);
+    }
+    formData() {
+        const kind = "formData";
+        return consumed(this, kind) || read(this, kind);
+    }
+    json() {
+        const kind = "json";
+        return consumed(this, kind) || read(this, kind);
+    }
+    text() {
+        const kind = "text";
+        return consumed(this, kind) || read(this, kind);
+    }
+    /** @internal */ toString() { return "[object Body]"; }
+    /** @internal */ get [_Symbol.toStringTag]() { return "Body"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["Body"] }; }
+}
+/** @internal */
+class BodyState {
+    constructor() {
+        this.bodyUsed = false;
+    }
+}
+function state(target) {
+    return target.__Body__;
+}
+function initBody(instance, body) {
+    const b = instance;
+    if (isGlobalReadableStream(body) || isOtherReadableStream(body)) {
+        throw new TypeError(`Failed to construct '${className(b)}': ReadableStream not implemented.`);
+    }
+    if (body !== null && body !== undefined) {
+        state(b).payload = new Payload(body);
+    }
+}
+function read(body, kind) {
+    let payload = state(body).payload || new Payload();
+    if (kind === "json") {
+        return payload.text().then(r => JSON.parse(r));
+    }
+    else if (kind === "text") {
+        return payload.text();
+    }
+    else if (kind === "arrayBuffer") {
+        return payload.arrayBuffer();
+    }
+    else if (kind === "bytes") {
+        return payload.arrayBuffer().then(r => new Uint8Array(r));
+    }
+    else if (kind === "blob") {
+        return payload.promise.then(r => new BlobE([r]));
+    }
+    else if (kind === "formData") {
+        return payload.text().then(r => createFormDataFromBinaryText(r, extractBoundary(payload.type)));
+    }
+    else {
+        return payload.promise;
+    }
+}
+function consumed(body, kind) {
+    if (!state(body).payload)
+        return;
+    if (!body.bodyUsed) {
+        state(body).bodyUsed = true;
+        return;
+    }
+    return Promise.reject(new TypeError(`Failed to execute '${kind}' on '${className(body)}': body stream already read`));
+}
+function isGlobalReadableStream(value) {
+    return !!value &&
+        typeof value === "object" &&
+        typeof ReadableStream !== "undefined" &&
+        ReadableStream &&
+        ReadableStream.prototype.isPrototypeOf(value);
+}
+function isOtherReadableStream(value) {
+    return (isObjectType("ReadableStream", value) || String(value) === "[object ReadableStream]")
+        && "getReader" in value
+        && typeof value.getReader === "function";
+}
+
+export { BodyImpl, Payload, initBody };

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

@@ -0,0 +1,176 @@
+import { setState, isSequence, _Symbol, isPolyfillType, checkArgsLength } from '../utils.js';
+
+class HeadersP {
+    constructor(init) {
+        setState(this, "__Headers__", new HeadersState());
+        if (init !== undefined) {
+            if (isHeaders(init)) {
+                init.forEach((value, name) => { Headers_append(this, name, value, ""); }, this);
+            }
+            else if (isSequence(init)) {
+                let _init = Array.isArray(init) ? init : Array.from(init);
+                for (let i = 0; i < _init.length; ++i) {
+                    let item = _init[i];
+                    if (isSequence(item)) {
+                        let pair = Array.isArray(item) ? item : Array.from(item);
+                        if (pair.length === 2) {
+                            Headers_append(this, pair[0], pair[1]);
+                        }
+                        else {
+                            throw new TypeError("Failed to construct 'Headers': Invalid value");
+                        }
+                    }
+                    else {
+                        throw new TypeError("Failed to construct 'Headers': The provided value cannot be converted to a sequence.");
+                    }
+                }
+            }
+            else {
+                if (init && typeof init === "object") {
+                    Object.getOwnPropertyNames(init).forEach(name => { Headers_append(this, name, init[name]); }, this);
+                }
+                else {
+                    throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(record<ByteString, ByteString> or sequence<sequence<ByteString>>)'.");
+                }
+            }
+        }
+    }
+    append(name, value) {
+        checkArgsFn(arguments.length, 2, "append");
+        Headers_append(this, name, value, "append");
+    }
+    delete(name) {
+        checkArgsFn(arguments.length, 1, "delete");
+        delete state(this).dict[normalizeName(name, throwsFn("delete"))];
+    }
+    get(name) {
+        var _a;
+        checkArgsFn(arguments.length, 1, "get");
+        return (_a = state(this).dict[normalizeName(name, throwsFn("get"))]) !== null && _a !== void 0 ? _a : null;
+    }
+    getSetCookie() {
+        let value = this.get("Set-Cookie");
+        return value ? value.split(", ") : [];
+    }
+    has(name) {
+        checkArgsFn(arguments.length, 1, "has");
+        return state(this).dict.hasOwnProperty(normalizeName(name, throwsFn("has")));
+    }
+    set(name, value) {
+        checkArgsFn(arguments.length, 2, "set");
+        state(this).dict[normalizeName(name, throwsFn("set"))] = normalizeValue(value);
+    }
+    forEach(callbackfn, thisArg) {
+        checkArgsFn(arguments.length, 1, "forEach");
+        if (typeof callbackfn !== "function") {
+            throw new TypeError("Failed to execute 'forEach' on 'Headers': parameter 1 is not of type 'Function'.");
+        }
+        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, dict[name], name, this);
+        }
+    }
+    entries() {
+        let array = [];
+        this.forEach((value, name) => { array.push([name, value]); });
+        return array.values();
+    }
+    keys() {
+        let array = [];
+        this.forEach((value, name) => { array.push([name, value]); });
+        return array.map(x => x[0]).values();
+    }
+    values() {
+        let array = [];
+        this.forEach((value, name) => { array.push([name, value]); });
+        return array.map(x => x[1]).values();
+    }
+    // @ts-ignore
+    /** @internal */ [_Symbol.iterator]() {
+        return this.entries();
+    }
+    /** @internal */ toString() { return "[object Headers]"; }
+    /** @internal */ get [_Symbol.toStringTag]() { return "Headers"; }
+    /** @internal */ get __MPHTTPX__() { return { chain: ["Headers"] }; }
+}
+/** @internal */
+class HeadersState {
+    constructor() {
+        this.dict = {};
+    }
+}
+function state(target) {
+    return target.__Headers__;
+}
+function Headers_append(headers, name, value, kind = "constructor") {
+    let _name = normalizeName(name, kind ? throwsFn(kind) : undefined);
+    let _value = normalizeValue(value);
+    let dict = state(headers).dict;
+    let oldValue = dict[_name];
+    dict[_name] = oldValue !== undefined ? `${oldValue}, ${_value}` : _value;
+}
+function throwsFn(kind) {
+    return () => {
+        throw new TypeError(`Failed to ${(kind && kind !== "constructor") ? ("execute '" + kind + "' on") : "construct"} 'Headers': Invalid name`);
+    };
+}
+function checkArgsFn(actual, expect, funcName) {
+    checkArgsLength(actual, expect, "Headers", funcName);
+}
+function isHeaders(value) {
+    return isPolyfillType("Headers", value) || isExternalHeaders(value);
+}
+function isExternalHeaders(value) {
+    let expect = "[object Headers]";
+    return (Object.prototype.toString.call(value) === expect || String(value) === expect)
+        && "forEach" in value
+        && typeof value.forEach === "function";
+}
+function normalizeName(name, throwError) {
+    if (typeof name !== "string") {
+        name = "" + name;
+    }
+    if (throwError && (/[^a-z0-9\-#$%&'*+.^_`|~!]/i.test(name) || name === "")) {
+        throwError();
+    }
+    return name.toLowerCase();
+}
+function normalizeValue(value) {
+    return typeof value === "string" ? value : ("" + value);
+}
+function parseHeaders(rawHeaders) {
+    let headers = new HeadersE();
+    let preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, " ");
+    preProcessedHeaders
+        .split("\r")
+        .map(header => header.indexOf("\n") === 0 ? header.substring(1, header.length) : header)
+        .forEach(line => {
+        let parts = line.split(":");
+        let name = parts.shift().trim();
+        if (name) {
+            let value = parts.join(":").trim();
+            try {
+                headers.append(name, value);
+            }
+            catch (e) {
+                console.warn(`SyntaxError: Response.headers: '${name}' is not a valid HTTP header field name.`);
+            }
+        }
+    });
+    return headers;
+}
+function createHeaders(headers) {
+    if (isPolyfillType("Headers", headers)) {
+        if (!Object.is(HeadersE, HeadersP)) {
+            let _headers = new HeadersE();
+            headers.forEach((v, k) => { _headers.append(k, v); });
+            return _headers;
+        }
+    }
+    return new HeadersE(headers);
+}
+const HeadersE = (typeof Headers !== "undefined" && Headers) || HeadersP;
+
+export { HeadersE as Headers, HeadersP, createHeaders, isHeaders, normalizeName, normalizeValue, parseHeaders };