vigor-fetch 2.0.1 → 2.0.2

package/dist/index.js

@@ -3,546 +3,805 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 class VigorError extends Error {
-    constructor(text, options) {
-        const { type, data, status, response, message, origin } = options;
-        super(message || `[VigorError] ${text}`);
-        this.name = this.constructor.name;
-        this.data = data;
-        this.type = type;
-        this.status = status;
-        this.response = response;
-        this.origin = origin;
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
+    timestamp;
+    method;
+    cause;
+    context;
+    type;
+    data;
+    constructor(message, options) {
+        super(message, { cause: options?.cause });
+        this.name = new.target.name;
+        this.timestamp = new Date();
+        if (options?.method !== undefined)
+            this.method = options.method;
+        if (options?.context !== undefined)
+            this.context = options.context;
+        if (options?.type !== undefined)
+            this.type = options.type;
+        if (options?.data !== undefined)
+            this.data = options.data;
+        Object.setPrototypeOf(this, new.target.prototype);
+        Error.captureStackTrace?.(this, new.target);
     }
 }
 class VigorRetryError extends VigorError {
-    constructor(text, options) {
-        super(text, options);
-        this.message = options.message || `[VigorRetryError] ${text}`;
+    constructor(message, options) {
+        super(message, options);
     }
 }
 class VigorParseError extends VigorError {
-    constructor(text, options) {
-        super(text, options);
-        this.message = options.message || `[VigorParseError] ${text}`;
+    constructor(message, options) {
+        super(message, options);
     }
 }
 class VigorFetchError extends VigorError {
-    constructor(text, options) {
-        super(text, options);
-        this.message = options.message || `[VigorFetchError] ${text}`;
+    constructor(message, options) {
+        super(message, options);
     }
 }
 class VigorAllError extends VigorError {
-    constructor(text, options) {
-        super(text, options);
-        this.message = options.message || `[VigorAllError] ${text}`;
+    constructor(message, options) {
+        super(message, options);
     }
 }
-/**
- * VigorRetry
- */
-class VigorRetry {
-    constructor(target, args = [], config = {}) {
-        this._target = target;
-        this._args = args;
-        this._config = {
-            retry: {
-                count: 5, max: 10000, backoff: 1.3, baseDelay: 1000, jitter: 500
-            },
-            interceptors: {
-                before: [], after: [], onRetry: [], onError: []
-            },
-            ...config
+class VigorStatus {
+    _config;
+    _ctor;
+    _errorCtor;
+    constructor(_config, _ctor, _errorCtor) {
+        this._config = _config;
+        this._ctor = _ctor;
+        this._errorCtor = _errorCtor;
+    }
+    _create(config) { return this._ctor(config); }
+    _next(config) { return this._create({ ...this._config, ...config }); }
+    getConfig() { return this._config; }
+    _pipeSub(value, Ctor, fn, errorKey) {
+        const ErrorCtor = this._errorCtor?.();
+        if (typeof fn !== "function" && ErrorCtor) {
+            throw new ErrorCtor("ctor expects function", {
+                method: errorKey,
+                type: "invalid_input",
+                data: { expected: "function", received: fn }
+            });
+        }
+        return fn(new Ctor(value)).getConfig();
+    }
+}
+class VigorRetrySettings extends VigorStatus {
+    _base;
+    constructor(config) {
+        const base = {
+            count: 5,
+            limit: 10000,
+            maxDelay: 10000,
         };
+        super({ ...base, ...config }, (c) => new VigorRetrySettings(c));
+        this._base = base;
     }
-    _next(changes) {
-        return new this.constructor(this._target, this._args, {
-            ...this._config,
-            ...changes,
-            retry: {
-                ...this._config.retry,
-                ...(changes.retry || {})
-            },
-            interceptors: {
-                ...this._config.interceptors,
-                ...(changes.interceptors || {})
-            }
+    getBase() { return this._base; }
+    count(num) { return this._next({ count: num }); }
+    limit(num) { return this._next({ limit: num }); }
+    maxDelay(num) { return this._next({ maxDelay: num }); }
+    default(obj) { return this._next({ default: obj }); }
+}
+class VigorRetryBackoff extends VigorStatus {
+    _base;
+    constructor(config) {
+        const base = {
+            initialDelay: 0,
+            baseDelay: 1000,
+            factor: 1.7,
+            jitter: 1000
+        };
+        super({ ...base, ...config }, (c) => new VigorRetryBackoff(c));
+        this._base = base;
+    }
+    getBase() { return this._base; }
+    initialDelay(num) { return this._next({ initialDelay: num }); }
+    baseDelay(num) { return this._next({ baseDelay: num }); }
+    factor(num) { return this._next({ factor: num }); }
+    jitter(num) { return this._next({ jitter: num }); }
+}
+class VigorRetryInterceptors extends VigorStatus {
+    _base;
+    constructor(config) {
+        const base = {
+            before: [],
+            after: [],
+            onError: [],
+            onRetry: [],
+            retryIf: []
+        };
+        super({ ...base, ...config }, (c) => new VigorRetryInterceptors(c));
+        this._base = base;
+    }
+    getBase() { return this._base; }
+    before(...funcs) { return this._next({ before: [...this.getConfig().before, ...funcs.flat()] }); }
+    after(...funcs) { return this._next({ after: [...this.getConfig().after, ...funcs.flat()] }); }
+    onError(...funcs) { return this._next({ onError: [...this.getConfig().onError, ...funcs.flat()] }); }
+    onRetry(...funcs) { return this._next({ onRetry: [...this.getConfig().onRetry, ...funcs.flat()] }); }
+    retryIf(...funcs) { return this._next({ retryIf: [...this.getConfig().retryIf, ...funcs.flat()] }); }
+}
+class VigorRetry extends VigorStatus {
+    _base;
+    _controller = new AbortController();
+    constructor(config) {
+        const base = {
+            target: null,
+            setting: new VigorRetrySettings().getBase(),
+            backoff: new VigorRetryBackoff().getBase(),
+            interceptors: new VigorRetryInterceptors().getBase()
+        };
+        super({ ...base, ...config }, (c) => new VigorRetry(c), () => VigorRetryError);
+        this._base = base;
+    }
+    getBase() { return this._base; }
+    target(func) { return new VigorRetry({ ...this._config, target: func, setting: this._config.setting, interceptors: this._config.interceptors }); }
+    createController() { const controller = new AbortController(); this._controller = controller; return (error) => controller.abort(error); }
+    setting(func) {
+        return this._next({
+            setting: this._pipeSub(this._config.setting, VigorRetrySettings, func, "setting")
+        });
+    }
+    backoff(func) {
+        return this._next({
+            backoff: this._pipeSub(this._config.backoff, VigorRetryBackoff, func, "backoff")
+        });
+    }
+    interceptors(func) {
+        return this._next({
+            interceptors: this._pipeSub(this._config.interceptors, VigorRetryInterceptors, func, "interceptors")
         });
     }
-    args(...args) { return new this.constructor(this._target, args, this._config); }
-    count(int) { return this._next({ retry: { count: int } }); }
-    max(ms) { return this._next({ retry: { max: ms } }); }
-    backoff(ms) { return this._next({ retry: { backoff: ms } }); }
-    baseDelay(ms) { return this._next({ retry: { baseDelay: ms } }); }
-    jitter(ms) { return this._next({ retry: { jitter: ms } }); }
-    before(...func) { return this._next({ interceptors: { before: [...this._config.interceptors.before, ...func.flat()] } }); }
-    onRetry(...func) { return this._next({ interceptors: { onRetry: [...this._config.interceptors.onRetry, ...func.flat()] } }); }
-    after(...func) { return this._next({ interceptors: { after: [...this._config.interceptors.after, ...func.flat()] } }); }
-    onError(...func) { return this._next({ interceptors: { onError: [...this._config.interceptors.onError, ...func.flat()] } }); }
     async request() {
-        const [target, args, config] = [this._target, this._args, this._config];
-        const { retry: { count, max, backoff, baseDelay, jitter }, interceptors: { before, after, onRetry, onError } } = config;
-        let ctx = { target, args, attempt: 0, result: null, error: null, try: true, retry: true, max, backoff, jitter, wait: 0, baseDelay };
+        const config = this._config;
+        let ctx = {
+            target: config.target,
+            setting: { ...config.setting },
+            interceptors: {
+                before: [...config.interceptors.before],
+                after: [...config.interceptors.after],
+                onError: [...config.interceptors.onError],
+                onRetry: [...config.interceptors.onRetry],
+                retryIf: [...config.interceptors.retryIf],
+            },
+            backoff: { ...config.backoff },
+            runtime: {
+                result: null,
+                controller: null,
+                attempt: 0,
+                aborted: false,
+                signal: null,
+                delay: 0,
+                retry: false,
+            }
+        };
+        const throwError = (error) => { throw error; };
+        const normalizeError = (obj) => {
+            if (obj instanceof Error) {
+                throw obj;
+            }
+            throw new Error(String(obj));
+        };
         try {
-            if (typeof target !== 'function')
-                throw new VigorRetryError('target is not a function', { type: "not a function", data: "target" });
-            const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
-            for (let i = 0; i < count; i++) {
-                ctx.attempt = i + 1;
-                ctx.error = null;
-                ctx.result = null;
-                ctx.retry ?? (ctx.retry = true);
-                for (const func of before) {
-                    if (typeof func !== 'function')
-                        throw new VigorRetryError('Interceptor<before> is not a function', { type: "not a function", data: "before" });
-                    const next = await func(ctx, ctx.args);
-                    if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                        ctx = { ...ctx, ...next };
-                }
-                if (!ctx.try)
-                    break;
+            while (ctx.runtime.attempt < ctx.setting.count) {
+                ctx.runtime.attempt++;
+                ctx.runtime.controller = new AbortController();
+                let listener;
+                let timerId;
+                const setAttempt = (attempt) => ctx.runtime.attempt = attempt;
+                const abort = (error) => { if (!ctx.runtime.aborted) {
+                    ctx.runtime.controller?.abort(error);
+                } };
                 try {
-                    ctx.result = await ctx.target(...ctx.args);
-                    for (const func of after) {
-                        if (typeof func !== 'function')
-                            throw new VigorRetryError('Interceptor<after> is not a function', { type: "not a function", data: "after" });
-                        const next = await func(ctx, ctx.result);
-                        if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                            ctx = { ...ctx, ...next };
+                    ctx.runtime.signal = AbortSignal.any([
+                        this._controller.signal,
+                        ctx.runtime.controller.signal
+                    ]);
+                    ctx.runtime.abortPromise = new Promise((_, reject) => {
+                        if (ctx.runtime.signal.aborted)
+                            reject(ctx.runtime.signal.reason);
+                        listener = () => {
+                            ctx.runtime.aborted = true;
+                            reject(ctx.runtime.signal.reason);
+                        };
+                        ctx.runtime.signal.addEventListener("abort", listener, { once: true });
+                        timerId = setTimeout(() => {
+                            if (ctx.runtime.aborted)
+                                return;
+                            abort(new VigorRetryError(`timeouted after ${ctx.setting.limit}`, { method: "request", type: "timeout", data: { limit: ctx.setting.limit, attempt: ctx.runtime.attempt } }));
+                        }, ctx.setting.limit);
+                    });
+                    for (const func of ctx.interceptors.before) {
+                        await func(ctx, { setAttempt, throwError, abort });
+                        if (ctx.runtime.signal.aborted)
+                            normalizeError(ctx.runtime.signal.reason);
+                    }
+                    ctx.runtime.result = await Promise.race([
+                        ctx.target(ctx, { abort, signal: ctx.runtime.signal }),
+                        ctx.runtime.abortPromise
+                    ]);
+                    const setResult = (result) => ctx.runtime.result = result;
+                    for (const func of ctx.interceptors.after) {
+                        await func(ctx, { setAttempt, setResult, throwError });
+                        if (ctx.runtime.signal.aborted)
+                            normalizeError(ctx.runtime.signal.reason);
                     }
-                    if (ctx.error instanceof Error)
-                        throw ctx.error;
-                    if (ctx.result instanceof Error)
-                        throw ctx.result;
-                    return ctx.result;
+                    return ctx.runtime.result;
                 }
                 catch (error) {
-                    ctx.error = error;
-                    ctx.wait = Math.min(Math.pow(ctx.backoff, ctx.attempt - 1) * ctx.baseDelay, max) + ctx.jitter * Math.random();
-                    for (const func of onRetry) {
-                        if (typeof func !== 'function')
-                            throw new VigorRetryError('Interceptor<onRetry> is not a function', { type: "not a function", data: "retry" });
-                        const next = await func(ctx, ctx.error);
-                        if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                            ctx = { ...ctx, ...next };
+                    if (ctx.runtime.aborted)
+                        normalizeError(ctx.runtime.signal.reason);
+                    ctx.runtime.retry = true;
+                    ctx.runtime.error = error;
+                    const proceedRetry = () => ctx.runtime.retry = true;
+                    const cancelRetry = (error) => { ctx.runtime.error = error; return (ctx.runtime.retry = false); };
+                    for (const func of ctx.interceptors.retryIf) {
+                        await func(ctx, { throwError, proceedRetry, cancelRetry });
+                    }
+                    if (!ctx.runtime.retry) {
+                        throw ctx.runtime.error;
                     }
-                    if (!ctx.retry)
-                        break;
-                    await sleep(ctx.wait);
+                    ctx.runtime.delay = Math.min(ctx.setting.maxDelay, Math.max(0, ctx.backoff.initialDelay + ctx.backoff.baseDelay * Math.pow(ctx.backoff.factor, ctx.runtime.attempt - 1))) + calculateJitter(ctx.backoff.jitter);
+                    const setDelay = (delay) => ctx.runtime.delay = delay;
+                    for (const func of ctx.interceptors.onRetry) {
+                        await func(ctx, { setAttempt, throwError, setDelay });
+                    }
+                    await new Promise((resolve, reject) => {
+                        const timer = setTimeout(resolve, ctx.runtime.delay);
+                        const abortHandler = () => {
+                            clearTimeout(timer);
+                            reject(this._controller.signal.reason);
+                        };
+                        if (this._controller.signal.aborted)
+                            return abortHandler();
+                        this._controller.signal.addEventListener("abort", abortHandler, { once: true });
+                    });
+                }
+                finally {
+                    clearTimeout(timerId);
+                    if (listener)
+                        ctx.runtime.signal.removeEventListener("abort", listener);
                 }
             }
-            if (ctx.error instanceof Error)
-                throw ctx.error;
-            if (ctx.result instanceof Error)
-                throw ctx.result;
+            throw new VigorRetryError(`Maximum retry attempts (${ctx.setting.count}) reached. Task failed or timed out.`, { method: "request", type: "exhausted", data: { limit: ctx.setting.limit, attempt: ctx.runtime.attempt, maxAttempts: ctx.setting.count } });
         }
-        catch (mainError) {
-            ctx.mainError = mainError;
-            for (const func of onError) {
-                if (typeof func !== 'function')
-                    throw new VigorRetryError('Interceptor<onError> is not a function', { type: "not a function", data: "onError" });
-                const next = await func(ctx, ctx.mainError);
-                if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                    ctx = { ...ctx, ...next };
+        catch (error) {
+            ctx.runtime.error = error;
+            let overrided = false;
+            const setResult = (result) => { overrided = true; return (ctx.runtime.result = result); };
+            for (const func of ctx.interceptors.onError) {
+                await func(ctx, { setResult, throwError });
             }
-            if (ctx.mainError instanceof Error)
-                throw ctx.mainError;
-            return ctx.mainError;
+            if (overrided && ctx.runtime.result !== undefined)
+                return ctx.runtime.result;
+            if (ctx.setting.default !== undefined)
+                return ctx.setting.default;
+            throw error;
         }
-        return ctx.result;
     }
 }
-/**
- * VigorParse
- */
-class VigorParse {
-    constructor(response, config = {}) {
-        this._response = response;
-        this._config = {
-            settings: { original: false, parse: null },
-            interceptors: { before: [], after: [], onError: [] },
-            ...config,
+const basic = { key: /text/, parse: (res) => res.text(), type: "text" };
+const parser = [
+    { key: /json/, parse: (res) => res.json(), type: "json" },
+    { key: /multipart\/form-data/, parse: (res) => res.formData(), type: "formData" },
+    { key: /octet-stream/, parse: (res) => res.arrayBuffer(), type: "arrayBuffer" },
+    { key: /(image|video|audio|pdf)/, parse: (res) => res.blob(), type: "blob" },
+    basic
+];
+const supported = parser.map(i => i.type);
+class VigorParse extends VigorStatus {
+    _base;
+    constructor(config) {
+        const base = {
+            original: false
         };
+        super({ ...base, ...config }, (c) => new VigorParse(c));
+        this._base = base;
     }
-    _next(changes) {
-        return new this.constructor(this._response, {
-            ...this._config,
-            ...changes,
-            settings: {
-                ...this._config.settings,
-                ...(changes.settings || {})
-            },
-            interceptors: {
-                ...this._config.interceptors,
-                ...(changes.interceptors || {})
-            }
-        });
-    }
-    original(bool) { return this._next({ settings: { original: bool } }); }
-    type(str) { return this._next({ settings: { parse: str } }); }
-    before(...func) { return this._next({ interceptors: { before: [...this._config.interceptors.before, ...func.flat()] } }); }
-    after(...func) { return this._next({ interceptors: { after: [...this._config.interceptors.after, ...func.flat()] } }); }
-    onError(...func) { return this._next({ interceptors: { onError: [...this._config.interceptors.onError, ...func.flat()] } }); }
+    getBase() { return this._base; }
+    target(response) { return this._next({ target: response }); }
+    original(bool) { return this._next({ original: bool }); }
+    type(str) { return this._next({ type: str }); }
     async request() {
-        const { settings: { original, parse }, interceptors: { before, after, onError } } = this._config;
-        let ctx = { original, parse, result: null, response: this._response };
+        const config = this._config;
+        if (!config.target)
+            throw new VigorParseError("target is required", { method: "request", type: "invalid_target", data: {
+                    expected: "Response",
+                    received: config.target,
+                } });
+        if (config.original)
+            return config.target;
+        const contentType = config.target.headers.get("Content-Type") || "";
+        let strategy;
         try {
-            for (const func of before) {
-                if (typeof func !== 'function')
-                    throw new VigorParseError('Interceptor<before> is not a function', { type: "not a function", data: "before" });
-                const next = await func(ctx, ctx.response);
-                if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                    ctx = { ...ctx, ...next };
-            }
-            ctx.result = await (async (response) => {
-                if (ctx.original)
-                    return response;
-                if (ctx.parse) {
-                    const method = response[ctx.parse];
-                    if (!method || typeof method !== 'function')
-                        throw new VigorParseError(`Invalid method such as ${ctx.parse}`, { type: "Invalid method", data: ctx.parse });
-                    return await method.call(response);
-                }
-                const contentType = response.headers.get("Content-Type") || "";
-                if (/json/.test(contentType))
-                    return await response.json();
-                if (/multipart\/form-data/.test(contentType))
-                    return await response.formData();
-                if (/octet-stream/.test(contentType))
-                    return await response.arrayBuffer();
-                if (/(image|video|audio|pdf)/.test(contentType))
-                    return await response.blob();
-                return await response.text();
-            })(ctx.response);
-            for (const func of after) {
-                if (typeof func !== 'function')
-                    throw new VigorParseError('Interceptor<after> is not a function', { type: "not a function", data: "after" });
-                const next = await func(ctx, ctx.result);
-                if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                    ctx = { ...ctx, ...next };
+            if (config.type) {
+                strategy = { type: config.type };
+                const parser = config.target[config.type];
+                if (!parser || typeof parser !== 'function')
+                    throw new VigorParseError(`failed to parse: '${strategy?.type ?? "unknown"}'`, { method: "request", type: "invalid_type", data: {
+                            expected: config.type,
+                            supported: supported,
+                            response: config.target,
+                            headers: contentType,
+                        } });
+                return await parser();
             }
-            if (ctx.result instanceof Error)
-                throw ctx.result;
-            return ctx.result;
+            strategy = parser.find(i => i.key.test(contentType)) ?? basic;
+            return await strategy.parse(config.target);
         }
-        catch (mainError) {
-            ctx.mainError = mainError;
-            for (const func of onError) {
-                if (typeof func !== 'function')
-                    throw new VigorParseError('Interceptor<onError> is not a function', { type: "not a function", data: "onError" });
-                const next = await func(ctx, ctx.mainError);
-                if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                    ctx = { ...ctx, ...next };
-            }
-            if (ctx.mainError instanceof Error)
-                throw ctx.mainError;
-            return ctx.mainError;
+        catch (error) {
+            if (error instanceof VigorParseError)
+                throw error;
+            throw new VigorParseError(`failed to parse: '${strategy?.type ?? "unknown"}'`, { method: "request", type: "parse_failed", data: {
+                    expected: strategy?.type ?? "unknown",
+                    supported: supported,
+                    response: config.target,
+                    headers: contentType,
+                    error
+                } });
         }
     }
 }
-/**
- * VigorFetch
- */
-class VigorFetch {
-    constructor(origin = "", config = {}) {
-        this._config = {
-            request: { origin, path: "", query: {}, method: "", headers: {}, body: null, offset: {} },
-            retry: { limit: 10000, retryHeaders: ["retry-after", "ratelimit-reset"], unretry: new Set([400, 404]) },
-            response: { retryConfig: undefined, parseConfig: undefined },
-            interceptors: { before: [], after: [], onError: [], result: [] },
-            ...config
+class VigorFetchSettings extends VigorStatus {
+    _base;
+    constructor(config) {
+        const base = {
+            origin: "",
+            path: [],
+            query: {},
+            unretry: [400, 401, 403, 404, 405, 413, 422],
+            retryHeaders: ["retry-after", "ratelimit-reset", "x-ratelimit-reset", "x-retry-after", "x-amz-retry-after", "chrome-proxy-next-link"],
         };
+        super({ ...base, ...config }, (c) => new VigorFetchSettings(c));
+        this._base = base;
     }
-    _next(changes) {
-        const newConfig = {
-            ...this._config,
-            request: { ...this._config.request, ...(changes.request || {}) },
-            retry: { ...this._config.retry, ...(changes.retry || {}) },
-            response: { ...this._config.response, ...(changes.response || {}) },
-            interceptors: {
-                before: [...(this._config.interceptors.before || [])],
-                after: [...(this._config.interceptors.after || [])],
-                onError: [...(this._config.interceptors.onError || [])],
-                result: [...(this._config.interceptors.result || [])],
-                ...(changes.interceptors || {})
-            }
+    getBase() { return this._base; }
+    origin(str) { return this._next({ origin: str }); }
+    path(...strs) { return this._next({ path: [...this._config.path, ...strs.flat()] }); }
+    query(obj) { return this._next({ query: { ...this._config.query, ...obj } }); }
+    unretry(...numbers) { return this._next({ unretry: numbers.flat() }); }
+    retryHeaders(...strs) { return this._next({ retryHeaders: [...this._config.retryHeaders, ...strs.flat()] }); }
+    method(str) { return this._next({ method: str }); }
+    headers(obj) { return this._next({ headers: obj }); }
+    body(obj) { return this._next({ body: obj }); }
+    options(obj) { return this._next({ options: obj }); }
+    default(obj) { return this._next({ default: obj }); }
+}
+class VigorFetchInterceptors extends VigorStatus {
+    _base;
+    constructor(config) {
+        const base = {
+            before: [],
+            after: [],
+            onError: [],
+            result: []
         };
-        if (changes.interceptors) {
-            Object.keys(changes.interceptors).forEach(key => {
-                if (Array.isArray(changes.interceptors[key])) {
-                    newConfig.interceptors[key] = [
-                        ...this._config.interceptors[key],
-                        ...changes.interceptors[key]
-                    ];
+        super({ ...base, ...config }, (c) => new VigorFetchInterceptors(c));
+        this._base = base;
+    }
+    getBase() { return this._base; }
+    before(...funcs) { return this._next({ before: [...this.getConfig().before, ...funcs.flat()] }); }
+    after(...funcs) { return this._next({ after: [...this.getConfig().after, ...funcs.flat()] }); }
+    onError(...funcs) { return this._next({ onError: [...this.getConfig().onError, ...funcs.flat()] }); }
+    result(...funcs) { return this._next({ result: [...this.getConfig().result, ...funcs.flat()] }); }
+}
+class VigorFetch extends VigorStatus {
+    _base;
+    constructor(config) {
+        const base = {
+            setting: new VigorFetchSettings().getBase(),
+            retryConfig: new VigorRetry().getBase(),
+            parseConfig: new VigorParse().getBase(),
+            interceptors: new VigorFetchInterceptors().getBase(),
+        };
+        super({ ...base, ...config }, (c) => new VigorFetch(c), () => VigorRetryError);
+        this._base = base;
+    }
+    getBase() { return this._base; }
+    origin(str) { return this._next({ setting: { ...this._config.setting, origin: str } }); }
+    path(...strs) { return this._next({ setting: { ...this._config.setting, path: [...this._config.setting.path, ...strs.flat()] } }); }
+    query(obj) { return this._next({ setting: { ...this._config.setting, query: { ...this._config.setting.query, ...obj } } }); }
+    method(str) { return this._next({ setting: { ...this._config.setting, method: str } }); }
+    headers(obj) { return this._next({ setting: { ...this._config.setting, headers: obj } }); }
+    body(obj) { return this._next({ setting: { ...this._config.setting, body: obj } }); }
+    options(obj) { return this._next({ setting: { ...this._config.setting, options: obj } }); }
+    setting(func) {
+        return this._next({
+            setting: this._pipeSub(this._config.setting, VigorFetchSettings, func, "setting")
+        });
+    }
+    retryConfig(func) {
+        return this._next({
+            retryConfig: this._pipeSub(this._config.retryConfig, VigorRetry, func, "retryConfig")
+        });
+    }
+    parseConfig(func) {
+        return this._next({
+            parseConfig: this._pipeSub(this._config.parseConfig, VigorParse, func, "parseConfig")
+        });
+    }
+    buildUrl(origin, path, query) {
+        if (!origin)
+            throw new VigorFetchError("buildUrl expects 'origin'", {
+                type: "invalid_input", method: "buildUrl", data: {
+                    expected: "string", received: origin
+                }
+            });
+        try {
+            const url = new URL(origin);
+            if (path && path.length > 0) {
+                const cleanPath = path
+                    .filter(p => p && typeof p === 'string')
+                    .map(p => p.replace(/^\/+|\/+$/g, ''))
+                    .join('/');
+                if (cleanPath) {
+                    const base = url.pathname.endsWith('/') ? url.pathname : url.pathname + '/';
+                    url.pathname = base + cleanPath;
                 }
+            }
+            if (query && typeof query === 'object') {
+                Object.entries(query).forEach(([key, value]) => {
+                    if (value === null || value === undefined)
+                        return;
+                    if (Array.isArray(value)) {
+                        value.forEach(v => url.searchParams.append(key, String(v)));
+                    }
+                    else {
+                        url.searchParams.set(key, String(value));
+                    }
+                });
+            }
+            return url.toString();
+        }
+        catch (e) {
+            throw new VigorFetchError(`Invalid URL origin: ${origin}`, {
+                type: "invalid_url", method: "buildUrl", data: { error: e }
             });
         }
-        return new this.constructor(newConfig.request.origin, newConfig);
-    }
-    origin(str) { return this._next({ request: { origin: str } }); }
-    path(str) { return this._next({ request: { path: str } }); }
-    query(obj) { return this._next({ request: { query: obj } }); }
-    method(str) { return this._next({ request: { method: str } }); }
-    headers(obj) { return this._next({ request: { headers: obj } }); }
-    body(obj) { return this._next({ request: { body: obj } }); }
-    offset(obj) { return this._next({ request: { offset: obj } }); }
-    limit(ms) { return this._next({ retry: { limit: ms } }); }
-    retryHeaders(...str) { return this._next({ retry: { retryHeaders: [...this._config.retry.retryHeaders, ...str.flat()] } }); }
-    unretry(...int) { return this._next({ retry: { unretry: new Set(int.flat()) } }); }
-    before(...func) { return this._next({ interceptors: { before: [...this._config.interceptors.before, ...func.flat()] } }); }
-    after(...func) { return this._next({ interceptors: { after: [...this._config.interceptors.after, ...func.flat()] } }); }
-    result(...func) { return this._next({ interceptors: { result: [...this._config.interceptors.result, ...func.flat()] } }); }
-    onError(...func) { return this._next({ interceptors: { onError: [...this._config.interceptors.onError, ...func.flat()] } }); }
-    retryConfig(func) {
-        if (typeof func !== 'function')
-            throw new VigorFetchError("retryConfig is not a function", { type: "not a function", data: "retryConfig" });
-        const dummyRetry = func(new VigorRetry(async () => { }));
-        return this._next({ retry: { retryConfig: dummyRetry['_config'] } });
     }
-    parseConfig(func) {
-        if (typeof func !== 'function')
-            throw new VigorFetchError("parseConfig is not a function", { type: "not a function", data: "parseConfig" });
-        const dummyParse = func(new VigorParse(null));
-        return this._next({ response: { parseConfig: dummyParse['_config'] } });
+    interceptors(func) {
+        return this._next({
+            interceptors: this._pipeSub(this._config.interceptors, VigorFetchInterceptors, func, "interceptors")
+        });
     }
     async request() {
-        const { request: { origin, path, query, method, headers, body, offset }, retry: { limit, retryHeaders, unretry }, interceptors: { before, after, onError, result }, response: { retryConfig, parseConfig } } = this._config;
-        let ctx = { option: null, result: null, path, origin };
+        const config = this._config;
+        let ctx = {
+            setting: { ...config.setting },
+            retryConfig: {
+                ...config.retryConfig,
+                interceptors: {
+                    before: [...config.retryConfig.interceptors.before],
+                    after: [...config.retryConfig.interceptors.after],
+                    onError: [...config.retryConfig.interceptors.onError],
+                    onRetry: [...config.retryConfig.interceptors.onRetry],
+                    retryIf: [...config.retryConfig.interceptors.retryIf],
+                }
+            },
+            parseConfig: {
+                ...config.parseConfig
+            },
+            interceptors: {
+                before: [...config.interceptors.before],
+                after: [...config.interceptors.after],
+                onError: [...config.interceptors.onError],
+                result: [...config.interceptors.result]
+            },
+            runtime: {}
+        };
+        const throwError = (error) => { throw error; };
         try {
-            if (!/^(https?|data|blob|file|about):\/\//.test(origin))
-                throw new VigorFetchError(`${origin} Invalid Protocol`, { type: "Invalid Protocol", data: origin, origin: origin, status: 0 });
-            const isJson = Array.isArray(body) || (!!body && Object.getPrototypeOf(body) === Object.prototype);
-            ctx.option = {
-                method: method || (body ? "POST" : "GET"),
-                headers: { ...(isJson && { "Content-Type": "application/json" }), ...headers },
-                ...(body && { body: isJson ? JSON.stringify(body) : body }),
-                ...offset
+            ctx.runtime.unretrySet = new Set(ctx.setting.unretry);
+            if (!/^(https?|data|blob|file|about):\/\//.test(ctx.setting.origin))
+                throw new VigorFetchError(`Invalid Protocol`, { type: "Invalid Protocol", method: "request", data: {
+                        expected: ["http", "https", "data", "blob", "file", "about"], received: ctx.setting.origin
+                    } });
+            ctx.runtime.url = this.buildUrl(config.setting.origin, config.setting.path, config.setting.query);
+            const isJson = Array.isArray(ctx.setting.body) || (!!ctx.setting.body && Object.getPrototypeOf(ctx.setting.body) === Object.prototype);
+            ctx.runtime.baseOptions = {
+                method: ctx.setting.method || (ctx.setting.body ? "POST" : "GET"),
+                headers: { ...(isJson && { "Content-Type": "application/json" }), ...ctx.setting.headers },
+                ...(ctx.setting.body && { body: isJson ? JSON.stringify(ctx.setting.body) : ctx.setting.body }),
+                ...ctx.setting.options,
+                signal: null
             };
-            for (const func of before) {
-                if (typeof func !== 'function')
-                    throw new VigorFetchError('Interceptor<before> is not a function', { type: "not a function", data: "before" });
-                const next = await func(ctx, ctx.option);
-                if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                    ctx = { ...ctx, ...next };
-            }
-            const originBase = ctx.origin.endsWith('/') ? ctx.origin : ctx.origin + '/';
-            const cleanPath = ctx.path.replace(/^\//, "");
-            const urlObj = cleanPath ? new URL(cleanPath, originBase) : new URL(ctx.origin);
-            Object.entries(query).forEach(([key, value]) => {
-                if (value !== null && value !== undefined)
-                    urlObj.searchParams.append(key, String(value));
-            });
-            const url = urlObj.href;
-            ctx.url = url;
-            const fetchTarget = async () => {
-                const controller = new AbortController();
-                const abort = setTimeout(() => controller.abort(), limit);
-                const http = ctx.option;
-                http.signal = controller.signal;
-                const res = await fetch(url, http);
-                clearTimeout(abort);
-                return res;
+            const target = async (ctx2, { signal }) => {
+                ctx.runtime.options = {
+                    ...ctx.runtime.baseOptions,
+                    signal
+                };
+                const response = await fetch(ctx.runtime.url, ctx.runtime.options);
+                return response;
             };
-            const handle429 = async (ctx) => {
-                const res = ctx.result;
-                if (unretry.has(res.status))
-                    throw new Error(`Unretry ${res.status}`);
-                if (!res || res.status !== 429)
-                    return;
-                const rHeader = retryHeaders.map((h) => res.headers.get(h)).find(Boolean);
-                let delay = 0;
-                if (rHeader) {
-                    delay = isNaN(Number(rHeader)) ? new Date(rHeader).getTime() - Date.now() : Number(rHeader) * 1000;
+            const checkOk = async (ctx2, { throwError }) => {
+                const result = ctx2.runtime.result;
+                if (!result.ok)
+                    return throwError?.(new VigorFetchError(`HTTP Error: ${result.status} ${result.statusText}`, {
+                        method: "request", type: "fetch_error",
+                        data: { status: result.status, statusText: result.statusText, url: result.url }
+                    }));
+            };
+            const handleBlacklist = (ctx2, { cancelRetry }) => {
+                const result = ctx2.runtime.result;
+                if (!result?.status || ctx.runtime.unretrySet.has(result.status))
+                    cancelRetry?.();
+            };
+            const handle429 = (ctx2, { setDelay }) => {
+                const result = ctx2.runtime.result;
+                if (result?.status === 429) {
+                    let rHeader = null;
+                    ctx.setting.retryHeaders.some(h => (rHeader = result.headers.get(h)));
+                    if (rHeader) {
+                        setDelay?.(isNaN(Number(rHeader)) ? new Date(rHeader).getTime() - Date.now() : Number(rHeader) * 1000);
+                    }
                 }
-                ctx.wait = Math.max(0, delay) + Math.random() * ctx.jitter;
-                if (ctx.wait > ctx.max)
-                    throw new Error(`${url} Timeouted ${ctx.wait}ms`);
-                await new Promise(r => setTimeout(r, ctx.wait));
-                ctx.retry = true;
             };
-            const retryInstance = new VigorRetry(fetchTarget, [], retryConfig).onRetry(handle429);
-            ctx.result = await retryInstance.request();
-            for (const func of after) {
-                if (typeof func !== 'function')
-                    throw new VigorFetchError('Interceptor<after> is not a function', { type: "not a function", data: "after" });
-                const next = await func(ctx, ctx.result);
-                if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                    ctx = { ...ctx, ...next };
+            ctx.retryConfig.target = target;
+            ctx.retryConfig.interceptors.after.unshift(checkOk);
+            ctx.retryConfig.interceptors.retryIf.unshift(handleBlacklist);
+            ctx.retryConfig.interceptors.onRetry.unshift(handle429);
+            ctx.runtime.retryEngine = new VigorRetry(ctx.retryConfig);
+            ctx.runtime.parseEngine = new VigorParse(ctx.parseConfig);
+            const setOptions = (obj) => ctx.runtime.baseOptions = obj;
+            for (const func of ctx.interceptors.before) {
+                await func(ctx, { setOptions, throwError });
             }
-            const parseInstance = new VigorParse(ctx.result, parseConfig);
-            ctx.final = await parseInstance.request();
-            const finalInterceptors = this._config.interceptors.result || [];
-            for (const func of finalInterceptors) {
-                if (typeof func !== 'function')
-                    continue;
-                const next = await func(ctx.final);
-                if (next !== undefined)
-                    ctx.final = next;
+            ctx.runtime.response = await ctx.runtime.retryEngine.request();
+            for (const func of ctx.interceptors.after) {
+                await func(ctx, { throwError });
             }
-            if (ctx.final instanceof Error)
-                throw ctx.final;
-            return ctx.final;
+            ctx.runtime.result = await ctx.runtime.parseEngine?.target(ctx.runtime.response).request();
+            const setResult = (result) => ctx.runtime.result = result;
+            for (const func of ctx.interceptors.result) {
+                await func(ctx, { setResult, throwError });
+            }
+            return ctx.runtime.result;
         }
-        catch (mainError) {
-            ctx.mainError = mainError;
-            for (const func of onError) {
-                if (typeof func !== 'function')
-                    throw new VigorFetchError('Interceptor<onError> is not a function', { type: "not a function", data: "onError" });
-                const next = await func(ctx, ctx.mainError);
-                if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                    ctx = { ...ctx, ...next };
+        catch (error) {
+            ctx.runtime.error = error;
+            let overrided = false;
+            const setResult = (result) => { overrided = true; return (ctx.runtime.result = result); };
+            for (const func of ctx.interceptors.onError) {
+                await func(ctx, { setResult, throwError });
             }
-            if (ctx.mainError instanceof Error)
-                throw ctx.mainError;
-            return ctx.mainError;
+            if (overrided && ctx.runtime.result !== undefined)
+                return ctx.runtime.result;
+            if (ctx.setting.default !== undefined)
+                return ctx.setting.default;
+            throw error;
         }
     }
 }
-/**
- * VigorAll
- */
-class VigorAll {
+class VigorAllSettings extends VigorStatus {
+    _base;
     constructor(config) {
-        this._config = {
-            settings: { limit: 10, jitter: 1000 },
-            request: { promises: [] },
-            response: { retryConfig: undefined, parseConfig: undefined },
-            interceptors: { before: [], after: [], onError: [] },
-            ...config
+        const base = {
+            concurrency: 5,
+            jitter: 1000
         };
+        super({ ...base, ...config }, (c) => new VigorAllSettings(c));
+        this._base = base;
     }
-    _next(changes) {
-        return new this.constructor({
-            ...this._config,
-            ...changes,
-            settings: {
-                ...this._config.settings,
-                ...(changes.settings || {})
-            },
-            request: {
-                ...this._config.request,
-                ...(changes.request || {})
-            },
-            interceptors: {
-                ...this._config.interceptors,
-                ...(changes.interceptors || {})
-            }
+    getBase() { return this._base; }
+    concurrency(num) { return this._next({ concurrency: num }); }
+    jitter(num) { return this._next({ jitter: num }); }
+}
+class VigorAllInterceptors extends VigorStatus {
+    _base;
+    constructor(config) {
+        const base = {
+            before: [],
+            after: [],
+            onError: [],
+            result: []
+        };
+        super({ ...base, ...config }, (c) => new VigorAllInterceptors(c));
+        this._base = base;
+    }
+    getBase() { return this._base; }
+    before(...funcs) { return this._next({ before: [...this.getConfig().before, ...funcs.flat()] }); }
+    after(...funcs) { return this._next({ after: [...this.getConfig().after, ...funcs.flat()] }); }
+    onError(...funcs) { return this._next({ onError: [...this.getConfig().onError, ...funcs.flat()] }); }
+    result(...funcs) { return this._next({ result: [...this.getConfig().result, ...funcs.flat()] }); }
+}
+class VigorAll extends VigorStatus {
+    _base;
+    constructor(config) {
+        const base = {
+            target: [],
+            setting: new VigorAllSettings().getBase(),
+            interceptors: new VigorAllInterceptors().getBase()
+        };
+        super({ ...base, ...config }, (c) => new VigorAll(c), () => VigorAllError);
+        this._base = base;
+    }
+    getBase() { return this._base; }
+    target(...funcs) { return this._next({ target: [...this._config.target, ...funcs.flat()] }); }
+    setting(func) {
+        return this._next({
+            setting: this._pipeSub(this._config.setting, VigorAllSettings, func, "setting")
+        });
+    }
+    interceptors(func) {
+        return this._next({
+            interceptors: this._pipeSub(this._config.interceptors, VigorAllInterceptors, func, "interceptors")
         });
     }
-    promises(...func) { return this._next({ request: { promises: [...this._config.request.promises, ...func.flat()] } }); }
-    limit(int) { return this._next({ settings: { limit: int } }); }
-    jitter(ms) { return this._next({ settings: { jitter: ms } }); }
-    before(...func) { return this._next({ interceptors: { before: [...this._config.interceptors.before, ...func.flat()] } }); }
-    after(...func) { return this._next({ interceptors: { after: [...this._config.interceptors.after, ...func.flat()] } }); }
-    onError(...func) { return this._next({ interceptors: { onError: [...this._config.interceptors.onError, ...func.flat()] } }); }
     async request() {
-        const { settings: { limit, jitter }, request: { promises }, interceptors: { before, after, onError } } = this._config;
-        let ctx = { limit, jitter, promises, result: null };
-        try {
-            for (const func of before || []) {
-                if (typeof func !== 'function')
-                    throw new VigorAllError('Interceptor<before> is not a function', { type: "not a function", data: "before" });
-                const next = await func(ctx, ctx.promises);
-                if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                    ctx = { ...ctx, ...next };
+        const config = this._config;
+        let ctx = {
+            target: [...config.target],
+            setting: { ...config.setting },
+            interceptors: {
+                before: [...config.interceptors.before],
+                after: [...config.interceptors.after],
+                onError: [...config.interceptors.onError],
+                result: [...config.interceptors.result]
+            },
+            runtime: {
+                tasks: [],
+                result: []
             }
-            const results = [];
-            const executing = new Set();
-            for (const task of ctx.promises) {
-                const p = Promise.resolve()
-                    .then(() => new Promise(res => setTimeout(res, Math.random() * ctx.jitter)))
-                    .then(() => task());
-                results.push(p);
-                executing.add(p);
-                p.finally(() => executing.delete(p));
-                if (executing.size >= ctx.limit) {
-                    await Promise.race(executing);
+        };
+        if (ctx.target?.length == 0)
+            throw new VigorFetchError("request expects 'target'", {
+                type: "invalid_input", method: "request", data: {
+                    expected: "string", received: ctx.target
+                }
+            });
+        let active = 0;
+        const queue = [];
+        const runTask = async (task) => {
+            await new Promise(resolve => {
+                if (active < ctx.setting.concurrency) {
+                    active++;
+                    resolve();
+                }
+                else {
+                    queue.push(() => {
+                        active++;
+                        resolve();
+                    });
                 }
-            }
-            const ready = await Promise.allSettled(results);
-            ctx.result = ready.map(i => {
-                if (i.status === "fulfilled")
-                    return i.value;
-                return i.reason instanceof VigorAllError ? i.reason : new VigorAllError(i.reason?.message || "Unknown", { message: i.reason?.message || "Unknown" });
             });
-            for (const func of after) {
-                if (typeof func !== 'function')
-                    throw new VigorAllError('Interceptor<after> is not a function', { type: "not a function", data: "after" });
-                const next = await func(ctx, ctx.result);
-                if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                    ctx = { ...ctx, ...next };
+            const throwError = (error) => { throw error; };
+            try {
+                await new Promise(resolve => setTimeout(resolve, ctx.setting.jitter));
+                let res;
+                for (const func of ctx.interceptors.before) {
+                    await func(ctx, { throwError });
+                }
+                res = await task(ctx, {});
+                const setResult = (result) => res = result;
+                for (const func of ctx.interceptors.after) {
+                    await func(ctx, { setResult, throwError });
+                }
+                return res;
             }
-            if (ctx.result instanceof Error)
-                throw ctx.result;
-            return ctx.result;
-        }
-        catch (mainError) {
-            ctx.mainError = mainError;
-            for (const func of onError) {
-                if (typeof func !== 'function')
-                    throw new VigorAllError('Interceptor<onError> is not a function', { type: "not a function", data: "onError" });
-                const next = await func(ctx, ctx.mainError);
-                if (next !== undefined && typeof next === 'object' && !Array.isArray(next))
-                    ctx = { ...ctx, ...next };
+            catch (error) {
+                let res;
+                let overrided = false;
+                const setResult = (result) => { overrided = true; return (res = result); };
+                for (const func of ctx.interceptors.onError) {
+                    await func(ctx, { setResult, throwError });
+                }
+                if (overrided && res !== undefined)
+                    return res;
+                throw error;
+            }
+            finally {
+                active--;
+                const next = queue.shift();
+                if (next)
+                    next();
             }
-            if (ctx.mainError instanceof Error)
-                throw ctx.mainError;
-            return ctx.mainError;
+        };
+        ctx.runtime.tasks = ctx.target.map(task => runTask(task));
+        const settled = await Promise.allSettled(ctx.runtime.tasks);
+        ctx.runtime.result = settled.map(i => {
+            if (i.status === "fulfilled")
+                return i.value;
+            return new VigorAllError(`this request failed`, {
+                method: "request", type: "request_failed", data: {
+                    error: i.reason
+                }
+            });
+        });
+        const setResult = (result) => ctx.runtime.result = result;
+        const throwError = (error) => { throw error; };
+        for (const func of ctx.interceptors.result) {
+            await func(ctx, { setResult, throwError });
         }
+        return ctx.runtime.result;
     }
 }
-/**
- * Main Vigor Class
- */
+function calculateJitter(jitter) {
+    return jitter * (Math.random() * 2 - 1);
+}
 class Vigor {
-    constructor() {
-        this._Fetch = VigorFetch;
-        this._Retry = VigorRetry;
-        this._Parse = VigorParse;
-        this._All = VigorAll;
-    }
-    use(plugin, options = {}) {
-        if (typeof plugin === 'function') {
-            plugin(this, options);
-        }
-        return this;
+    registry;
+    constructor(config) {
+        const defaultRegistry = {
+            VigorRetry: {
+                main: () => new VigorRetry(),
+                error: VigorRetryError,
+                setting: VigorRetrySettings,
+                interceptors: VigorRetryInterceptors,
+                backoff: VigorRetryBackoff,
+            },
+            VigorFetch: {
+                main: () => new VigorFetch(),
+                error: VigorFetchError,
+                setting: VigorFetchSettings,
+                interceptors: VigorFetchInterceptors,
+            },
+            VigorAll: {
+                main: () => new VigorAll(),
+                error: VigorAllError,
+                setting: VigorAllSettings,
+                interceptors: VigorAllInterceptors,
+            },
+            VigorParse: {
+                main: () => new VigorParse(),
+                error: VigorParseError,
+            }
+        };
+        this.registry = config?.registry ?? defaultRegistry;
+    }
+    fetch(origin) {
+        return this.registry.VigorFetch.main().origin(origin);
     }
-    fetch(origin, config) {
-        return new this._Fetch(origin, config);
+    all(tasks) {
+        return this.registry.VigorAll.main().target(tasks.flat());
     }
-    retry(target, args, config) {
-        return new this._Retry(target, args, config);
+    parse(response) {
+        return this.registry.VigorParse.main().target(response);
     }
-    parse(response, config) {
-        return new this._Parse(response, config);
+    retry(fn) {
+        return this.registry.VigorRetry.main().target(fn);
     }
-    all(config) {
-        return new this._All(config);
+    use(plugin, options) {
+        const nextRegistry = {
+            ...this.registry,
+            VigorFetch: {
+                ...this.registry.VigorFetch
+            },
+            VigorRetry: {
+                ...this.registry.VigorRetry
+            },
+            VigorAll: {
+                ...this.registry.VigorAll
+            },
+            VigorParse: {
+                ...this.registry.VigorParse
+            }
+        };
+        plugin(nextRegistry, options);
+        return new Vigor({
+            registry: nextRegistry
+        });
     }
 }
 const vigor = new Vigor();
-const vigorInstance = vigor;
-vigorInstance.VigorError = VigorError;
-vigorInstance.VigorRetryError = VigorRetryError;
-vigorInstance.VigorParseError = VigorParseError;
-vigorInstance.VigorFetchError = VigorFetchError;
-vigorInstance.VigorAllError = VigorAllError;
-vigorInstance.VigorFetch = VigorFetch;
-vigorInstance.VigorRetry = VigorRetry;
-vigorInstance.VigorParse = VigorParse;
-vigorInstance.VigorAll = VigorAll;
 
+exports.Vigor = Vigor;
 exports.VigorAll = VigorAll;
 exports.VigorAllError = VigorAllError;
-exports.VigorError = VigorError;
+exports.VigorAllInterceptors = VigorAllInterceptors;
+exports.VigorAllSettings = VigorAllSettings;
 exports.VigorFetch = VigorFetch;
 exports.VigorFetchError = VigorFetchError;
+exports.VigorFetchInterceptors = VigorFetchInterceptors;
+exports.VigorFetchSettings = VigorFetchSettings;
 exports.VigorParse = VigorParse;
 exports.VigorParseError = VigorParseError;
 exports.VigorRetry = VigorRetry;
+exports.VigorRetryBackoff = VigorRetryBackoff;
 exports.VigorRetryError = VigorRetryError;
+exports.VigorRetryInterceptors = VigorRetryInterceptors;
+exports.VigorRetrySettings = VigorRetrySettings;
 exports.default = vigor;
 exports.vigor = vigor;