got 14.6.6 → 15.0.0

package/dist/source/core/options.d.ts

@@ -1,4 +1,3 @@
-import type { Buffer } from 'node:buffer';
 import { checkServerIdentity, type SecureContextOptions, type DetailedPeerCertificate } from 'node:tls';
 import https, { type RequestOptions as HttpsRequestOptions, type Agent as HttpsAgent } from 'node:https';
 import http, { type Agent as HttpAgent, type ClientRequest } from 'node:http';
@@ -6,16 +5,15 @@ import type { Readable } from 'node:stream';
 import type { Socket, LookupFunction } from 'node:net';
 import CacheableLookup from 'cacheable-lookup';
 import http2wrapper, { type ClientHttp2Session } from 'http2-wrapper';
-import { type FormDataLike } from 'form-data-encoder';
 import type { KeyvStoreAdapter } from 'keyv';
 import type KeyvType from 'keyv';
 import type ResponseLike from 'responselike';
-import type { CancelableRequest } from '../as-promise/types.js';
+import type { RequestPromise } from '../as-promise/types.js';
 import type { IncomingMessageWithTimings } from './utils/timer.js';
 import type { PlainResponse, Response } from './response.js';
 import type { RequestError } from './errors.js';
 import type { Delays } from './timed-out.js';
-type StorageAdapter = KeyvStoreAdapter | KeyvType | Map<any, any>;
+type StorageAdapter = KeyvStoreAdapter | KeyvType | Map<unknown, unknown>;
 type Promisable<T> = T | Promise<T>;
 export type DnsLookupIpVersion = undefined | 4 | 6;
 type Except<ObjectType, KeysType extends keyof ObjectType> = Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>;
@@ -23,7 +21,7 @@ export type NativeRequestOptions = HttpsRequestOptions & CacheOptions & {
     checkServerIdentity?: CheckServerIdentityFunction;
 };
 type AcceptableResponse = IncomingMessageWithTimings | ResponseLike;
-type AcceptableRequestResult = Promisable<AcceptableResponse | ClientRequest> | undefined;
+type AcceptableRequestResult = Promisable<AcceptableResponse | ClientRequest | undefined>;
 export type RequestFunction = (url: URL, options: NativeRequestOptions, callback?: (response: AcceptableResponse) => void) => AcceptableRequestResult;
 export type Agents = {
     http?: HttpAgent | false;
@@ -31,9 +29,20 @@ export type Agents = {
     http2?: unknown | false;
 };
 export type Headers = Record<string, string | string[] | undefined>;
+export type CrossOriginState = {
+    headers: Headers;
+    username: string;
+    password: string;
+    body: unknown;
+    json: unknown;
+    form: unknown;
+    bodySnapshot: unknown;
+    jsonSnapshot: unknown;
+    formSnapshot: unknown;
+};
 export type ToughCookieJar = {
-    getCookieString: ((currentUrl: string, options: Record<string, unknown>, callback: (error: Error | null, cookies: string) => void) => void) & ((url: string, callback: (error: Error | null, cookieHeader: string) => void) => void);
-    setCookie: ((cookieOrString: unknown, currentUrl: string, options: Record<string, unknown>, callback: (error: Error | null, cookie: unknown) => void) => void) & ((rawCookie: string, url: string, callback: (error: Error | null, result: unknown) => void) => void);
+    getCookieString: ((currentUrl: string, options: Record<string, unknown>, callback: (error: Error | undefined, cookies: string) => void) => void) & ((url: string, callback: (error: Error | undefined, cookieHeader: string) => void) => void);
+    setCookie: ((cookieOrString: unknown, currentUrl: string, options: Record<string, unknown>, callback: (error: Error | undefined, cookie: unknown) => void) => void) & ((rawCookie: string, url: string, callback: (error: Error | undefined, result: unknown) => void) => void);
 };
 export type PromiseCookieJar = {
     getCookieString: (url: string) => Promise<string>;
@@ -70,7 +79,7 @@ export type BeforeRedirectHook = (updatedOptions: NormalizedOptions, plainRespon
 export type BeforeErrorHook = (error: RequestError) => Promisable<Error>;
 export type BeforeRetryHook = (error: RequestError, retryCount: number) => Promisable<void>;
 export type BeforeCacheHook = (response: PlainResponse) => false | void;
-export type AfterResponseHook<ResponseType = unknown> = (response: Response<ResponseType>, retryWithMergedOptions: (options: OptionsInit) => never) => Promisable<Response | CancelableRequest<Response>>;
+export type AfterResponseHook<ResponseType = unknown> = (response: Response<ResponseType>, retryWithMergedOptions: (options: OptionsInit) => never) => Promisable<Response | RequestPromise<Response>>;
 /**
 All available hooks of Got.
 */
@@ -522,9 +531,9 @@ Delays between retries counts with function `1000 * Math.pow(2, retry) + Math.ra
 The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
 The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
 
-The `enforceRetryRules` property is a `boolean` that, when set to `true`, enforces the `limit`, `methods`, `statusCodes`, and `errorCodes` options before calling `calculateDelay`. Your `calculateDelay` function is only invoked when a retry is allowed based on these criteria. When `false` (default), `calculateDelay` receives the computed value but can override all retry logic.
+The `enforceRetryRules` property is a `boolean` that, when set to `true` (default), enforces the `limit`, `methods`, `statusCodes`, and `errorCodes` options before calling `calculateDelay`. Your `calculateDelay` function is only invoked when a retry is allowed based on these criteria. When `false`, `calculateDelay` receives the computed value but can override all retry logic.
 
-__Note:__ When `enforceRetryRules` is `false`, you must check `computedValue` in your `calculateDelay` function to respect the default retry logic. When `true`, the retry rules are enforced automatically.
+__Note:__ When `enforceRetryRules` is `false`, you must check `computedValue` in your `calculateDelay` function to respect retry rules. When `true` (default), the retry rules are enforced automatically.
 
 By default, it retries *only* on the specified methods, status codes, and on these network errors:
 - `ETIMEDOUT`: One of the [timeout](#timeout) limits were reached.
@@ -560,10 +569,10 @@ export type CacheOptions = {
     ignoreCargoCult?: boolean;
 };
 type PfxObject = {
-    buffer: string | Buffer;
+    buffer: string | Uint8Array;
     passphrase?: string | undefined;
 };
-type PfxType = string | Buffer | Array<string | Buffer | PfxObject> | undefined;
+type PfxType = string | Uint8Array | Array<string | Uint8Array | PfxObject> | undefined;
 export type HttpsOptions = {
     alpnProtocols?: string[];
     rejectUnauthorized?: NativeRequestOptions['rejectUnauthorized'];
@@ -606,7 +615,7 @@ export type HttpsOptions = {
     [PEM](https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) allows the option of private keys being encrypted.
     Encrypted keys will be decrypted with `options.https.passphrase`.
 
-    Multiple keys with different passphrases can be provided as an array of `{pem: <string | Buffer>, passphrase: <string>}`
+    Multiple keys with different passphrases can be provided as an array of `{pem: <string | Uint8Array>, passphrase: <string>}`
     */
     key?: SecureContextOptions['key'];
     /**
@@ -767,26 +776,30 @@ export type PaginationOptions<ElementType, BodyType> = {
     */
     stackAllItems?: boolean;
 };
-export type SearchParameters = Record<string, string | number | boolean | null | undefined>;
+export type SearchParameters = Record<string, string | number | boolean | undefined>;
+export declare function isSameOrigin(previousUrl: URL, nextUrl: URL): boolean;
+export declare const crossOriginStripHeaders: readonly ["host", "cookie", "cookie2", "authorization", "proxy-authorization"];
+export declare const hasExplicitCredentialInUrlChange: (changedState: Set<string>, url: URL | undefined, credential: "username" | "password") => boolean;
+export declare function applyUrlOverride(options: Options, url: string | URL, { username, password }?: {
+    username?: string;
+    password?: string;
+}): URL;
 /**
 All parsing methods supported by Got.
 */
 export type ResponseType = 'json' | 'buffer' | 'text';
-type OptionsToSkip = 'searchParameters' | 'followRedirects' | 'auth' | 'toJSON' | 'merge' | 'createNativeRequestOptions' | 'getRequestFunction' | 'getFallbackRequestFunction' | 'freeze';
+type OptionsToSkip = 'searchParameters' | 'followRedirects' | 'auth' | 'toJSON' | 'merge' | 'isHeaderExplicitlySet' | 'shouldCopyPipedHeader' | 'setPipedHeader' | 'getInternalHeaders' | 'setInternalHeader' | 'deleteInternalHeader' | 'trackStateMutations' | 'clearBody' | 'stripUnchangedCrossOriginState' | 'stripSensitiveHeaders' | 'createNativeRequestOptions' | 'getRequestFunction' | 'freeze';
 export type InternalsType = Except<Options, OptionsToSkip>;
 export type OptionsError = NodeJS.ErrnoException & {
     options?: Options;
 };
-export type OptionsInit = Except<Partial<InternalsType>, 'hooks' | 'retry'> & {
+export type OptionsInit = Except<Partial<InternalsType>, 'hooks' | 'retry' | 'isStream'> & {
     hooks?: Partial<Hooks>;
     retry?: Partial<RetryOptions>;
     preserveHooks?: boolean;
 };
 export default class Options {
-    private _unixOptions?;
-    private readonly _internals;
-    private _merging;
-    private readonly _init;
+    #private;
     constructor(input?: string | URL | OptionsInit, options?: OptionsInit, defaults?: Options);
     merge(options?: OptionsInit | Options): void;
     /**
@@ -828,7 +841,7 @@ export default class Options {
 
     This will set the `accept-encoding` header to `gzip, deflate, br` unless you set it yourself.
 
-    If this is disabled, a compressed response is returned as a `Buffer`.
+    If this is disabled, a compressed response is returned as a `Uint8Array`.
     This may be useful if you want to handle decompression yourself or stream the raw compressed data.
 
     @default true
@@ -902,7 +915,7 @@ export default class Options {
 
     __Note #4__: This option is not enumerable and will not be merged with the instance defaults.
 
-    The `content-length` header will be automatically set if `body` is a `string` / `Buffer` / typed array ([`Uint8Array`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), etc.) / [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) / [`form-data` instance](https://github.com/form-data/form-data), and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
+    The `content-length` header will be automatically set if `body` is a `string` / `Uint8Array` / typed array, and `content-length` and `transfer-encoding` are not manually set in `options.headers`.
 
     Since Got 12, the `content-length` is not automatically set when `body` is a `fs.createReadStream`.
 
@@ -923,8 +936,8 @@ export default class Options {
     });
     ```
     */
-    get body(): string | Buffer | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormDataLike | ArrayBufferView | undefined;
-    set body(value: string | Buffer | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormDataLike | ArrayBufferView | undefined);
+    get body(): string | Uint8Array | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormData | ArrayBufferView | undefined;
+    set body(value: string | Uint8Array | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormData | ArrayBufferView | undefined);
     /**
     The form body is converted to a query string using [`(new URLSearchParams(object)).toString()`](https://nodejs.org/api/url.html#url_constructor_new_urlsearchparams_obj).
 
@@ -1084,6 +1097,7 @@ export default class Options {
 
     Note that if a `303` is sent by the server in response to any request type (`POST`, `DELETE`, etc.), Got will automatically request the resource pointed to in the location header via `GET`.
     This is in accordance with [the spec](https://tools.ietf.org/html/rfc7231#section-6.4.4). You can optionally turn on this behavior also for other redirect codes - see `methodRewriting`.
+    On cross-origin redirects, Got strips `host`, `cookie`, `cookie2`, `authorization`, and `proxy-authorization`. When a redirect rewrites the request to `GET`, Got also strips request body headers. Use `hooks.beforeRedirect` for app-specific sensitive headers.
 
     @default true
     */
@@ -1158,25 +1172,24 @@ export default class Options {
 
     When piping a request into a Got stream (e.g., `request.pipe(got.stream(url))`), this controls whether headers from the source stream are automatically merged into the Got request headers.
 
-    Note: Piped headers overwrite any explicitly set headers with the same name. To override this, either set `copyPipedHeaders` to `false` and manually copy safe headers, or use a `beforeRequest` hook to force specific header values after piping.
+    Note: Explicitly set headers take precedence over piped headers. Piped headers are only copied when a header is not already explicitly set.
 
-    Useful for proxy scenarios, but you may want to disable this to filter out headers like `Host`, `Connection`, `Authorization`, etc.
+    Useful for proxy scenarios when explicitly enabled, but you may still want to filter out headers like `Host`, `Connection`, `Authorization`, etc.
 
-    @default true
+    @default false
 
     @example
     ```
     import got from 'got';
     import {pipeline} from 'node:stream/promises';
 
-    // Disable automatic header copying and manually copy only safe headers
+    // Opt in to automatic header copying for proxy scenarios
     server.get('/proxy', async (request, response) => {
         const gotStream = got.stream('https://example.com', {
-            copyPipedHeaders: false,
+            copyPipedHeaders: true,
+            // Explicit headers win over piped headers
             headers: {
-                'user-agent': request.headers['user-agent'],
-                'accept': request.headers['accept'],
-                // Explicitly NOT copying host, connection, authorization, etc.
+                host: 'example.com',
             }
         });
 
@@ -1187,23 +1200,40 @@ export default class Options {
     @example
     ```
     import got from 'got';
+    import {pipeline} from 'node:stream/promises';
 
-    // Override piped headers using beforeRequest hook
-    const gotStream = got.stream('https://example.com', {
-        hooks: {
-            beforeRequest: [
-                options => {
-                    // Force specific header values after piping
-                    options.headers.host = 'example.com';
-                    delete options.headers.authorization;
-                }
-            ]
-        }
+    // Keep it disabled and manually copy only safe headers
+    server.get('/proxy', async (request, response) => {
+        const gotStream = got.stream('https://example.com', {
+            headers: {
+                'user-agent': request.headers['user-agent'],
+                'accept': request.headers['accept'],
+                // Explicitly NOT copying host, connection, authorization, etc.
+            }
+        });
+
+        await pipeline(request, gotStream, response);
     });
     ```
     */
     get copyPipedHeaders(): boolean;
     set copyPipedHeaders(value: boolean);
+    isHeaderExplicitlySet(name: string): boolean;
+    shouldCopyPipedHeader(name: string): boolean;
+    setPipedHeader(name: string, value: string | string[] | undefined): void;
+    getInternalHeaders(): Headers;
+    setInternalHeader(name: string, value: string | string[] | undefined): void;
+    deleteInternalHeader(name: string): void;
+    trackStateMutations<Value>(operation: (changedState: Set<string>) => Promisable<Value>): Promise<Value>;
+    clearBody(): void;
+    stripUnchangedCrossOriginState(previousState: CrossOriginState, changedState: Set<string>, { clearBody }?: {
+        clearBody?: boolean;
+    }): void;
+    /**
+    Strip sensitive headers and credentials when navigating to a different origin.
+    Headers and credentials explicitly provided in `userOptions` are preserved.
+    */
+    stripSensitiveHeaders(previousUrl: URL, nextUrl: URL, userOptions: OptionsInit): void;
     /**
     Request headers.
 
@@ -1216,8 +1246,8 @@ export default class Options {
     /**
     Specifies if the HTTP request method should be [rewritten as `GET`](https://tools.ietf.org/html/rfc7231#section-6.4) on redirects.
 
-    As the [specification](https://tools.ietf.org/html/rfc7231#section-6.4) prefers to rewrite the HTTP method only on `303` responses, this is Got's default behavior.
-    Setting `methodRewriting` to `true` will also rewrite `301` and `302` responses, as allowed by the spec. This is the behavior followed by `curl` and browsers.
+    As the [specification](https://tools.ietf.org/html/rfc7231#section-6.4) prefers to rewrite the HTTP method only on `303` responses, this is Got's default behavior. Cross-origin `301` and `302` redirects also rewrite `POST` requests to `GET` by default to avoid forwarding request bodies to another origin.
+    Setting `methodRewriting` to `true` will also rewrite same-origin `301` and `302` responses, as allowed by the spec. This is the behavior followed by `curl` and browsers.
 
     __Note__: Got never performs method rewriting on `307` and `308` responses, as this is [explicitly prohibited by the specification](https://www.rfc-editor.org/rfc/rfc7231#section-6.4.7).
 
@@ -1305,9 +1335,9 @@ export default class Options {
     The `calculateDelay` property is a `function` that receives an object with `attemptCount`, `retryOptions`, `error` and `computedValue` properties for current retry count, the retry options, error and default computed value.
     The function must return a delay in milliseconds (or a Promise resolving with it) (`0` return value cancels retry).
 
-    The `enforceRetryRules` property is a `boolean` that, when set to `true`, enforces the `limit`, `methods`, `statusCodes`, and `errorCodes` options before calling `calculateDelay`. Your `calculateDelay` function is only invoked when a retry is allowed based on these criteria. When `false` (default), `calculateDelay` receives the computed value but can override all retry logic.
+    The `enforceRetryRules` property is a `boolean` that, when set to `true` (default), enforces the `limit`, `methods`, `statusCodes`, and `errorCodes` options before calling `calculateDelay`. Your `calculateDelay` function is only invoked when a retry is allowed based on these criteria. When `false`, `calculateDelay` receives the computed value but can override all retry logic.
 
-    __Note:__ When `enforceRetryRules` is `false`, you must check `computedValue` in your `calculateDelay` function to respect the default retry logic. When `true`, the retry rules are enforced automatically.
+    __Note:__ When `enforceRetryRules` is `false`, you must check `computedValue` in your `calculateDelay` function to respect retry rules. When `true` (default), the retry rules are enforced automatically.
 
     By default, it retries *only* on the specified methods, status codes, and on these network errors:
 
@@ -1356,7 +1386,7 @@ export default class Options {
     /**
     [Encoding](https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings) to be used on `setEncoding` of the response data.
 
-    To get a [`Buffer`](https://nodejs.org/api/buffer.html), you need to set `responseType` to `buffer` instead.
+    To get a [`Uint8Array`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array), you need to set `responseType` to `buffer` instead.
     Don't set this option to `null`.
 
     __Note__: This doesn't affect streams! Instead, you need to do `got.stream(...).setEncoding(encoding)`.
@@ -1372,13 +1402,6 @@ export default class Options {
     */
     get resolveBodyOnly(): boolean;
     set resolveBodyOnly(value: boolean);
-    /**
-    Returns a `Stream` instead of a `Promise`.
-    This is equivalent to calling `got.stream(url, options?)`.
-
-    @default false
-    */
-    get isStream(): boolean;
     set isStream(value: boolean);
     /**
     The parsing method.
@@ -1397,7 +1420,7 @@ export default class Options {
 
     const [response, buffer, json] = Promise.all([responsePromise, bufferPromise, jsonPromise]);
     // `response` is an instance of Got Response
-    // `buffer` is an instance of Buffer
+    // `buffer` is an instance of Uint8Array
     // `json` is an object
     ```
 
@@ -1430,7 +1453,7 @@ export default class Options {
     __Note__: Responses without a `content-length` header are not validated.
     __Note__: When enabled and validation fails, a `ReadError` with code `ERR_HTTP_CONTENT_LENGTH_MISMATCH` will be thrown.
 
-    @default false
+    @default true
     */
     get strictContentLength(): boolean;
     set strictContentLength(value: boolean);
@@ -1438,18 +1461,16 @@ export default class Options {
         timeout: Delays;
         headers: Headers;
         request: RequestFunction | undefined;
-        username: string;
-        password: string;
         json: unknown;
         followRedirect: boolean | ((response: PlainResponse) => boolean);
+        body: string | Uint8Array | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormData | ArrayBufferView | undefined;
+        url: string | URL | undefined;
         retry: Partial<RetryOptions>;
         agent: Agents;
         h2session: ClientHttp2Session | undefined;
         decompress: boolean;
         prefixUrl: string | URL;
-        body: string | Buffer | Readable | Generator | AsyncGenerator | Iterable<unknown> | AsyncIterable<unknown> | FormDataLike | ArrayBufferView | undefined;
         form: Record<string, any> | undefined;
-        url: string | URL | undefined;
         cookieJar: PromiseCookieJar | ToughCookieJar | undefined;
         signal: AbortSignal | undefined;
         ignoreInvalidCookies: boolean;
@@ -1461,6 +1482,8 @@ export default class Options {
         maxRedirects: number;
         cache: string | StorageAdapter | boolean | undefined;
         throwHttpErrors: boolean;
+        username: string;
+        password: string;
         http2: boolean;
         allowGetBody: boolean;
         copyPipedHeaders: boolean;
@@ -1487,7 +1510,7 @@ export default class Options {
         ALPNProtocols: string[] | undefined;
         ca: string | Buffer<ArrayBufferLike> | (string | Buffer<ArrayBufferLike>)[] | undefined;
         cert: string | Buffer<ArrayBufferLike> | (string | Buffer<ArrayBufferLike>)[] | undefined;
-        key: string | Buffer<ArrayBufferLike> | (string | Buffer<ArrayBufferLike> | import("tls").KeyObject)[] | undefined;
+        key: string | Buffer<ArrayBufferLike> | (string | Buffer<ArrayBufferLike> | import("node:tls").KeyObject)[] | undefined;
         passphrase: string | undefined;
         pfx: PfxType;
         rejectUnauthorized: boolean | undefined;
@@ -1495,8 +1518,8 @@ export default class Options {
         servername: string | undefined;
         ciphers: string | undefined;
         honorCipherOrder: boolean | undefined;
-        minVersion: import("tls").SecureVersion | undefined;
-        maxVersion: import("tls").SecureVersion | undefined;
+        minVersion: import("node:tls").SecureVersion | undefined;
+        maxVersion: import("node:tls").SecureVersion | undefined;
         sigalgs: string | undefined;
         sessionTimeout: number | undefined;
         dhparam: string | Buffer<ArrayBufferLike> | undefined;
@@ -1525,40 +1548,18 @@ export default class Options {
         createConnection: CreateConnectionFunction | undefined;
         timeout: number | undefined;
         h2session: http2wrapper.ClientHttp2Session | undefined;
-        _defaultAgent?: http.Agent | undefined;
-        auth?: string | null | undefined;
-        defaultPort?: number | string | undefined;
-        host?: string | null | undefined;
-        hostname?: string | null | undefined;
-        insecureHTTPParser?: boolean | undefined;
-        localPort?: number | undefined;
-        path?: string | null | undefined;
-        port?: number | string | null | undefined;
-        protocol?: string | null | undefined;
-        setDefaultHeaders?: boolean | undefined;
-        signal?: AbortSignal | undefined;
         socketPath?: string | undefined;
-        uniqueHeaders?: Array<string | string[]> | undefined;
-        joinDuplicateHeaders?: boolean | undefined;
-        hints?: number | undefined;
-        ALPNCallback?: ((arg: {
-            servername: string;
-            protocols: string[];
-        }) => string | undefined) | undefined;
-        allowPartialTrustChain?: boolean | undefined;
-        clientCertEngine?: string | undefined;
-        privateKeyEngine?: string | undefined;
-        privateKeyIdentifier?: string | undefined;
-        secureProtocol?: string | undefined;
-        sessionIdContext?: string | undefined;
-        ticketKeys?: Buffer | undefined;
+        path?: string | undefined;
+        host?: string | undefined;
         shared?: boolean;
         cacheHeuristic?: number;
         immutableMinTimeToLive?: number;
         ignoreCargoCult?: boolean;
     };
     getRequestFunction(): RequestFunction | typeof https.request | undefined;
-    getFallbackRequestFunction(): RequestFunction | typeof https.request | undefined;
     freeze(): void;
 }
+export declare const snapshotCrossOriginState: (options: Options) => CrossOriginState;
+export declare const isCrossOriginCredentialChanged: (previousUrl: URL, nextUrl: URL, credential: "username" | "password") => boolean;
+export declare const isBodyUnchanged: (options: Options, previousState: CrossOriginState) => boolean;
 export {};