keq 2.0.1 → 2.0.3

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [2.0.3](https://www.github.com/keq-request/keq/compare/v2.0.2...v2.0.3) (2023-09-27)
+
+
+### Bug Fixes
+
+* cannot find dist/umd/src/index.js ([9264923](https://www.github.com/keq-request/keq/commit/9264923e606fc5bc28675c751910e1eb3a30b864))
+
+### [2.0.2](https://www.github.com/keq-request/keq/compare/v2.0.1...v2.0.2) (2023-09-27)
+
+
+### Bug Fixes
+
+* cannot import umd package ([4eb05b3](https://www.github.com/keq-request/keq/commit/4eb05b35a41fd7b00e21ae5978eb3dc3900a3bdc))
+
 ### [2.0.1](https://www.github.com/keq-request/keq/compare/v2.0.0...v2.0.1) (2023-09-27)
 
 

package/dist/umd/src/constant.d.ts

@@ -0,0 +1 @@
+export declare const OUTPUT_PROPERTY: unique symbol;

package/dist/umd/src/constant.js

@@ -0,0 +1,14 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OUTPUT_PROPERTY = void 0;
+    exports.OUTPUT_PROPERTY = Symbol('outputProperty');
+});

package/dist/umd/src/core.d.ts

@@ -0,0 +1,28 @@
+import { URL } from 'whatwg-url';
+import { KeqRequestContext } from './types/keq-context';
+import { KeqMiddleware } from './types/keq-middleware';
+import { KeqOptions } from './types/keq-options';
+import { KeqRequestInit } from './types/keq-request-init';
+/**
+ * @description Keq 核心 API，发送请求必要的原子化的API
+ */
+export declare class Core<T> {
+    private requestPromise?;
+    protected requestContext: KeqRequestContext;
+    protected __prepend_middlewares__: KeqMiddleware[];
+    protected __append_middlewares__: KeqMiddleware[];
+    protected __options__: KeqOptions;
+    constructor(url: (URL | globalThis.URL), init: KeqRequestInit);
+    prependMiddlewares(...middlewares: KeqMiddleware[]): this;
+    appendMiddlewares(...middlewares: KeqMiddleware[]): this;
+    private run;
+    end(): Promise<T>;
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+}

package/dist/umd/src/core.js

@@ -0,0 +1,125 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "whatwg-url", "./exception/exception", "./util/clone", "./constant", "./middleware", "./util/shadow-clone"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Core = void 0;
+    const whatwg_url_1 = require("whatwg-url");
+    const exception_1 = require("./exception/exception");
+    const clone_1 = require("./util/clone");
+    const constant_1 = require("./constant");
+    const middleware_1 = require("./middleware");
+    const shadow_clone_1 = require("./util/shadow-clone");
+    /**
+     * @description Keq 核心 API，发送请求必要的原子化的API
+     */
+    class Core {
+        requestPromise;
+        requestContext;
+        __prepend_middlewares__ = [];
+        __append_middlewares__ = [];
+        __options__ = { resolveWithFullResponse: false };
+        constructor(url, init) {
+            this.requestContext = {
+                method: 'get',
+                headers: new Headers(),
+                routeParams: {},
+                body: undefined,
+                ...init,
+                url: new whatwg_url_1.URL(url.href),
+            };
+        }
+        prependMiddlewares(...middlewares) {
+            this.__prepend_middlewares__.push(...middlewares);
+            return this;
+        }
+        appendMiddlewares(...middlewares) {
+            this.__append_middlewares__.unshift(...middlewares);
+            return this;
+        }
+        async run() {
+            const headers = new Headers();
+            for (const [key, value] of this.requestContext.headers.entries()) {
+                headers.append(key, value);
+            }
+            const requestContext = {
+                method: this.requestContext.method,
+                url: new whatwg_url_1.URL(this.requestContext.url.href),
+                headers,
+                routeParams: (0, shadow_clone_1.shadowClone)(this.requestContext.routeParams),
+                body: (0, clone_1.clone)(this.requestContext.body),
+            };
+            const options = (0, shadow_clone_1.shadowClone)(this.__options__);
+            const ctx = {
+                request: requestContext,
+                options,
+                get output() {
+                    throw new exception_1.Exception('output property is write-only');
+                },
+                set output(value) {
+                    this[constant_1.OUTPUT_PROPERTY] = value;
+                },
+            };
+            const middleware = (0, middleware_1.composeMiddleware)([...this.__prepend_middlewares__, ...this.__append_middlewares__]);
+            // eslint-disable-next-line @typescript-eslint/no-empty-function
+            await middleware(ctx, async () => { });
+            let output = ctx[constant_1.OUTPUT_PROPERTY];
+            if (ctx.options.resolveWithFullResponse) {
+                return ctx.response;
+            }
+            if (!(constant_1.OUTPUT_PROPERTY in ctx)) {
+                const response = ctx.response;
+                if (response?.status === 204) {
+                    // 204: NO CONTENT
+                    output = response && response.body;
+                }
+                else {
+                    const headers = response?.headers;
+                    const contentType = headers?.get('content-type') || '';
+                    try {
+                        if (contentType.includes('application/json')) {
+                            output = ctx.response && await ctx.response.json();
+                        }
+                        else if (contentType.includes('multipart/form-data')) {
+                            output = ctx.response && await ctx.response.formData();
+                        }
+                        else if (contentType.includes('plain/text')) {
+                            output = ctx.response && await ctx.response.text();
+                        }
+                        else {
+                            output = ctx.response && ctx.response.body;
+                        }
+                    }
+                    catch (e) {
+                        console.warn('Failed to auto parse response body', e);
+                    }
+                }
+            }
+            return output;
+        }
+        async end() {
+            return this.run();
+        }
+        /**
+         * Attaches callbacks for the resolution and/or rejection of the Promise.
+         * @param onfulfilled The callback to execute when the Promise is resolved.
+         * @param onrejected The callback to execute when the Promise is rejected.
+         * @returns A Promise for the completion of which ever callback is executed.
+         */
+        then(onfulfilled, onrejected) {
+            if (!this.requestPromise)
+                this.requestPromise = this.end();
+            return this.requestPromise.then(onfulfilled, onrejected);
+        }
+        catch(onrejected) {
+            return this.end().catch(onrejected);
+        }
+    }
+    exports.Core = Core;
+});

package/dist/umd/src/create-request.d.ts

@@ -0,0 +1,8 @@
+import { KeqMiddleware } from './types/keq-middleware';
+import { KeqRequest } from './types/keq-request';
+interface CreateRequestOptions {
+    initMiddlewares?: KeqMiddleware[];
+    baseOrigin?: string;
+}
+export declare function createRequest(options?: CreateRequestOptions): KeqRequest;
+export {};

package/dist/umd/src/create-request.js

@@ -0,0 +1,126 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "whatwg-url", "./router/keq-host-router", "./router/keq-location-router", "./router/keq-method-router", "./router/keq-module-router", "./router/keq-pathname-router", "./is/is-browser", "./keq", "./middlewares/fetch-arguments-middleware", "./middlewares/fetch-middleware", "./middlewares/proxy-response-middleware", "./middlewares/retry-middleware"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createRequest = void 0;
+    /* eslint-disable @typescript-eslint/no-unsafe-return */
+    const whatwg_url_1 = require("whatwg-url");
+    const keq_host_router_1 = require("./router/keq-host-router");
+    const keq_location_router_1 = require("./router/keq-location-router");
+    const keq_method_router_1 = require("./router/keq-method-router");
+    const keq_module_router_1 = require("./router/keq-module-router");
+    const keq_pathname_router_1 = require("./router/keq-pathname-router");
+    const is_browser_1 = require("./is/is-browser");
+    const keq_1 = require("./keq");
+    const fetch_arguments_middleware_1 = require("./middlewares/fetch-arguments-middleware");
+    const fetch_middleware_1 = require("./middlewares/fetch-middleware");
+    const proxy_response_middleware_1 = require("./middlewares/proxy-response-middleware");
+    const retry_middleware_1 = require("./middlewares/retry-middleware");
+    function createRequest(options) {
+        let baseOrigin = options?.baseOrigin;
+        if ((0, is_browser_1.isBrowser)() && !baseOrigin)
+            baseOrigin = location.origin;
+        const appendMiddlewares = options?.initMiddlewares ? [...options.initMiddlewares] : [
+            (0, proxy_response_middleware_1.proxyResponseMiddleware)(),
+            (0, fetch_arguments_middleware_1.fetchArgumentsMiddleware)(),
+            (0, retry_middleware_1.retryMiddleware)(),
+            (0, fetch_middleware_1.fetchMiddleware)(),
+        ];
+        const prependMiddlewares = [];
+        const formatUrl = (url) => {
+            if (typeof url === 'string') {
+                return new whatwg_url_1.URL(url, baseOrigin);
+            }
+            return new whatwg_url_1.URL(url.href);
+        };
+        const routerMap = {
+            host: (host, ...middlewares) => {
+                const route = new keq_host_router_1.KeqHostRouter(host, middlewares);
+                prependMiddlewares.push(route.routes());
+                return routerMap;
+            },
+            method: (method, ...middlewares) => {
+                const route = new keq_method_router_1.KeqMethodRouter(method, middlewares);
+                prependMiddlewares.push(route.routes());
+                return routerMap;
+            },
+            pathname: (pathname, ...middlewares) => {
+                const route = new keq_pathname_router_1.KeqPathnameRouter(pathname, middlewares);
+                prependMiddlewares.push(route.routes());
+                return routerMap;
+            },
+            location: (...middlewares) => {
+                const route = new keq_location_router_1.KeqLocationRouter(middlewares);
+                prependMiddlewares.push(route.routes());
+                return routerMap;
+            },
+            module: (moduleName, ...middlewares) => {
+                const route = new keq_module_router_1.KeqModuleRouter(moduleName, middlewares);
+                prependMiddlewares.push(route.routes());
+                return routerMap;
+            },
+        };
+        const request = function (url, init) {
+            const keq = new keq_1.Keq(formatUrl(url), init);
+            keq.appendMiddlewares(...appendMiddlewares);
+            keq.prependMiddlewares(...prependMiddlewares);
+            return keq;
+        };
+        request.baseOrigin = (origin) => {
+            baseOrigin = origin;
+        };
+        request.useRouter = function useRouter() {
+            return routerMap;
+        };
+        request.get = function (url) {
+            const keq = new keq_1.Keq(formatUrl(url), { method: 'get' });
+            keq.appendMiddlewares(...appendMiddlewares);
+            keq.prependMiddlewares(...prependMiddlewares);
+            return keq;
+        };
+        request.put = function (url) {
+            const keq = new keq_1.Keq(formatUrl(url), { method: 'put' });
+            keq.appendMiddlewares(...appendMiddlewares);
+            keq.prependMiddlewares(...prependMiddlewares);
+            return keq;
+        };
+        request.delete = function (url) {
+            const keq = new keq_1.Keq(formatUrl(url), { method: 'delete' });
+            keq.appendMiddlewares(...appendMiddlewares);
+            keq.prependMiddlewares(...prependMiddlewares);
+            return keq;
+        };
+        request.del = request.delete;
+        request.post = function (url) {
+            const keq = new keq_1.Keq(formatUrl(url), { method: 'post' });
+            keq.appendMiddlewares(...appendMiddlewares);
+            keq.prependMiddlewares(...prependMiddlewares);
+            return keq;
+        };
+        request.head = function (url) {
+            const keq = new keq_1.Keq(formatUrl(url), { method: 'head' });
+            keq.appendMiddlewares(...appendMiddlewares);
+            keq.prependMiddlewares(...prependMiddlewares);
+            return keq;
+        };
+        request.patch = function (url) {
+            const keq = new keq_1.Keq(formatUrl(url), { method: 'patch' });
+            keq.appendMiddlewares(...appendMiddlewares);
+            keq.prependMiddlewares(...prependMiddlewares);
+            return keq;
+        };
+        request.use = function use(middleware, ...middlewares) {
+            prependMiddlewares.push(middleware, ...middlewares);
+            return request;
+        };
+        return request;
+    }
+    exports.createRequest = createRequest;
+});

package/dist/umd/src/exception/exception.d.ts

@@ -0,0 +1,4 @@
+import { CustomError } from 'ts-custom-error';
+export declare class Exception extends CustomError {
+    constructor(message?: string);
+}

package/dist/umd/src/exception/exception.js

@@ -0,0 +1,21 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "ts-custom-error"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Exception = void 0;
+    const ts_custom_error_1 = require("ts-custom-error");
+    class Exception extends ts_custom_error_1.CustomError {
+        constructor(message) {
+            super(message);
+            Object.defineProperty(this, 'name', { value: 'KeqError' });
+        }
+    }
+    exports.Exception = Exception;
+});

package/dist/umd/src/exception/file-expected.exception.d.ts

@@ -0,0 +1,4 @@
+import { Exception } from './exception';
+export declare class FileExpectedException extends Exception {
+    constructor();
+}

package/dist/umd/src/exception/file-expected.exception.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./exception"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.FileExpectedException = void 0;
+    const exception_1 = require("./exception");
+    class FileExpectedException extends exception_1.Exception {
+        constructor() {
+            super('File/Blob (Browser) or Buffer (NodeJS) expected');
+        }
+    }
+    exports.FileExpectedException = FileExpectedException;
+});

package/dist/umd/src/exception/invalid-arguments.exception.d.ts

@@ -0,0 +1,4 @@
+import { Exception } from './exception';
+export declare class InvalidArgumentsExceptions extends Exception {
+    constructor();
+}

package/dist/umd/src/exception/invalid-arguments.exception.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./exception"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.InvalidArgumentsExceptions = void 0;
+    const exception_1 = require("./exception");
+    class InvalidArgumentsExceptions extends exception_1.Exception {
+        constructor() {
+            super('Invalid arguments');
+        }
+    }
+    exports.InvalidArgumentsExceptions = InvalidArgumentsExceptions;
+});

package/dist/umd/src/exception/overwrite-array-body.exception.d.ts

@@ -0,0 +1,4 @@
+import { Exception } from './exception';
+export declare class OverwriteArrayBodyException extends Exception {
+    constructor();
+}

package/dist/umd/src/exception/overwrite-array-body.exception.js

@@ -0,0 +1,20 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./exception"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OverwriteArrayBodyException = void 0;
+    const exception_1 = require("./exception");
+    class OverwriteArrayBodyException extends exception_1.Exception {
+        constructor() {
+            super('Cannot merge or overwrite body, because it has been set as an array. Please use .body(arr) instead');
+        }
+    }
+    exports.OverwriteArrayBodyException = OverwriteArrayBodyException;
+});

package/dist/umd/src/index.d.ts

@@ -0,0 +1,13 @@
+export { createRequest } from './create-request';
+export { Keq } from './keq';
+export { composeMiddleware } from './middleware';
+export { request } from './request';
+export { KeqContext } from './types/keq-context';
+export { KeqMiddleware } from './types/keq-middleware';
+export { KeqNext } from './types/keq-next';
+export { KeqOptions } from './types/keq-options';
+export { KeqRequest } from './types/keq-request';
+export { KeqRequestBody } from './types/keq-request-body';
+export { KeqRequestInit } from './types/keq-request-init';
+export { KeqRetryDelay } from './types/keq-retry-delay';
+export { KeqRetryOn } from './types/keq-retry-on';

package/dist/umd/src/index.js

@@ -0,0 +1,21 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./create-request", "./keq", "./middleware", "./request"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.request = exports.composeMiddleware = exports.Keq = exports.createRequest = void 0;
+    var create_request_1 = require("./create-request");
+    Object.defineProperty(exports, "createRequest", { enumerable: true, get: function () { return create_request_1.createRequest; } });
+    var keq_1 = require("./keq");
+    Object.defineProperty(exports, "Keq", { enumerable: true, get: function () { return keq_1.Keq; } });
+    var middleware_1 = require("./middleware");
+    Object.defineProperty(exports, "composeMiddleware", { enumerable: true, get: function () { return middleware_1.composeMiddleware; } });
+    var request_1 = require("./request");
+    Object.defineProperty(exports, "request", { enumerable: true, get: function () { return request_1.request; } });
+});

package/dist/umd/src/is/is-blob.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Check if given valie is Blob or File -like object
+ */
+export declare function isBlob(value: any): value is Blob;

package/dist/umd/src/is/is-blob.js

@@ -0,0 +1,32 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./is-function", "./is-object", "./is-string"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isBlob = void 0;
+    const is_function_1 = require("./is-function");
+    const is_object_1 = require("./is-object");
+    const is_string_1 = require("./is-string");
+    const names = ['Blob', 'File'];
+    /**
+     * Check if given valie is Blob or File -like object
+     */
+    function isBlob(value) {
+        if (value instanceof Blob)
+            return true;
+        return (0, is_object_1.isObject)(value)
+            && (0, is_string_1.isString)(value.type)
+            && (0, is_function_1.isFunction)(value.arrayBuffer)
+            && (0, is_function_1.isFunction)(value.stream)
+            && (0, is_function_1.isFunction)(value.constructor)
+            && names.includes(value.constructor.name)
+            && 'size' in value;
+    }
+    exports.isBlob = isBlob;
+});

package/dist/umd/src/is/is-browser.d.ts

@@ -0,0 +1 @@
+export declare function isBrowser(): boolean;

package/dist/umd/src/is/is-browser.js

@@ -0,0 +1,17 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isBrowser = void 0;
+    function isBrowser() {
+        return typeof window !== 'undefined';
+    }
+    exports.isBrowser = isBrowser;
+});

package/dist/umd/src/is/is-file.d.ts

@@ -0,0 +1 @@
+export declare function isFile(object: any): object is File;

package/dist/umd/src/is/is-file.js

@@ -0,0 +1,21 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./is-blob", "./is-browser"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isFile = void 0;
+    const is_blob_1 = require("./is-blob");
+    const is_browser_1 = require("./is-browser");
+    function isFile(object) {
+        if ((0, is_browser_1.isBrowser)())
+            return object instanceof Blob;
+        return (0, is_blob_1.isBlob)(object);
+    }
+    exports.isFile = isFile;
+});

package/dist/umd/src/is/is-form-data.d.ts

@@ -0,0 +1 @@
+export declare function isFormData(object: any): object is FormData;

package/dist/umd/src/is/is-form-data.js

@@ -0,0 +1,30 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./is-function", "./is-object"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isFormData = void 0;
+    const is_function_1 = require("./is-function");
+    const is_object_1 = require("./is-object");
+    function isFormData(object) {
+        if (object instanceof FormData)
+            return true;
+        return ((0, is_object_1.isObject)(object) &&
+            (0, is_function_1.isFunction)(object.append) &&
+            (0, is_function_1.isFunction)(object.delete) &&
+            (0, is_function_1.isFunction)(object.get) &&
+            (0, is_function_1.isFunction)(object.getAll) &&
+            (0, is_function_1.isFunction)(object.has) &&
+            (0, is_function_1.isFunction)(object.set) &&
+            (0, is_function_1.isFunction)(object.entries) &&
+            (0, is_function_1.isFunction)(object.keys) &&
+            (0, is_function_1.isFunction)(object.values));
+    }
+    exports.isFormData = isFormData;
+});

package/dist/umd/src/is/is-function.d.ts

@@ -0,0 +1 @@
+export declare function isFunction(value: any): boolean;

package/dist/umd/src/is/is-function.js

@@ -0,0 +1,17 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isFunction = void 0;
+    function isFunction(value) {
+        return typeof value === 'function';
+    }
+    exports.isFunction = isFunction;
+});

package/dist/umd/src/is/is-headers.d.ts

@@ -0,0 +1 @@
+export declare function isHeaders(obj: any): obj is Headers;