@remotion/renderer 3.0.22 → 3.0.23

package/dist/browser/ExecutionContext.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Protocol } from 'devtools-protocol';
+import { Protocol } from 'devtools-protocol';
 import { CDPSession } from './Connection';
 import { DOMWorld } from './DOMWorld';
 import { EvaluateHandleFn, SerializableOrJSHandle } from './EvalTypes';
@@ -30,4 +30,6 @@ export declare class ExecutionContext {
     frame(): Frame | null;
     evaluate<ReturnType>(pageFunction: Function | string, ...args: unknown[]): Promise<ReturnType>;
     evaluateHandle<HandleType extends JSHandle | ElementHandle = JSHandle>(pageFunction: EvaluateHandleFn, ...args: SerializableOrJSHandle[]): Promise<HandleType>;
+    _adoptBackendNodeId(backendNodeId?: Protocol.DOM.BackendNodeId): Promise<ElementHandle>;
+    _adoptElementHandle(elementHandle: ElementHandle): Promise<ElementHandle>;
 }

package/dist/browser/ExecutionContext.js

@@ -24,6 +24,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _ExecutionContext_instances, _ExecutionContext_evaluate;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecutionContext = exports.EVALUATION_SCRIPT_URL = void 0;
+const assert_1 = require("./assert");
 const JSHandle_1 = require("./JSHandle");
 const util_1 = require("./util");
 exports.EVALUATION_SCRIPT_URL = 'pptr://__puppeteer_evaluation_script__';
@@ -45,6 +46,21 @@ class ExecutionContext {
     evaluateHandle(pageFunction, ...args) {
         return __classPrivateFieldGet(this, _ExecutionContext_instances, "m", _ExecutionContext_evaluate).call(this, false, pageFunction, ...args);
     }
+    async _adoptBackendNodeId(backendNodeId) {
+        const { object } = await this._client.send('DOM.resolveNode', {
+            backendNodeId,
+            executionContextId: this._contextId,
+        });
+        return (0, JSHandle_1._createJSHandle)(this, object);
+    }
+    async _adoptElementHandle(elementHandle) {
+        (0, assert_1.assert)(elementHandle.executionContext() !== this, 'Cannot adopt handle that already belongs to this execution context');
+        (0, assert_1.assert)(this._world, 'Cannot adopt handle without DOMWorld');
+        const nodeInfo = await this._client.send('DOM.describeNode', {
+            objectId: elementHandle._remoteObject.objectId,
+        });
+        return this._adoptBackendNodeId(nodeInfo.node.backendNodeId);
+    }
 }
 exports.ExecutionContext = ExecutionContext;
 _ExecutionContext_instances = new WeakSet(), _ExecutionContext_evaluate = async function _ExecutionContext_evaluate(returnByValue, pageFunction, ...args) {

package/dist/browser/FileChooser.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Protocol } from 'devtools-protocol';
+import { ElementHandle } from './JSHandle';
+/**
+ * File choosers let you react to the page requesting for a file.
+ * @remarks
+ * `FileChooser` objects are returned via the `page.waitForFileChooser` method.
+ * @example
+ * An example of using `FileChooser`:
+ * ```js
+ * const [fileChooser] = await Promise.all([
+ *   page.waitForFileChooser(),
+ *   page.click('#upload-file-button'), // some button that triggers file selection
+ * ]);
+ * await fileChooser.accept(['/tmp/myfile.pdf']);
+ * ```
+ * **NOTE** In browsers, only one file chooser can be opened at a time.
+ * All file choosers must be accepted or canceled. Not doing so will prevent
+ * subsequent file choosers from appearing.
+ * @public
+ */
+export declare class FileChooser {
+    #private;
+    /**
+     * @internal
+     */
+    constructor(element: ElementHandle, event: Protocol.Page.FileChooserOpenedEvent);
+    /**
+     * Whether file chooser allow for {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#attr-multiple | multiple} file selection.
+     */
+    isMultiple(): boolean;
+    /**
+     * Accept the file chooser request with given paths.
+     * @param filePaths - If some of the  `filePaths` are relative paths,
+     * then they are resolved relative to the {@link https://nodejs.org/api/process.html#process_process_cwd | current working directory}.
+     */
+    accept(filePaths: string[]): Promise<void>;
+    /**
+     * Closes the file chooser without selecting any files.
+     */
+    cancel(): void;
+}

package/dist/browser/FileChooser.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _FileChooser_element, _FileChooser_multiple, _FileChooser_handled;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileChooser = void 0;
+const assert_1 = require("./assert");
+/**
+ * File choosers let you react to the page requesting for a file.
+ * @remarks
+ * `FileChooser` objects are returned via the `page.waitForFileChooser` method.
+ * @example
+ * An example of using `FileChooser`:
+ * ```js
+ * const [fileChooser] = await Promise.all([
+ *   page.waitForFileChooser(),
+ *   page.click('#upload-file-button'), // some button that triggers file selection
+ * ]);
+ * await fileChooser.accept(['/tmp/myfile.pdf']);
+ * ```
+ * **NOTE** In browsers, only one file chooser can be opened at a time.
+ * All file choosers must be accepted or canceled. Not doing so will prevent
+ * subsequent file choosers from appearing.
+ * @public
+ */
+class FileChooser {
+    /**
+     * @internal
+     */
+    constructor(element, event) {
+        _FileChooser_element.set(this, void 0);
+        _FileChooser_multiple.set(this, void 0);
+        _FileChooser_handled.set(this, false);
+        __classPrivateFieldSet(this, _FileChooser_element, element, "f");
+        __classPrivateFieldSet(this, _FileChooser_multiple, event.mode !== 'selectSingle', "f");
+    }
+    /**
+     * Whether file chooser allow for {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#attr-multiple | multiple} file selection.
+     */
+    isMultiple() {
+        return __classPrivateFieldGet(this, _FileChooser_multiple, "f");
+    }
+    /**
+     * Accept the file chooser request with given paths.
+     * @param filePaths - If some of the  `filePaths` are relative paths,
+     * then they are resolved relative to the {@link https://nodejs.org/api/process.html#process_process_cwd | current working directory}.
+     */
+    async accept(filePaths) {
+        (0, assert_1.assert)(!__classPrivateFieldGet(this, _FileChooser_handled, "f"), 'Cannot accept FileChooser which is already handled!');
+        __classPrivateFieldSet(this, _FileChooser_handled, true, "f");
+        await __classPrivateFieldGet(this, _FileChooser_element, "f").uploadFile(...filePaths);
+    }
+    /**
+     * Closes the file chooser without selecting any files.
+     */
+    cancel() {
+        (0, assert_1.assert)(!__classPrivateFieldGet(this, _FileChooser_handled, "f"), 'Cannot cancel FileChooser which is already handled!');
+        __classPrivateFieldSet(this, _FileChooser_handled, true, "f");
+    }
+}
+exports.FileChooser = FileChooser;
+_FileChooser_element = new WeakMap(), _FileChooser_multiple = new WeakMap(), _FileChooser_handled = new WeakMap();

package/dist/browser/FrameManager.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Protocol } from 'devtools-protocol';
+import { Protocol } from 'devtools-protocol';
 import { CDPSession } from './Connection';
 import { DOMWorld } from './DOMWorld';
 import { EvaluateFn, EvaluateFnReturnType, EvaluateHandleFn, SerializableOrJSHandle, UnwrapPromiseLike } from './EvalTypes';

package/dist/browser/HTTPRequest.d.ts

@@ -13,16 +13,30 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Protocol } from 'devtools-protocol';
+import { Protocol } from 'devtools-protocol';
 import { Frame } from './FrameManager';
 import { HTTPResponse } from './HTTPResponse';
+declare type ResourceType = Lowercase<Protocol.Network.ResourceType>;
 export declare class HTTPRequest {
     #private;
     _requestId: string;
+    _failureText: string | null;
     _response: HTTPResponse | null;
     _fromMemoryCache: boolean;
-    constructor(frame: Frame | null, event: Protocol.Network.RequestWillBeSentEvent);
+    _redirectChain: HTTPRequest[];
+    constructor(frame: Frame | null, event: Protocol.Network.RequestWillBeSentEvent, redirectChain: HTTPRequest[]);
+    url(): string;
+    resourceType(): ResourceType;
+    method(): string;
+    postData(): string | undefined;
+    headers(): Record<string, string>;
     response(): HTTPResponse | null;
     frame(): Frame | null;
     isNavigationRequest(): boolean;
+    initiator(): Protocol.Network.Initiator;
+    redirectChain(): HTTPRequest[];
+    failure(): {
+        errorText: string;
+    } | null;
 }
+export {};

package/dist/browser/HTTPRequest.js

@@ -10,18 +10,49 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _HTTPRequest_isNavigationRequest, _HTTPRequest_frame;
+var _HTTPRequest_isNavigationRequest, _HTTPRequest_url, _HTTPRequest_resourceType, _HTTPRequest_method, _HTTPRequest_postData, _HTTPRequest_headers, _HTTPRequest_frame, _HTTPRequest_initiator;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HTTPRequest = void 0;
 class HTTPRequest {
-    constructor(frame, event) {
+    constructor(frame, event, redirectChain) {
+        this._failureText = null;
         this._response = null;
         this._fromMemoryCache = false;
         _HTTPRequest_isNavigationRequest.set(this, void 0);
+        _HTTPRequest_url.set(this, void 0);
+        _HTTPRequest_resourceType.set(this, void 0);
+        _HTTPRequest_method.set(this, void 0);
+        _HTTPRequest_postData.set(this, void 0);
+        _HTTPRequest_headers.set(this, {});
         _HTTPRequest_frame.set(this, void 0);
+        _HTTPRequest_initiator.set(this, void 0);
         this._requestId = event.requestId;
         __classPrivateFieldSet(this, _HTTPRequest_isNavigationRequest, event.requestId === event.loaderId && event.type === 'Document', "f");
+        __classPrivateFieldSet(this, _HTTPRequest_url, event.request.url, "f");
+        __classPrivateFieldSet(this, _HTTPRequest_resourceType, (event.type || 'other').toLowerCase(), "f");
+        __classPrivateFieldSet(this, _HTTPRequest_method, event.request.method, "f");
+        __classPrivateFieldSet(this, _HTTPRequest_postData, event.request.postData, "f");
         __classPrivateFieldSet(this, _HTTPRequest_frame, frame, "f");
+        this._redirectChain = redirectChain;
+        __classPrivateFieldSet(this, _HTTPRequest_initiator, event.initiator, "f");
+        for (const [key, value] of Object.entries(event.request.headers)) {
+            __classPrivateFieldGet(this, _HTTPRequest_headers, "f")[key.toLowerCase()] = value;
+        }
+    }
+    url() {
+        return __classPrivateFieldGet(this, _HTTPRequest_url, "f");
+    }
+    resourceType() {
+        return __classPrivateFieldGet(this, _HTTPRequest_resourceType, "f");
+    }
+    method() {
+        return __classPrivateFieldGet(this, _HTTPRequest_method, "f");
+    }
+    postData() {
+        return __classPrivateFieldGet(this, _HTTPRequest_postData, "f");
+    }
+    headers() {
+        return __classPrivateFieldGet(this, _HTTPRequest_headers, "f");
     }
     response() {
         return this._response;
@@ -32,6 +63,20 @@ class HTTPRequest {
     isNavigationRequest() {
         return __classPrivateFieldGet(this, _HTTPRequest_isNavigationRequest, "f");
     }
+    initiator() {
+        return __classPrivateFieldGet(this, _HTTPRequest_initiator, "f");
+    }
+    redirectChain() {
+        return this._redirectChain.slice();
+    }
+    failure() {
+        if (!this._failureText) {
+            return null;
+        }
+        return {
+            errorText: this._failureText,
+        };
+    }
 }
 exports.HTTPRequest = HTTPRequest;
-_HTTPRequest_isNavigationRequest = new WeakMap(), _HTTPRequest_frame = new WeakMap();
+_HTTPRequest_isNavigationRequest = new WeakMap(), _HTTPRequest_url = new WeakMap(), _HTTPRequest_resourceType = new WeakMap(), _HTTPRequest_method = new WeakMap(), _HTTPRequest_postData = new WeakMap(), _HTTPRequest_headers = new WeakMap(), _HTTPRequest_frame = new WeakMap(), _HTTPRequest_initiator = new WeakMap();

package/dist/browser/HTTPResponse.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 /**
  * Copyright 2020 Google Inc. All rights reserved.
  *
@@ -13,10 +14,87 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Protocol } from 'devtools-protocol';
+import { ProtocolMapping } from 'devtools-protocol/types/protocol-mapping';
+import { Protocol } from 'devtools-protocol';
+import { Frame } from './FrameManager';
+import { HTTPRequest } from './HTTPRequest';
+interface RemoteAddress {
+    ip?: string;
+    port?: number;
+}
+interface CDPSession {
+    send<T extends keyof ProtocolMapping.Commands>(method: T, ...paramArgs: ProtocolMapping.Commands[T]['paramsType']): Promise<ProtocolMapping.Commands[T]['returnType']>;
+}
 export declare class HTTPResponse {
     #private;
-    constructor(responsePayload: Protocol.Network.Response, extraInfo: Protocol.Network.ResponseReceivedExtraInfoEvent | null);
+    constructor(client: CDPSession, request: HTTPRequest, responsePayload: Protocol.Network.Response, extraInfo: Protocol.Network.ResponseReceivedExtraInfoEvent | null);
     _resolveBody(err: Error | null): void;
+    /**
+     * @returns The IP address and port number used to connect to the remote
+     * server.
+     */
+    remoteAddress(): RemoteAddress;
+    /**
+     * @returns The URL of the response.
+     */
+    url(): string;
+    /**
+     * @returns True if the response was successful (status in the range 200-299).
+     */
+    ok(): boolean;
+    /**
+     * @returns The status code of the response (e.g., 200 for a success).
+     */
     status(): number;
+    /**
+     * @returns  The status text of the response (e.g. usually an "OK" for a
+     * success).
+     */
+    statusText(): string;
+    /**
+     * @returns An object with HTTP headers associated with the response. All
+     * header names are lower-case.
+     */
+    headers(): Record<string, string>;
+    /**
+     * @returns Timing information related to the response.
+     */
+    timing(): Protocol.Network.ResourceTiming | null;
+    /**
+     * @returns Promise which resolves to a buffer with response body.
+     */
+    buffer(): Promise<Buffer>;
+    /**
+     * @returns Promise which resolves to a text representation of response body.
+     */
+    text(): Promise<string>;
+    /**
+     *
+     * @returns Promise which resolves to a JSON representation of response body.
+     *
+     * @remarks
+     *
+     * This method will throw if the response body is not parsable via
+     * `JSON.parse`.
+     */
+    json(): Promise<any>;
+    /**
+     * @returns A matching {@link HTTPRequest} object.
+     */
+    request(): HTTPRequest;
+    /**
+     * @returns True if the response was served from either the browser's disk
+     * cache or memory cache.
+     */
+    fromCache(): boolean;
+    /**
+     * @returns True if the response was served by a service worker.
+     */
+    fromServiceWorker(): boolean;
+    /**
+     * @returns A {@link Frame} that initiated this response, or `null` if
+     * navigating to error pages.
+     */
+    frame(): Frame | null;
 }
+export {};

package/dist/browser/HTTPResponse.js

@@ -10,14 +10,46 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _HTTPResponse_bodyLoadedPromiseFulfill, _HTTPResponse_status;
+var _HTTPResponse_instances, _HTTPResponse_client, _HTTPResponse_request, _HTTPResponse_contentPromise, _HTTPResponse_bodyLoadedPromise, _HTTPResponse_bodyLoadedPromiseFulfill, _HTTPResponse_remoteAddress, _HTTPResponse_status, _HTTPResponse_statusText, _HTTPResponse_url, _HTTPResponse_fromDiskCache, _HTTPResponse_fromServiceWorker, _HTTPResponse_headers, _HTTPResponse_timing, _HTTPResponse_parseStatusTextFromExtrInfo;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HTTPResponse = void 0;
+const Errors_1 = require("./Errors");
 class HTTPResponse {
-    constructor(responsePayload, extraInfo) {
+    constructor(client, request, responsePayload, extraInfo) {
+        _HTTPResponse_instances.add(this);
+        _HTTPResponse_client.set(this, void 0);
+        _HTTPResponse_request.set(this, void 0);
+        _HTTPResponse_contentPromise.set(this, null);
+        _HTTPResponse_bodyLoadedPromise.set(this, void 0);
         _HTTPResponse_bodyLoadedPromiseFulfill.set(this, () => undefined);
+        _HTTPResponse_remoteAddress.set(this, void 0);
         _HTTPResponse_status.set(this, void 0);
+        _HTTPResponse_statusText.set(this, void 0);
+        _HTTPResponse_url.set(this, void 0);
+        _HTTPResponse_fromDiskCache.set(this, void 0);
+        _HTTPResponse_fromServiceWorker.set(this, void 0);
+        _HTTPResponse_headers.set(this, {});
+        _HTTPResponse_timing.set(this, void 0);
+        __classPrivateFieldSet(this, _HTTPResponse_client, client, "f");
+        __classPrivateFieldSet(this, _HTTPResponse_request, request, "f");
+        __classPrivateFieldSet(this, _HTTPResponse_bodyLoadedPromise, new Promise((fulfill) => {
+            __classPrivateFieldSet(this, _HTTPResponse_bodyLoadedPromiseFulfill, fulfill, "f");
+        }), "f");
+        __classPrivateFieldSet(this, _HTTPResponse_remoteAddress, {
+            ip: responsePayload.remoteIPAddress,
+            port: responsePayload.remotePort,
+        }, "f");
+        __classPrivateFieldSet(this, _HTTPResponse_statusText, __classPrivateFieldGet(this, _HTTPResponse_instances, "m", _HTTPResponse_parseStatusTextFromExtrInfo).call(this, extraInfo) ||
+            responsePayload.statusText, "f");
+        __classPrivateFieldSet(this, _HTTPResponse_url, request.url(), "f");
+        __classPrivateFieldSet(this, _HTTPResponse_fromDiskCache, Boolean(responsePayload.fromDiskCache), "f");
+        __classPrivateFieldSet(this, _HTTPResponse_fromServiceWorker, Boolean(responsePayload.fromServiceWorker), "f");
         __classPrivateFieldSet(this, _HTTPResponse_status, extraInfo ? extraInfo.statusCode : responsePayload.status, "f");
+        const headers = extraInfo ? extraInfo.headers : responsePayload.headers;
+        for (const [key, value] of Object.entries(headers)) {
+            __classPrivateFieldGet(this, _HTTPResponse_headers, "f")[key.toLowerCase()] = value;
+        }
+        __classPrivateFieldSet(this, _HTTPResponse_timing, responsePayload.timing || null, "f");
     }
     _resolveBody(err) {
         if (err) {
@@ -25,9 +57,140 @@ class HTTPResponse {
         }
         return __classPrivateFieldGet(this, _HTTPResponse_bodyLoadedPromiseFulfill, "f").call(this);
     }
+    /**
+     * @returns The IP address and port number used to connect to the remote
+     * server.
+     */
+    remoteAddress() {
+        return __classPrivateFieldGet(this, _HTTPResponse_remoteAddress, "f");
+    }
+    /**
+     * @returns The URL of the response.
+     */
+    url() {
+        return __classPrivateFieldGet(this, _HTTPResponse_url, "f");
+    }
+    /**
+     * @returns True if the response was successful (status in the range 200-299).
+     */
+    ok() {
+        return __classPrivateFieldGet(this, _HTTPResponse_status, "f") === 0 || (__classPrivateFieldGet(this, _HTTPResponse_status, "f") >= 200 && __classPrivateFieldGet(this, _HTTPResponse_status, "f") <= 299);
+    }
+    /**
+     * @returns The status code of the response (e.g., 200 for a success).
+     */
     status() {
         return __classPrivateFieldGet(this, _HTTPResponse_status, "f");
     }
+    /**
+     * @returns  The status text of the response (e.g. usually an "OK" for a
+     * success).
+     */
+    statusText() {
+        return __classPrivateFieldGet(this, _HTTPResponse_statusText, "f");
+    }
+    /**
+     * @returns An object with HTTP headers associated with the response. All
+     * header names are lower-case.
+     */
+    headers() {
+        return __classPrivateFieldGet(this, _HTTPResponse_headers, "f");
+    }
+    /**
+     * @returns Timing information related to the response.
+     */
+    timing() {
+        return __classPrivateFieldGet(this, _HTTPResponse_timing, "f");
+    }
+    /**
+     * @returns Promise which resolves to a buffer with response body.
+     */
+    buffer() {
+        if (!__classPrivateFieldGet(this, _HTTPResponse_contentPromise, "f")) {
+            __classPrivateFieldSet(this, _HTTPResponse_contentPromise, __classPrivateFieldGet(this, _HTTPResponse_bodyLoadedPromise, "f").then(async (error) => {
+                if (error) {
+                    throw error;
+                }
+                try {
+                    const response = await __classPrivateFieldGet(this, _HTTPResponse_client, "f").send('Network.getResponseBody', {
+                        requestId: __classPrivateFieldGet(this, _HTTPResponse_request, "f")._requestId,
+                    });
+                    return Buffer.from(response.body, response.base64Encoded ? 'base64' : 'utf8');
+                }
+                catch (_error) {
+                    if (_error instanceof Errors_1.ProtocolError &&
+                        _error.originalMessage === 'No resource with given identifier found') {
+                        throw new Errors_1.ProtocolError('Could not load body for this request. This might happen if the request is a preflight request.');
+                    }
+                    throw _error;
+                }
+            }), "f");
+        }
+        return __classPrivateFieldGet(this, _HTTPResponse_contentPromise, "f");
+    }
+    /**
+     * @returns Promise which resolves to a text representation of response body.
+     */
+    async text() {
+        const content = await this.buffer();
+        return content.toString('utf8');
+    }
+    /**
+     *
+     * @returns Promise which resolves to a JSON representation of response body.
+     *
+     * @remarks
+     *
+     * This method will throw if the response body is not parsable via
+     * `JSON.parse`.
+     */
+    async json() {
+        const content = await this.text();
+        return JSON.parse(content);
+    }
+    /**
+     * @returns A matching {@link HTTPRequest} object.
+     */
+    request() {
+        return __classPrivateFieldGet(this, _HTTPResponse_request, "f");
+    }
+    /**
+     * @returns True if the response was served from either the browser's disk
+     * cache or memory cache.
+     */
+    fromCache() {
+        return __classPrivateFieldGet(this, _HTTPResponse_fromDiskCache, "f") || __classPrivateFieldGet(this, _HTTPResponse_request, "f")._fromMemoryCache;
+    }
+    /**
+     * @returns True if the response was served by a service worker.
+     */
+    fromServiceWorker() {
+        return __classPrivateFieldGet(this, _HTTPResponse_fromServiceWorker, "f");
+    }
+    /**
+     * @returns A {@link Frame} that initiated this response, or `null` if
+     * navigating to error pages.
+     */
+    frame() {
+        return __classPrivateFieldGet(this, _HTTPResponse_request, "f").frame();
+    }
 }
 exports.HTTPResponse = HTTPResponse;
-_HTTPResponse_bodyLoadedPromiseFulfill = new WeakMap(), _HTTPResponse_status = new WeakMap();
+_HTTPResponse_client = new WeakMap(), _HTTPResponse_request = new WeakMap(), _HTTPResponse_contentPromise = new WeakMap(), _HTTPResponse_bodyLoadedPromise = new WeakMap(), _HTTPResponse_bodyLoadedPromiseFulfill = new WeakMap(), _HTTPResponse_remoteAddress = new WeakMap(), _HTTPResponse_status = new WeakMap(), _HTTPResponse_statusText = new WeakMap(), _HTTPResponse_url = new WeakMap(), _HTTPResponse_fromDiskCache = new WeakMap(), _HTTPResponse_fromServiceWorker = new WeakMap(), _HTTPResponse_headers = new WeakMap(), _HTTPResponse_timing = new WeakMap(), _HTTPResponse_instances = new WeakSet(), _HTTPResponse_parseStatusTextFromExtrInfo = function _HTTPResponse_parseStatusTextFromExtrInfo(extraInfo) {
+    if (!extraInfo || !extraInfo.headersText) {
+        return;
+    }
+    const firstLine = extraInfo.headersText.split('\r', 1)[0];
+    if (!firstLine) {
+        return;
+    }
+    const match = firstLine.match(/[^ ]* [^ ]* (.*)/);
+    if (!match) {
+        return;
+    }
+    const statusText = match[1];
+    if (!statusText) {
+        return;
+    }
+    return statusText;
+};