undici 6.19.7 → 7.0.0-alpha.1

package/types/mock-agent.d.ts

@@ -1,7 +1,7 @@
 import Agent from './agent'
 import Dispatcher from './dispatcher'
 import { Interceptable, MockInterceptor } from './mock-interceptor'
-import MockDispatch = MockInterceptor.MockDispatch;
+import MockDispatch = MockInterceptor.MockDispatch
 
 export default MockAgent
 
@@ -11,30 +11,30 @@ interface PendingInterceptor extends MockDispatch {
 
 /** A mocked Agent class that implements the Agent API. It allows one to intercept HTTP requests made through undici and return mocked responses instead. */
 declare class MockAgent<TMockAgentOptions extends MockAgent.Options = MockAgent.Options> extends Dispatcher {
-  constructor(options?: MockAgent.Options)
+  constructor (options?: TMockAgentOptions)
   /** Creates and retrieves mock Dispatcher instances which can then be used to intercept HTTP requests. If the number of connections on the mock agent is set to 1, a MockClient instance is returned. Otherwise a MockPool instance is returned. */
-  get<TInterceptable extends Interceptable>(origin: string): TInterceptable;
-  get<TInterceptable extends Interceptable>(origin: RegExp): TInterceptable;
-  get<TInterceptable extends Interceptable>(origin: ((origin: string) => boolean)): TInterceptable;
+  get<TInterceptable extends Interceptable>(origin: string): TInterceptable
+  get<TInterceptable extends Interceptable>(origin: RegExp): TInterceptable
+  get<TInterceptable extends Interceptable>(origin: ((origin: string) => boolean)): TInterceptable
   /** Dispatches a mocked request. */
-  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean
   /** Closes the mock agent and waits for registered mock pools and clients to also close before resolving. */
-  close(): Promise<void>;
+  close (): Promise<void>
   /** Disables mocking in MockAgent. */
-  deactivate(): void;
+  deactivate (): void
   /** Enables mocking in a MockAgent instance. When instantiated, a MockAgent is automatically activated. Therefore, this method is only effective after `MockAgent.deactivate` has been called. */
-  activate(): void;
+  activate (): void
   /** Define host matchers so only matching requests that aren't intercepted by the mock dispatchers will be attempted. */
-  enableNetConnect(): void;
-  enableNetConnect(host: string): void;
-  enableNetConnect(host: RegExp): void;
-  enableNetConnect(host: ((host: string) => boolean)): void;
+  enableNetConnect (): void
+  enableNetConnect (host: string): void
+  enableNetConnect (host: RegExp): void
+  enableNetConnect (host: ((host: string) => boolean)): void
   /** Causes all requests to throw when requests are not matched in a MockAgent intercept. */
-  disableNetConnect(): void;
-  pendingInterceptors(): PendingInterceptor[];
-  assertNoPendingInterceptors(options?: {
+  disableNetConnect (): void
+  pendingInterceptors (): PendingInterceptor[]
+  assertNoPendingInterceptors (options?: {
     pendingInterceptorsFormatter?: PendingInterceptorsFormatter;
-  }): void;
+  }): void
 }
 
 interface PendingInterceptorsFormatter {
@@ -45,6 +45,6 @@ declare namespace MockAgent {
   /** MockAgent options. */
   export interface Options extends Agent.Options {
     /** A custom agent to be encapsulated by the MockAgent. */
-    agent?: Agent;
+    agent?: Dispatcher;
   }
 }

package/types/mock-client.d.ts

@@ -7,13 +7,13 @@ export default MockClient
 
 /** MockClient extends the Client API and allows one to mock requests. */
 declare class MockClient extends Client implements Interceptable {
-  constructor(origin: string, options: MockClient.Options);
+  constructor (origin: string, options: MockClient.Options)
   /** Intercepts any matching requests that use the same origin as this mock client. */
-  intercept(options: MockInterceptor.Options): MockInterceptor;
+  intercept (options: MockInterceptor.Options): MockInterceptor
   /** Dispatches a mocked request. */
-  dispatch(options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandlers): boolean;
+  dispatch (options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandlers): boolean
   /** Closes the mock client and gracefully waits for enqueued requests to complete. */
-  close(): Promise<void>;
+  close (): Promise<void>
 }
 
 declare namespace MockClient {

package/types/mock-errors.d.ts

@@ -5,8 +5,8 @@ export default MockErrors
 declare namespace MockErrors {
   /** The request does not match any registered mock dispatches. */
   export class MockNotMatchedError extends Errors.UndiciError {
-    constructor(message?: string);
-    name: 'MockNotMatchedError';
-    code: 'UND_MOCK_ERR_MOCK_NOT_MATCHED';
+    constructor (message?: string)
+    name: 'MockNotMatchedError'
+    code: 'UND_MOCK_ERR_MOCK_NOT_MATCHED'
   }
 }

package/types/mock-interceptor.d.ts

@@ -1,42 +1,36 @@
 import { IncomingHttpHeaders } from './header'
-import Dispatcher from './dispatcher';
+import Dispatcher from './dispatcher'
 import { BodyInit, Headers } from './fetch'
 
-export {
-  Interceptable,
-  MockInterceptor,
-  MockScope
-}
-
 /** The scope associated with a mock dispatch. */
 declare class MockScope<TData extends object = object> {
-  constructor(mockDispatch: MockInterceptor.MockDispatch<TData>);
+  constructor (mockDispatch: MockInterceptor.MockDispatch<TData>)
   /** Delay a reply by a set amount of time in ms. */
-  delay(waitInMs: number): MockScope<TData>;
+  delay (waitInMs: number): MockScope<TData>
   /** Persist the defined mock data for the associated reply. It will return the defined mock data indefinitely. */
-  persist(): MockScope<TData>;
+  persist (): MockScope<TData>
   /** Define a reply for a set amount of matching requests. */
-  times(repeatTimes: number): MockScope<TData>;
+  times (repeatTimes: number): MockScope<TData>
 }
 
 /** The interceptor for a Mock. */
 declare class MockInterceptor {
-  constructor(options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[]);
+  constructor (options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[])
   /** Mock an undici request with the defined reply. */
-  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>;
+  reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>
   reply<TData extends object = object>(
     statusCode: number,
     data?: TData | Buffer | string | MockInterceptor.MockResponseDataHandler<TData>,
     responseOptions?: MockInterceptor.MockResponseOptions
-  ): MockScope<TData>;
+  ): MockScope<TData>
   /** Mock an undici request by throwing the defined reply error. */
-  replyWithError<TError extends Error = Error>(error: TError): MockScope;
+  replyWithError<TError extends Error = Error>(error: TError): MockScope
   /** Set default reply headers on the interceptor for subsequent mocked replies. */
-  defaultReplyHeaders(headers: IncomingHttpHeaders): MockInterceptor;
+  defaultReplyHeaders (headers: IncomingHttpHeaders): MockInterceptor
   /** Set default reply trailers on the interceptor for subsequent mocked replies. */
-  defaultReplyTrailers(trailers: Record<string, string>): MockInterceptor;
+  defaultReplyTrailers (trailers: Record<string, string>): MockInterceptor
   /** Set automatically calculated content-length header on subsequent mocked replies. */
-  replyContentLength(): MockInterceptor;
+  replyContentLength (): MockInterceptor
 }
 
 declare namespace MockInterceptor {
@@ -80,7 +74,7 @@ declare namespace MockInterceptor {
 
   export type MockResponseDataHandler<TData extends object = object> = (
     opts: MockResponseCallbackOptions
-  ) => TData | Buffer | string;
+  ) => TData | Buffer | string
 
   export type MockReplyOptionsCallback<TData extends object = object> = (
     opts: MockResponseCallbackOptions
@@ -91,3 +85,9 @@ interface Interceptable extends Dispatcher {
   /** Intercepts any matching requests that use the same origin as this mock client. */
   intercept(options: MockInterceptor.Options): MockInterceptor;
 }
+
+export {
+  Interceptable,
+  MockInterceptor,
+  MockScope
+}

package/types/mock-pool.d.ts

@@ -7,13 +7,13 @@ export default MockPool
 
 /** MockPool extends the Pool API and allows one to mock requests. */
 declare class MockPool extends Pool implements Interceptable {
-  constructor(origin: string, options: MockPool.Options);
+  constructor (origin: string, options: MockPool.Options)
   /** Intercepts any matching requests that use the same origin as this mock pool. */
-  intercept(options: MockInterceptor.Options): MockInterceptor;
+  intercept (options: MockInterceptor.Options): MockInterceptor
   /** Dispatches a mocked request. */
-  dispatch(options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandlers): boolean;
+  dispatch (options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandlers): boolean
   /** Closes the mock pool and gracefully waits for enqueued requests to complete. */
-  close(): Promise<void>;
+  close (): Promise<void>
 }
 
 declare namespace MockPool {

package/types/patch.d.ts

@@ -2,48 +2,6 @@
 
 // See https://github.com/nodejs/undici/issues/1740
 
-export type DOMException = typeof globalThis extends { DOMException: infer T }
- ? T
- : any
-
-export type EventTarget = typeof globalThis extends { EventTarget: infer T }
-  ? T
-  : {
-    addEventListener(
-      type: string,
-      listener: any,
-      options?: any,
-    ): void
-    dispatchEvent(event: Event): boolean
-    removeEventListener(
-      type: string,
-      listener: any,
-      options?: any | boolean,
-    ): void
-  }
-
-export type Event = typeof globalThis extends { Event: infer T }
-  ? T
-  : {
-    readonly bubbles: boolean
-    cancelBubble: () => void
-    readonly cancelable: boolean
-    readonly composed: boolean
-    composedPath(): [EventTarget?]
-    readonly currentTarget: EventTarget | null
-    readonly defaultPrevented: boolean
-    readonly eventPhase: 0 | 2
-    readonly isTrusted: boolean
-    preventDefault(): void
-    returnValue: boolean
-    readonly srcElement: EventTarget | null
-    stopImmediatePropagation(): void
-    stopPropagation(): void
-    readonly target: EventTarget | null
-    readonly timeStamp: number
-    readonly type: string
-  }
-
 export interface EventInit {
   bubbles?: boolean
   cancelable?: boolean

package/types/pool-stats.d.ts

@@ -1,19 +1,19 @@
-import Pool from "./pool"
+import Pool from './pool'
 
 export default PoolStats
 
 declare class PoolStats {
-  constructor(pool: Pool);
+  constructor (pool: Pool)
   /** Number of open socket connections in this pool. */
-  connected: number;
+  connected: number
   /** Number of open socket connections in this pool that do not have an active request. */
-  free: number;
+  free: number
   /** Number of pending requests across all clients in this pool. */
-  pending: number;
+  pending: number
   /** Number of queued requests across all clients in this pool. */
-  queued: number;
+  queued: number
   /** Number of currently active requests across all clients in this pool. */
-  running: number;
+  running: number
   /** Number of active, pending, or queued requests across all clients in this pool. */
-  size: number;
+  size: number
 }

package/types/pool.d.ts

@@ -1,39 +1,39 @@
 import Client from './client'
 import TPoolStats from './pool-stats'
 import { URL } from 'url'
-import Dispatcher from "./dispatcher";
+import Dispatcher from './dispatcher'
 
 export default Pool
 
-type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, "origin">;
+type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>
 
 declare class Pool extends Dispatcher {
-  constructor(url: string | URL, options?: Pool.Options)
+  constructor (url: string | URL, options?: Pool.Options)
   /** `true` after `pool.close()` has been called. */
-  closed: boolean;
+  closed: boolean
   /** `true` after `pool.destroyed()` has been called or `pool.close()` has been called and the pool shutdown has completed. */
-  destroyed: boolean;
+  destroyed: boolean
   /** Aggregate stats for a Pool. */
-  readonly stats: TPoolStats;
+  readonly stats: TPoolStats
 
   // Override dispatcher APIs.
-  override connect(
+  override connect (
     options: PoolConnectOptions
-  ): Promise<Dispatcher.ConnectData>;
-  override connect(
+  ): Promise<Dispatcher.ConnectData>
+  override connect (
     options: PoolConnectOptions,
     callback: (err: Error | null, data: Dispatcher.ConnectData) => void
-  ): void;
+  ): void
 }
 
 declare namespace Pool {
-  export type PoolStats = TPoolStats;
+  export type PoolStats = TPoolStats
   export interface Options extends Client.Options {
     /** Default: `(origin, opts) => new Client(origin, opts)`. */
     factory?(origin: URL, opts: object): Dispatcher;
     /** The max number of clients to create. `null` if no limit. Default `null`. */
     connections?: number | null;
 
-    interceptors?: { Pool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options["interceptors"]
+    interceptors?: { Pool?: readonly Dispatcher.DispatchInterceptor[] } & Client.Options['interceptors']
   }
 }

package/types/proxy-agent.d.ts

@@ -1,15 +1,15 @@
 import Agent from './agent'
-import buildConnector from './connector';
+import buildConnector from './connector'
 import Dispatcher from './dispatcher'
 import { IncomingHttpHeaders } from './header'
 
 export default ProxyAgent
 
 declare class ProxyAgent extends Dispatcher {
-  constructor(options: ProxyAgent.Options | string)
+  constructor (options: ProxyAgent.Options | string)
 
-  dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean;
-  close(): Promise<void>;
+  dispatch (options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandlers): boolean
+  close (): Promise<void>
 }
 
 declare namespace ProxyAgent {

package/types/readable.d.ts

@@ -1,10 +1,10 @@
-import { Readable } from "stream";
+import { Readable } from 'stream'
 import { Blob } from 'buffer'
 
 export default BodyReadable
 
 declare class BodyReadable extends Readable {
-  constructor(
+  constructor (
     resume?: (this: Readable, size: number) => void | null,
     abort?: () => void | null,
     contentType?: string
@@ -13,28 +13,33 @@ declare class BodyReadable extends Readable {
   /** Consumes and returns the body as a string
    *  https://fetch.spec.whatwg.org/#dom-body-text
    */
-  text(): Promise<string>
+  text (): Promise<string>
 
   /** Consumes and returns the body as a JavaScript Object
    *  https://fetch.spec.whatwg.org/#dom-body-json
    */
-  json(): Promise<unknown>
+  json (): Promise<unknown>
 
   /** Consumes and returns the body as a Blob
    *  https://fetch.spec.whatwg.org/#dom-body-blob
    */
-  blob(): Promise<Blob>
+  blob (): Promise<Blob>
+
+  /** Consumes and returns the body as an Uint8Array
+   *  https://fetch.spec.whatwg.org/#dom-body-bytes
+   */
+  bytes (): Promise<Uint8Array>
 
   /** Consumes and returns the body as an ArrayBuffer
    *  https://fetch.spec.whatwg.org/#dom-body-arraybuffer
    */
-  arrayBuffer(): Promise<ArrayBuffer>
+  arrayBuffer (): Promise<ArrayBuffer>
 
   /** Not implemented
    *
    *  https://fetch.spec.whatwg.org/#dom-body-formdata
    */
-  formData(): Promise<never>
+  formData (): Promise<never>
 
   /** Returns true if the body is not null and the body has been consumed
    *
@@ -44,7 +49,7 @@ declare class BodyReadable extends Readable {
    */
   readonly bodyUsed: boolean
 
-  /** 
+  /**
    * If body is null, it should return null as the body
    *
    *  If body is not null, should return the body as a ReadableStream
@@ -56,5 +61,5 @@ declare class BodyReadable extends Readable {
   /** Dumps the response body by reading `limit` number of bytes.
    * @param opts.limit Number of bytes to read (optional) - Default: 262144
    */
-  dump(opts?: { limit: number }): Promise<void>
+  dump (opts?: { limit: number }): Promise<void>
 }

package/types/retry-agent.d.ts

@@ -4,5 +4,5 @@ import RetryHandler from './retry-handler'
 export default RetryAgent
 
 declare class RetryAgent extends Dispatcher {
-  constructor(dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
+  constructor (dispatcher: Dispatcher, options?: RetryHandler.RetryOptions)
 }

package/types/retry-handler.d.ts

@@ -1,18 +1,18 @@
-import Dispatcher from "./dispatcher";
+import Dispatcher from './dispatcher'
 
-export default RetryHandler;
+export default RetryHandler
 
 declare class RetryHandler implements Dispatcher.DispatchHandlers {
-  constructor(
+  constructor (
     options: Dispatcher.DispatchOptions & {
       retryOptions?: RetryHandler.RetryOptions;
     },
     retryHandlers: RetryHandler.RetryHandlers
-  );
+  )
 }
 
 declare namespace RetryHandler {
-  export type RetryState = { counter: number; };
+  export type RetryState = { counter: number; }
 
   export type RetryContext = {
     state: RetryState;
@@ -21,7 +21,7 @@ declare namespace RetryHandler {
     };
   }
 
-  export type OnRetryCallback = (result?: Error | null) => void;
+  export type OnRetryCallback = (result?: Error | null) => void
 
   export type RetryCallback = (
     err: Error,
@@ -32,7 +32,7 @@ declare namespace RetryHandler {
       };
     },
     callback: OnRetryCallback
-  ) => number | null;
+  ) => number | null
 
   export interface RetryOptions {
     /**
@@ -110,7 +110,7 @@ declare namespace RetryHandler {
   }
 
   export interface RetryHandlers {
-    dispatch: Dispatcher["dispatch"];
+    dispatch: Dispatcher['dispatch'];
     handler: Dispatcher.DispatchHandlers;
   }
 }

package/types/util.d.ts

@@ -3,7 +3,7 @@ export namespace util {
    * Retrieves a header name and returns its lowercase value.
    * @param value Header name
    */
-  export function headerNameToString(value: string | Buffer): string;
+  export function headerNameToString (value: string | Buffer): string
 
   /**
    * Receives a header object and returns the parsed value.
@@ -11,8 +11,8 @@ export namespace util {
    * @param obj Object to specify a proxy object. Used to assign parsed values.
    * @returns If `obj` is specified, it is equivalent to `obj`.
    */
-  export function parseHeaders(
+  export function parseHeaders (
     headers: (Buffer | string | (Buffer | string)[])[],
     obj?: Record<string, string | string[]>
-  ): Record<string, string | string[]>;
+  ): Record<string, string | string[]>
 }

package/types/utility.d.ts

@@ -0,0 +1,7 @@
+type AutocompletePrimitiveBaseType<T> =
+  T extends string ? string :
+    T extends number ? number :
+      T extends boolean ? boolean :
+        never
+
+export type Autocomplete<T> = T | (AutocompletePrimitiveBaseType<T> & Record<never, never>)

package/types/webidl.d.ts

@@ -34,11 +34,24 @@ interface WebidlErrors {
   }): TypeError
 }
 
+interface WebIDLTypes {
+  UNDEFINED: 1,
+  BOOLEAN: 2,
+  STRING: 3,
+  SYMBOL: 4,
+  NUMBER: 5,
+  BIGINT: 6,
+  NULL: 7
+  OBJECT: 8
+}
+
 interface WebidlUtil {
   /**
    * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
    */
-  Type (object: unknown):
+  Type (object: unknown): WebIDLTypes
+
+  TypeValueToString (o: unknown):
     | 'Undefined'
     | 'Boolean'
     | 'String'
@@ -48,6 +61,8 @@ interface WebidlUtil {
     | 'Null'
     | 'Object'
 
+  Types: WebIDLTypes
+
   /**
    * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
    */
@@ -150,7 +165,7 @@ interface WebidlConverters {
   ): NodeJS.TypedArray | ArrayBufferLike | DataView
 
   ['sequence<ByteString>']: SequenceConverter<string>
-  
+
   ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
 
   ['record<ByteString, ByteString>']: RecordConverter<string, string>
@@ -167,7 +182,9 @@ export interface Webidl {
    * @description Performs a brand-check on {@param V} to ensure it is a
    * {@param cls} object.
    */
-  brandCheck <Interface>(V: unknown, cls: Interface, opts?: { strict?: boolean }): asserts V is Interface
+  brandCheck <Interface extends new () => unknown>(V: unknown, cls: Interface): asserts V is Interface
+
+  brandCheckMultiple <Interfaces extends (new () => unknown)[]> (V: unknown, list: Interfaces): asserts V is Interfaces[number]
 
   /**
    * @see https://webidl.spec.whatwg.org/#es-sequence
@@ -192,7 +209,8 @@ export interface Webidl {
    */
   interfaceConverter <Interface>(cls: Interface): (
     V: unknown,
-    opts?: { strict: boolean }
+    prefix: string,
+    argument: string
   ) => asserts V is typeof cls
 
   // TODO(@KhafraDev): a type could likely be implemented that can infer the return type

package/types/websocket.d.ts

@@ -3,8 +3,6 @@
 import type { Blob } from 'buffer'
 import type { MessagePort } from 'worker_threads'
 import {
-  EventTarget,
-  Event,
   EventInit,
   EventListenerOptions,
   AddEventListenerOptions,
@@ -24,7 +22,7 @@ interface WebSocketEventMap {
 
 interface WebSocket extends EventTarget {
   binaryType: BinaryType
-  
+
   readonly bufferedAmount: number
   readonly extensions: string
 

package/docs/docs/api/DispatchInterceptor.md

@@ -1,60 +0,0 @@
-# Interface: DispatchInterceptor
-
-Extends: `Function`
-
-A function that can be applied to the `Dispatcher.Dispatch` function before it is invoked with a dispatch request.
-
-This allows one to write logic to intercept both the outgoing request, and the incoming response.
-
-### Parameter: `Dispatcher.Dispatch`
-
-The base dispatch function you are decorating.
-
-### ReturnType: `Dispatcher.Dispatch`
-
-A dispatch function that has been altered to provide additional logic
-
-### Basic Example
-
-Here is an example of an interceptor being used to provide a JWT bearer token
-
-```js
-'use strict'
-
-const insertHeaderInterceptor = dispatch => {
-  return function InterceptedDispatch(opts, handler){
-    opts.headers.push('Authorization', 'Bearer [Some token]')
-    return dispatch(opts, handler)
-  }
-}
-
-const client = new Client('https://localhost:3000', {
-  interceptors: { Client: [insertHeaderInterceptor] }
-})
-
-```
-
-### Basic Example 2
-
-Here is a contrived example of an interceptor stripping the headers from a response.
-
-```js
-'use strict'
-
-const clearHeadersInterceptor = dispatch => {
-  const { DecoratorHandler } = require('undici')
-  class ResultInterceptor extends DecoratorHandler {
-    onHeaders (statusCode, headers, resume) {
-      return super.onHeaders(statusCode, [], resume)
-    }
-  }
-  return function InterceptedDispatch(opts, handler){
-    return dispatch(opts, new ResultInterceptor(handler))
-  }
-}
-
-const client = new Client('https://localhost:3000', {
-  interceptors: { Client: [clearHeadersInterceptor] }
-})
-
-```

package/lib/interceptor/redirect-interceptor.js

@@ -1,21 +0,0 @@
-'use strict'
-
-const RedirectHandler = require('../handler/redirect-handler')
-
-function createRedirectInterceptor ({ maxRedirections: defaultMaxRedirections }) {
-  return (dispatch) => {
-    return function Intercept (opts, handler) {
-      const { maxRedirections = defaultMaxRedirections } = opts
-
-      if (!maxRedirections) {
-        return dispatch(opts, handler)
-      }
-
-      const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler)
-      opts = { ...opts, maxRedirections: 0 } // Stop sub dispatcher from also redirecting.
-      return dispatch(opts, redirectHandler)
-    }
-  }
-}
-
-module.exports = createRedirectInterceptor